fix some other syntax warnings

IPython/core/completerlib.py

@@ -1,354 +1,354
 # encoding: utf-8
 """Implementations for various useful completers.
 
 These are all loaded by default by IPython.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010-2011 The IPython Development Team.
 #
 #  Distributed under the terms of the BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import glob
 import inspect
 import os
 import re
 import sys
 from importlib import import_module
 from importlib.machinery import all_suffixes
 
 
 # Third-party imports
 from time import time
 from zipimport import zipimporter
 
 # Our own imports
 from IPython.core.completer import expand_user, compress_user
 from IPython.core.error import TryNext
 from IPython.utils._process_common import arg_split
 
 # FIXME: this should be pulled in with the right call via the component system
 from IPython import get_ipython
 
 from typing import List
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 _suffixes = all_suffixes()
 
 # Time in seconds after which the rootmodules will be stored permanently in the
 # ipython ip.db database (kept in the user's .ipython dir).
 TIMEOUT_STORAGE = 2
 
 # Time in seconds after which we give up
 TIMEOUT_GIVEUP = 20
 
 # Regular expression for the python import statement
 import_re = re.compile(r'(?P<name>[a-zA-Z_][a-zA-Z0-9_]*?)'
                        r'(?P<package>[/\\]__init__)?'
                        r'(?P<suffix>%s)$' %
                        r'|'.join(re.escape(s) for s in _suffixes))
 
 # RE for the ipython %run command (python + ipython scripts)
 magic_run_re = re.compile(r'.*(\.ipy|\.ipynb|\.py[w]?)$')
 
 #-----------------------------------------------------------------------------
 # Local utilities
 #-----------------------------------------------------------------------------
 
 def module_list(path):
     """
     Return the list containing the names of the modules available in the given
     folder.
     """
     # sys.path has the cwd as an empty string, but isdir/listdir need it as '.'
     if path == '':
         path = '.'
 
     # A few local constants to be used in loops below
     pjoin = os.path.join
 
     if os.path.isdir(path):
         # Build a list of all files in the directory and all files
         # in its subdirectories. For performance reasons, do not
         # recurse more than one level into subdirectories.
         files = []
         for root, dirs, nondirs in os.walk(path, followlinks=True):
             subdir = root[len(path)+1:]
             if subdir:
                 files.extend(pjoin(subdir, f) for f in nondirs)
                 dirs[:] = [] # Do not recurse into additional subdirectories.
             else:
                 files.extend(nondirs)
 
     else:
         try:
             files = list(zipimporter(path)._files.keys())
         except:
             files = []
 
     # Build a list of modules which match the import_re regex.
     modules = []
     for f in files:
         m = import_re.match(f)
         if m:
             modules.append(m.group('name'))
     return list(set(modules))
 
 
 def get_root_modules():
     """
     Returns a list containing the names of all the modules available in the
     folders of the pythonpath.
 
     ip.db['rootmodules_cache'] maps sys.path entries to list of modules.
     """
     ip = get_ipython()
     if ip is None:
         # No global shell instance to store cached list of modules.
         # Don't try to scan for modules every time.
         return list(sys.builtin_module_names)
 
     rootmodules_cache = ip.db.get('rootmodules_cache', {})
     rootmodules = list(sys.builtin_module_names)
     start_time = time()
     store = False
     for path in sys.path:
         try:
             modules = rootmodules_cache[path]
         except KeyError:
             modules = module_list(path)
             try:
                 modules.remove('__init__')
             except ValueError:
                 pass
             if path not in ('', '.'): # cwd modules should not be cached
                 rootmodules_cache[path] = modules
             if time() - start_time > TIMEOUT_STORAGE and not store:
                 store = True
                 print("\nCaching the list of root modules, please wait!")
                 print("(This will only be done once - type '%rehashx' to "
                       "reset cache!)\n")
                 sys.stdout.flush()
             if time() - start_time > TIMEOUT_GIVEUP:
                 print("This is taking too long, we give up.\n")
                 return []
         rootmodules.extend(modules)
     if store:
         ip.db['rootmodules_cache'] = rootmodules_cache
     rootmodules = list(set(rootmodules))
     return rootmodules
 
 
 def is_importable(module, attr, only_modules):
     if only_modules:
         return inspect.ismodule(getattr(module, attr))
     else:
         return not(attr[:2] == '__' and attr[-2:] == '__')
 
 
 def try_import(mod: str, only_modules=False) -> List[str]:
     """
     Try to import given module and return list of potential completions.
     """
     mod = mod.rstrip('.')
     try:
         m = import_module(mod)
     except:
         return []
 
     m_is_init = '__init__' in (getattr(m, '__file__', '') or '')
 
     completions = []
     if (not hasattr(m, '__file__')) or (not only_modules) or m_is_init:
         completions.extend( [attr for attr in dir(m) if
                              is_importable(m, attr, only_modules)])
 
     completions.extend(getattr(m, '__all__', []))
     if m_is_init:
         completions.extend(module_list(os.path.dirname(m.__file__)))
     completions_set = {c for c in completions if isinstance(c, str)}
     completions_set.discard('__init__')
     return list(completions_set)
 
 
 #-----------------------------------------------------------------------------
 # Completion-related functions.
 #-----------------------------------------------------------------------------
 
 def quick_completer(cmd, completions):
-    """ Easily create a trivial completer for a command.
+    r""" Easily create a trivial completer for a command.
 
     Takes either a list of completions, or all completions in string (that will
     be split on whitespace).
 
     Example::
 
         [d:\ipython]|1> import ipy_completers
         [d:\ipython]|2> ipy_completers.quick_completer('foo', ['bar','baz'])
         [d:\ipython]|3> foo b<TAB>
         bar baz
         [d:\ipython]|3> foo ba
     """
 
     if isinstance(completions, str):
         completions = completions.split()
 
     def do_complete(self, event):
         return completions
 
     get_ipython().set_hook('complete_command',do_complete, str_key = cmd)
 
 def module_completion(line):
     """
     Returns a list containing the completion possibilities for an import line.
 
     The line looks like this :
     'import xml.d'
     'from xml.dom import'
     """
 
     words = line.split(' ')
     nwords = len(words)
 
     # from whatever <tab> -> 'import '
     if nwords == 3 and words[0] == 'from':
         return ['import ']
 
     # 'from xy<tab>' or 'import xy<tab>'
     if nwords < 3 and (words[0] in {'%aimport', 'import', 'from'}) :
         if nwords == 1:
             return get_root_modules()
         mod = words[1].split('.')
         if len(mod) < 2:
             return get_root_modules()
         completion_list = try_import('.'.join(mod[:-1]), True)
         return ['.'.join(mod[:-1] + [el]) for el in completion_list]
 
     # 'from xyz import abc<tab>'
     if nwords >= 3 and words[0] == 'from':
         mod = words[1]
         return try_import(mod)
 
 #-----------------------------------------------------------------------------
 # Completers
 #-----------------------------------------------------------------------------
 # These all have the func(self, event) signature to be used as custom
 # completers
 
 def module_completer(self,event):
     """Give completions after user has typed 'import ...' or 'from ...'"""
 
     # This works in all versions of python.  While 2.5 has
     # pkgutil.walk_packages(), that particular routine is fairly dangerous,
     # since it imports *EVERYTHING* on sys.path.  That is: a) very slow b) full
     # of possibly problematic side effects.
     # This search the folders in the sys.path for available modules.
 
     return module_completion(event.line)
 
 # FIXME: there's a lot of logic common to the run, cd and builtin file
 # completers, that is currently reimplemented in each.
 
 def magic_run_completer(self, event):
     """Complete files that end in .py or .ipy or .ipynb for the %run command.
     """
     comps = arg_split(event.line, strict=False)
     # relpath should be the current token that we need to complete.
     if (len(comps) > 1) and (not event.line.endswith(' ')):
         relpath = comps[-1].strip("'\"")
     else:
         relpath = ''
 
     #print("\nev=", event)  # dbg
     #print("rp=", relpath)  # dbg
     #print('comps=', comps)  # dbg
 
     lglob = glob.glob
     isdir = os.path.isdir
     relpath, tilde_expand, tilde_val = expand_user(relpath)
 
     # Find if the user has already typed the first filename, after which we
     # should complete on all files, since after the first one other files may
     # be arguments to the input script.
 
     if any(magic_run_re.match(c) for c in comps):
         matches =  [f.replace('\\','/') + ('/' if isdir(f) else '')
                             for f in lglob(relpath+'*')]
     else:
         dirs = [f.replace('\\','/') + "/" for f in lglob(relpath+'*') if isdir(f)]
         pys =  [f.replace('\\','/')
                 for f in lglob(relpath+'*.py') + lglob(relpath+'*.ipy') +
                 lglob(relpath+'*.ipynb') + lglob(relpath + '*.pyw')]
 
         matches = dirs + pys
 
     #print('run comp:', dirs+pys) # dbg
     return [compress_user(p, tilde_expand, tilde_val) for p in matches]
 
 
 def cd_completer(self, event):
     """Completer function for cd, which only returns directories."""
     ip = get_ipython()
     relpath = event.symbol
 
     #print(event) # dbg
     if event.line.endswith('-b') or ' -b ' in event.line:
         # return only bookmark completions
         bkms = self.db.get('bookmarks', None)
         if bkms:
             return bkms.keys()
         else:
             return []
 
     if event.symbol == '-':
         width_dh = str(len(str(len(ip.user_ns['_dh']) + 1)))
         # jump in directory history by number
         fmt = '-%0' + width_dh +'d [%s]'
         ents = [ fmt % (i,s) for i,s in enumerate(ip.user_ns['_dh'])]
         if len(ents) > 1:
             return ents
         return []
 
     if event.symbol.startswith('--'):
         return ["--" + os.path.basename(d) for d in ip.user_ns['_dh']]
 
     # Expand ~ in path and normalize directory separators.
     relpath, tilde_expand, tilde_val = expand_user(relpath)
     relpath = relpath.replace('\\','/')
 
     found = []
     for d in [f.replace('\\','/') + '/' for f in glob.glob(relpath+'*')
               if os.path.isdir(f)]:
         if ' ' in d:
             # we don't want to deal with any of that, complex code
             # for this is elsewhere
             raise TryNext
 
         found.append(d)
 
     if not found:
         if os.path.isdir(relpath):
             return [compress_user(relpath, tilde_expand, tilde_val)]
 
         # if no completions so far, try bookmarks
         bks = self.db.get('bookmarks',{})
         bkmatches = [s for s in bks if s.startswith(event.symbol)]
         if bkmatches:
             return bkmatches
 
         raise TryNext
 
     return [compress_user(p, tilde_expand, tilde_val) for p in found]
 
 def reset_completer(self, event):
     "A completer for %reset magic"
     return '-f -s in out array dhist'.split()

IPython/core/display.py

@@ -1,1466 +1,1466
 # -*- coding: utf-8 -*-
 """Top-level display functions for displaying object in different formats."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 from binascii import b2a_hex, b2a_base64, hexlify
 import json
 import mimetypes
 import os
 import struct
 import sys
 import warnings
 from copy import deepcopy
 
 from IPython.utils.py3compat import cast_unicode
 from IPython.testing.skipdoctest import skip_doctest
 
 __all__ = ['display', 'display_pretty', 'display_html', 'display_markdown',
 'display_svg', 'display_png', 'display_jpeg', 'display_latex', 'display_json',
 'display_javascript', 'display_pdf', 'DisplayObject', 'TextDisplayObject',
 'Pretty', 'HTML', 'Markdown', 'Math', 'Latex', 'SVG', 'ProgressBar', 'JSON',
 'GeoJSON', 'Javascript', 'Image', 'clear_output', 'set_matplotlib_formats',
 'set_matplotlib_close', 'publish_display_data', 'update_display', 'DisplayHandle',
 'Video']
 
 #-----------------------------------------------------------------------------
 # utility functions
 #-----------------------------------------------------------------------------
 
 def _safe_exists(path):
     """Check path, but don't let exceptions raise"""
     try:
         return os.path.exists(path)
     except Exception:
         return False
 
 def _merge(d1, d2):
     """Like update, but merges sub-dicts instead of clobbering at the top level.
 
     Updates d1 in-place
     """
 
     if not isinstance(d2, dict) or not isinstance(d1, dict):
         return d2
     for key, value in d2.items():
         d1[key] = _merge(d1.get(key), value)
     return d1
 
 def _display_mimetype(mimetype, objs, raw=False, metadata=None):
     """internal implementation of all display_foo methods
 
     Parameters
     ----------
     mimetype : str
         The mimetype to be published (e.g. 'image/png')
     objs : tuple of objects
         The Python objects to display, or if raw=True raw text data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
     if metadata:
         metadata = {mimetype: metadata}
     if raw:
         # turn list of pngdata into list of { 'image/png': pngdata }
         objs = [ {mimetype: obj} for obj in objs ]
     display(*objs, raw=raw, metadata=metadata, include=[mimetype])
 
 #-----------------------------------------------------------------------------
 # Main functions
 #-----------------------------------------------------------------------------
 
 # use * to indicate transient is keyword-only
 def publish_display_data(data, metadata=None, source=None, *, transient=None, **kwargs):
     """Publish data and metadata to all frontends.
 
     See the ``display_data`` message in the messaging documentation for
     more details about this message type.
 
     Keys of data and metadata can be any mime-type.
 
     Parameters
     ----------
     data : dict
         A dictionary having keys that are valid MIME types (like
         'text/plain' or 'image/svg+xml') and values that are the data for
         that MIME type. The data itself must be a JSON'able data
         structure. Minimally all data should have the 'text/plain' data,
         which can be displayed by all frontends. If more than the plain
         text is given, it is up to the frontend to decide which
         representation to use.
     metadata : dict
         A dictionary for metadata related to the data. This can contain
         arbitrary key, value pairs that frontends can use to interpret
         the data. mime-type keys matching those in data can be used
         to specify metadata about particular representations.
     source : str, deprecated
         Unused.
     transient : dict, keyword-only
         A dictionary of transient data, such as display_id.
         """
     from IPython.core.interactiveshell import InteractiveShell
 
     display_pub = InteractiveShell.instance().display_pub
 
     # only pass transient if supplied,
     # to avoid errors with older ipykernel.
     # TODO: We could check for ipykernel version and provide a detailed upgrade message.
     if transient:
         kwargs['transient'] = transient
 
     display_pub.publish(
         data=data,
         metadata=metadata,
         **kwargs
     )
 
 
 def _new_id():
     """Generate a new random text id with urandom"""
     return b2a_hex(os.urandom(16)).decode('ascii')
 
 
 def display(*objs, include=None, exclude=None, metadata=None, transient=None, display_id=None, **kwargs):
     """Display a Python object in all frontends.
 
     By default all representations will be computed and sent to the frontends.
     Frontends can decide which representation is used and how.
 
     In terminal IPython this will be similar to using :func:`print`, for use in richer
     frontends see Jupyter notebook examples with rich display logic.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display.
     raw : bool, optional
         Are the objects to be displayed already mimetype-keyed dicts of raw display data,
         or Python objects that need to be formatted before display? [default: False]
     include : list, tuple or set, optional
         A list of format type strings (MIME types) to include in the
         format data dict. If this is set *only* the format types included
         in this list will be computed.
     exclude : list, tuple or set, optional
         A list of format type strings (MIME types) to exclude in the format
         data dict. If this is set all format types will be computed,
         except for those included in this argument.
     metadata : dict, optional
         A dictionary of metadata to associate with the output.
         mime-type keys in this dictionary will be associated with the individual
         representation formats, if they exist.
     transient : dict, optional
         A dictionary of transient data to associate with the output.
         Data in this dict should not be persisted to files (e.g. notebooks).
     display_id : str, bool optional
         Set an id for the display.
         This id can be used for updating this display area later via update_display.
         If given as `True`, generate a new `display_id`
     kwargs: additional keyword-args, optional
         Additional keyword-arguments are passed through to the display publisher.
 
     Returns
     -------
 
     handle: DisplayHandle
         Returns a handle on updatable displays for use with :func:`update_display`,
         if `display_id` is given. Returns :any:`None` if no `display_id` is given
         (default).
 
     Examples
     --------
 
     >>> class Json(object):
     ...     def __init__(self, json):
     ...         self.json = json
     ...     def _repr_pretty_(self, pp, cycle):
     ...         import json
     ...         pp.text(json.dumps(self.json, indent=2))
     ...     def __repr__(self):
     ...         return str(self.json)
     ...
 
     >>> d = Json({1:2, 3: {4:5}})
 
     >>> print(d)
     {1: 2, 3: {4: 5}}
 
     >>> display(d)
     {
       "1": 2,
       "3": {
         "4": 5
       }
     }
 
     >>> def int_formatter(integer, pp, cycle):
     ...     pp.text('I'*integer)
 
     >>> plain = get_ipython().display_formatter.formatters['text/plain']
     >>> plain.for_type(int, int_formatter)
     <function _repr_pprint at 0x...>
     >>> display(7-5)
     II
 
     >>> del plain.type_printers[int]
     >>> display(7-5)
     2
 
     See Also
     --------
 
     :func:`update_display`
 
     Notes
     -----
 
     In Python, objects can declare their textual representation using the
     `__repr__` method. IPython expands on this idea and allows objects to declare
     other, rich representations including:
 
       - HTML
       - JSON
       - PNG
       - JPEG
       - SVG
       - LaTeX
 
     A single object can declare some or all of these representations; all are
     handled by IPython's display system.
 
     The main idea of the first approach is that you have to implement special
     display methods when you define your class, one for each representation you
     want to use. Here is a list of the names of the special methods and the
     values they must return:
 
       - `_repr_html_`: return raw HTML as a string, or a tuple (see below).
       - `_repr_json_`: return a JSONable dict, or a tuple (see below).
       - `_repr_jpeg_`: return raw JPEG data, or a tuple (see below).
       - `_repr_png_`: return raw PNG data, or a tuple (see below).
       - `_repr_svg_`: return raw SVG data as a string, or a tuple (see below).
       - `_repr_latex_`: return LaTeX commands in a string surrounded by "$",
                         or a tuple (see below).
       - `_repr_mimebundle_`: return a full mimebundle containing the mapping
                              from all mimetypes to data.
                              Use this for any mime-type not listed above.
 
     The above functions may also return the object's metadata alonside the
     data.  If the metadata is available, the functions will return a tuple
     containing the data and metadata, in that order.  If there is no metadata
     available, then the functions will return the data only.
 
     When you are directly writing your own classes, you can adapt them for
     display in IPython by following the above approach. But in practice, you
     often need to work with existing classes that you can't easily modify.
 
     You can refer to the documentation on integrating with the display system in
     order to register custom formatters for already existing types
     (:ref:`integrating_rich_display`).
 
     .. versionadded:: 5.4 display available without import
     .. versionadded:: 6.1 display available without import
 
     Since IPython 5.4 and 6.1 :func:`display` is automatically made available to
     the user without import. If you are using display in a document that might
     be used in a pure python context or with older version of IPython, use the
     following import at the top of your file::
 
         from IPython.display import display
 
     """
     from IPython.core.interactiveshell import InteractiveShell
     
     if not InteractiveShell.initialized():
         # Directly print objects.
         print(*objs)
         return
     
     raw = kwargs.pop('raw', False)
     if transient is None:
         transient = {}
     if metadata is None:
         metadata={}
     if display_id:
         if display_id is True:
             display_id = _new_id()
         transient['display_id'] = display_id
     if kwargs.get('update') and 'display_id' not in transient:
         raise TypeError('display_id required for update_display')
     if transient:
         kwargs['transient'] = transient
 
     if not raw:
         format = InteractiveShell.instance().display_formatter.format
 
     for obj in objs:
         if raw:
             publish_display_data(data=obj, metadata=metadata, **kwargs)
         else:
             format_dict, md_dict = format(obj, include=include, exclude=exclude)
             if not format_dict:
                 # nothing to display (e.g. _ipython_display_ took over)
                 continue
             if metadata:
                 # kwarg-specified metadata gets precedence
                 _merge(md_dict, metadata)
             publish_display_data(data=format_dict, metadata=md_dict, **kwargs)
     if display_id:
         return DisplayHandle(display_id)
 
 
 # use * for keyword-only display_id arg
 def update_display(obj, *, display_id, **kwargs):
     """Update an existing display by id
 
     Parameters
     ----------
 
     obj:
         The object with which to update the display
     display_id: keyword-only
         The id of the display to update
 
     See Also
     --------
 
     :func:`display`
     """
     kwargs['update'] = True
     display(obj, display_id=display_id, **kwargs)
 
 
 class DisplayHandle(object):
     """A handle on an updatable display
 
     Call `.update(obj)` to display a new object.
 
     Call `.display(obj`) to add a new instance of this display,
     and update existing instances.
 
     See Also
     --------
 
         :func:`display`, :func:`update_display`
 
     """
 
     def __init__(self, display_id=None):
         if display_id is None:
             display_id = _new_id()
         self.display_id = display_id
 
     def __repr__(self):
         return "<%s display_id=%s>" % (self.__class__.__name__, self.display_id)
 
     def display(self, obj, **kwargs):
         """Make a new display with my id, updating existing instances.
         
         Parameters
         ----------
         
         obj:
             object to display
         **kwargs:
             additional keyword arguments passed to display
         """
         display(obj, display_id=self.display_id, **kwargs)
 
     def update(self, obj, **kwargs):
         """Update existing displays with my id
         
         Parameters
         ----------
         
         obj:
             object to display
         **kwargs:
             additional keyword arguments passed to update_display
         """
         update_display(obj, display_id=self.display_id, **kwargs)
 
 
 def display_pretty(*objs, **kwargs):
     """Display the pretty (default) representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw text data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
     _display_mimetype('text/plain', objs, **kwargs)
 
 
 def display_html(*objs, **kwargs):
     """Display the HTML representation of an object.
 
     Note: If raw=False and the object does not have a HTML
     representation, no HTML will be shown.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw HTML data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
     _display_mimetype('text/html', objs, **kwargs)
 
 
 def display_markdown(*objs, **kwargs):
     """Displays the Markdown representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw markdown data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
 
     _display_mimetype('text/markdown', objs, **kwargs)
 
 
 def display_svg(*objs, **kwargs):
     """Display the SVG representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw svg data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
     _display_mimetype('image/svg+xml', objs, **kwargs)
 
 
 def display_png(*objs, **kwargs):
     """Display the PNG representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw png data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
     _display_mimetype('image/png', objs, **kwargs)
 
 
 def display_jpeg(*objs, **kwargs):
     """Display the JPEG representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw JPEG data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
     _display_mimetype('image/jpeg', objs, **kwargs)
 
 
 def display_latex(*objs, **kwargs):
     """Display the LaTeX representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw latex data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
     _display_mimetype('text/latex', objs, **kwargs)
 
 
 def display_json(*objs, **kwargs):
     """Display the JSON representation of an object.
 
     Note that not many frontends support displaying JSON.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw json data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
     _display_mimetype('application/json', objs, **kwargs)
 
 
 def display_javascript(*objs, **kwargs):
     """Display the Javascript representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw javascript data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
     _display_mimetype('application/javascript', objs, **kwargs)
 
 
 def display_pdf(*objs, **kwargs):
     """Display the PDF representation of an object.
 
     Parameters
     ----------
     objs : tuple of objects
         The Python objects to display, or if raw=True raw javascript data to
         display.
     raw : bool
         Are the data objects raw data or Python objects that need to be
         formatted before display? [default: False]
     metadata : dict (optional)
         Metadata to be associated with the specific mimetype output.
     """
     _display_mimetype('application/pdf', objs, **kwargs)
 
 
 #-----------------------------------------------------------------------------
 # Smart classes
 #-----------------------------------------------------------------------------
 
 
 class DisplayObject(object):
     """An object that wraps data to be displayed."""
 
     _read_flags = 'r'
     _show_mem_addr = False
     metadata = None
 
     def __init__(self, data=None, url=None, filename=None, metadata=None):
         """Create a display object given raw data.
 
         When this object is returned by an expression or passed to the
         display function, it will result in the data being displayed
         in the frontend. The MIME type of the data should match the
         subclasses used, so the Png subclass should be used for 'image/png'
         data. If the data is a URL, the data will first be downloaded
         and then displayed. If
 
         Parameters
         ----------
         data : unicode, str or bytes
             The raw data or a URL or file to load the data from
         url : unicode
             A URL to download the data from.
         filename : unicode
             Path to a local file to load the data from.
         metadata : dict
             Dict of metadata associated to be the object when displayed
         """
         if data is not None and isinstance(data, str):
             if data.startswith('http') and url is None:
                 url = data
                 filename = None
                 data = None
             elif _safe_exists(data) and filename is None:
                 url = None
                 filename = data
                 data = None
 
         self.data = data
         self.url = url
         self.filename = filename
 
         if metadata is not None:
             self.metadata = metadata
         elif self.metadata is None:
             self.metadata = {}
 
         self.reload()
         self._check_data()
 
     def __repr__(self):
         if not self._show_mem_addr:
             cls = self.__class__
             r = "<%s.%s object>" % (cls.__module__, cls.__name__)
         else:
             r = super(DisplayObject, self).__repr__()
         return r
 
     def _check_data(self):
         """Override in subclasses if there's something to check."""
         pass
 
     def _data_and_metadata(self):
         """shortcut for returning metadata with shape information, if defined"""
         if self.metadata:
             return self.data, deepcopy(self.metadata)
         else:
             return self.data
 
     def reload(self):
         """Reload the raw data from file or URL."""
         if self.filename is not None:
             with open(self.filename, self._read_flags) as f:
                 self.data = f.read()
         elif self.url is not None:
             try:
                 # Deferred import
                 from urllib.request import urlopen
                 response = urlopen(self.url)
                 self.data = response.read()
                 # extract encoding from header, if there is one:
                 encoding = None
                 for sub in response.headers['content-type'].split(';'):
                     sub = sub.strip()
                     if sub.startswith('charset'):
                         encoding = sub.split('=')[-1].strip()
                         break
                 # decode data, if an encoding was specified
                 if encoding:
                     self.data = self.data.decode(encoding, 'replace')
             except:
                 self.data = None
 
 class TextDisplayObject(DisplayObject):
     """Validate that display data is text"""
     def _check_data(self):
         if self.data is not None and not isinstance(self.data, str):
             raise TypeError("%s expects text, not %r" % (self.__class__.__name__, self.data))
 
 class Pretty(TextDisplayObject):
 
     def _repr_pretty_(self, pp, cycle):
         return pp.text(self.data)
 
 
 class HTML(TextDisplayObject):
 
     def __init__(self, data=None, url=None, filename=None, metadata=None):
         def warn():
             if not data:
                 return False
 
             #
             # Avoid calling lower() on the entire data, because it could be a
             # long string and we're only interested in its beginning and end.
             #
             prefix = data[:10].lower()
             suffix = data[-10:].lower()
             return prefix.startswith("<iframe ") and suffix.endswith("</iframe>")
 
         if warn():
             warnings.warn("Consider using IPython.display.IFrame instead")
         super(HTML, self).__init__(data=data, url=url, filename=filename, metadata=metadata)
 
     def _repr_html_(self):
         return self._data_and_metadata()
 
     def __html__(self):
         """
         This method exists to inform other HTML-using modules (e.g. Markupsafe,
         htmltag, etc) that this object is HTML and does not need things like
         special characters (<>&) escaped.
         """
         return self._repr_html_()
 
 
 class Markdown(TextDisplayObject):
 
     def _repr_markdown_(self):
         return self._data_and_metadata()
 
 
 class Math(TextDisplayObject):
 
     def _repr_latex_(self):
-        s = "$\displaystyle %s$" % self.data.strip('$')
+        s = r"$\displaystyle %s$" % self.data.strip('$')
         if self.metadata:
             return s, deepcopy(self.metadata)
         else:
             return s
 
 
 class Latex(TextDisplayObject):
 
     def _repr_latex_(self):
         return self._data_and_metadata()
 
 
 class SVG(DisplayObject):
 
     _read_flags = 'rb'
     # wrap data in a property, which extracts the <svg> tag, discarding
     # document headers
     _data = None
 
     @property
     def data(self):
         return self._data
 
     @data.setter
     def data(self, svg):
         if svg is None:
             self._data = None
             return
         # parse into dom object
         from xml.dom import minidom
         x = minidom.parseString(svg)
         # get svg tag (should be 1)
         found_svg = x.getElementsByTagName('svg')
         if found_svg:
             svg = found_svg[0].toxml()
         else:
             # fallback on the input, trust the user
             # but this is probably an error.
             pass
         svg = cast_unicode(svg)
         self._data = svg
     
     def _repr_svg_(self):
         return self._data_and_metadata()
 
 class ProgressBar(DisplayObject):
     """Progressbar supports displaying a progressbar like element 
     """
     def __init__(self, total):
         """Creates a new progressbar
         
         Parameters
         ----------
         total : int
             maximum size of the progressbar
         """
         self.total = total
         self._progress = 0
         self.html_width = '60ex'
         self.text_width = 60
         self._display_id = hexlify(os.urandom(8)).decode('ascii')
 
     def __repr__(self):
         fraction = self.progress / self.total
         filled = '=' * int(fraction * self.text_width)
         rest = ' ' * (self.text_width - len(filled))
         return '[{}{}] {}/{}'.format(
             filled, rest,
             self.progress, self.total,
         )
 
     def _repr_html_(self):
         return "<progress style='width:{}' max='{}' value='{}'></progress>".format(
             self.html_width, self.total, self.progress)
 
     def display(self):
         display(self, display_id=self._display_id)
 
     def update(self):
         display(self, display_id=self._display_id, update=True)
 
     @property
     def progress(self):
         return self._progress
 
     @progress.setter
     def progress(self, value):
         self._progress = value
         self.update()
 
     def __iter__(self):
         self.display()
         self._progress = -1 # First iteration is 0
         return self
 
     def __next__(self):
         """Returns current value and increments display by one."""
         self.progress += 1
         if self.progress < self.total:
             return self.progress
         else:
             raise StopIteration()
 
 class JSON(DisplayObject):
     """JSON expects a JSON-able dict or list
 
     not an already-serialized JSON string.
 
     Scalar types (None, number, string) are not allowed, only dict or list containers.
     """
     # wrap data in a property, which warns about passing already-serialized JSON
     _data = None
     def __init__(self, data=None, url=None, filename=None, expanded=False, metadata=None, root='root', **kwargs):
         """Create a JSON display object given raw data.
 
         Parameters
         ----------
         data : dict or list
             JSON data to display. Not an already-serialized JSON string.
             Scalar types (None, number, string) are not allowed, only dict
             or list containers.
         url : unicode
             A URL to download the data from.
         filename : unicode
             Path to a local file to load the data from.
         expanded : boolean
             Metadata to control whether a JSON display component is expanded.
         metadata: dict
             Specify extra metadata to attach to the json display object.
         root : str
             The name of the root element of the JSON tree 
         """
         self.metadata = {
             'expanded': expanded,
             'root': root,
         }
         if metadata:
             self.metadata.update(metadata)
         if kwargs:
             self.metadata.update(kwargs)
         super(JSON, self).__init__(data=data, url=url, filename=filename)
 
     def _check_data(self):
         if self.data is not None and not isinstance(self.data, (dict, list)):
             raise TypeError("%s expects JSONable dict or list, not %r" % (self.__class__.__name__, self.data))
 
     @property
     def data(self):
         return self._data
 
     @data.setter
     def data(self, data):
         if isinstance(data, str):
             if getattr(self, 'filename', None) is None:
                 warnings.warn("JSON expects JSONable dict or list, not JSON strings")
             data = json.loads(data)
         self._data = data
 
     def _data_and_metadata(self):
         return self.data, self.metadata
 
     def _repr_json_(self):
         return self._data_and_metadata()
 
 _css_t = """var link = document.createElement("link");
 	link.ref = "stylesheet";
 	link.type = "text/css";
 	link.href = "%s";
 	document.head.appendChild(link);
 """
 
 _lib_t1 = """new Promise(function(resolve, reject) {
 	var script = document.createElement("script");
 	script.onload = resolve;
 	script.onerror = reject;
 	script.src = "%s";
 	document.head.appendChild(script);
 }).then(() => {
 """
 
 _lib_t2 = """
 });"""
 
 class GeoJSON(JSON):
     """GeoJSON expects JSON-able dict
 
     not an already-serialized JSON string.
 
     Scalar types (None, number, string) are not allowed, only dict containers.
     """
     
     def __init__(self, *args, **kwargs):
         """Create a GeoJSON display object given raw data.
 
         Parameters
         ----------
         data : dict or list
             VegaLite data. Not an already-serialized JSON string.
             Scalar types (None, number, string) are not allowed, only dict
             or list containers.
         url_template : string
             Leaflet TileLayer URL template: http://leafletjs.com/reference.html#url-template
         layer_options : dict
             Leaflet TileLayer options: http://leafletjs.com/reference.html#tilelayer-options
         url : unicode
             A URL to download the data from.
         filename : unicode
             Path to a local file to load the data from.
         metadata: dict
             Specify extra metadata to attach to the json display object.
 
         Examples
         --------
 
         The following will display an interactive map of Mars with a point of
         interest on frontend that do support GeoJSON display.
 
             >>> from IPython.display import GeoJSON
 
             >>> GeoJSON(data={
             ...     "type": "Feature",
             ...     "geometry": {
             ...         "type": "Point",
             ...         "coordinates": [-81.327, 296.038]
             ...     }
             ... },
             ... url_template="http://s3-eu-west-1.amazonaws.com/whereonmars.cartodb.net/{basemap_id}/{z}/{x}/{y}.png",
             ... layer_options={
             ...     "basemap_id": "celestia_mars-shaded-16k_global",
             ...     "attribution" : "Celestia/praesepe",
             ...     "minZoom" : 0,
             ...     "maxZoom" : 18,
             ... })
             <IPython.core.display.GeoJSON object>
 
         In the terminal IPython, you will only see the text representation of
         the GeoJSON object.
 
         """
         
         super(GeoJSON, self).__init__(*args, **kwargs)
 
 
     def _ipython_display_(self):
         bundle = {
             'application/geo+json': self.data,
             'text/plain': '<IPython.display.GeoJSON object>'
         }
         metadata = {
             'application/geo+json': self.metadata
         }
         display(bundle, metadata=metadata, raw=True)
 
 class Javascript(TextDisplayObject):
 
     def __init__(self, data=None, url=None, filename=None, lib=None, css=None):
         """Create a Javascript display object given raw data.
 
         When this object is returned by an expression or passed to the
         display function, it will result in the data being displayed
         in the frontend. If the data is a URL, the data will first be
         downloaded and then displayed.
 
         In the Notebook, the containing element will be available as `element`,
         and jQuery will be available.  Content appended to `element` will be
         visible in the output area.
 
         Parameters
         ----------
         data : unicode, str or bytes
             The Javascript source code or a URL to download it from.
         url : unicode
             A URL to download the data from.
         filename : unicode
             Path to a local file to load the data from.
         lib : list or str
             A sequence of Javascript library URLs to load asynchronously before
             running the source code. The full URLs of the libraries should
             be given. A single Javascript library URL can also be given as a
             string.
         css: : list or str
             A sequence of css files to load before running the source code.
             The full URLs of the css files should be given. A single css URL
             can also be given as a string.
         """
         if isinstance(lib, str):
             lib = [lib]
         elif lib is None:
             lib = []
         if isinstance(css, str):
             css = [css]
         elif css is None:
             css = []
         if not isinstance(lib, (list,tuple)):
             raise TypeError('expected sequence, got: %r' % lib)
         if not isinstance(css, (list,tuple)):
             raise TypeError('expected sequence, got: %r' % css)
         self.lib = lib
         self.css = css
         super(Javascript, self).__init__(data=data, url=url, filename=filename)
 
     def _repr_javascript_(self):
         r = ''
         for c in self.css:
             r += _css_t % c
         for l in self.lib:
             r += _lib_t1 % l
         r += self.data
         r += _lib_t2*len(self.lib)
         return r
 
 # constants for identifying png/jpeg data
 _PNG = b'\x89PNG\r\n\x1a\n'
 _JPEG = b'\xff\xd8'
 
 def _pngxy(data):
     """read the (width, height) from a PNG header"""
     ihdr = data.index(b'IHDR')
     # next 8 bytes are width/height
     return struct.unpack('>ii', data[ihdr+4:ihdr+12])
 
 def _jpegxy(data):
     """read the (width, height) from a JPEG header"""
     # adapted from http://www.64lines.com/jpeg-width-height
 
     idx = 4
     while True:
         block_size = struct.unpack('>H', data[idx:idx+2])[0]
         idx = idx + block_size
         if data[idx:idx+2] == b'\xFF\xC0':
             # found Start of Frame
             iSOF = idx
             break
         else:
             # read another block
             idx += 2
 
     h, w = struct.unpack('>HH', data[iSOF+5:iSOF+9])
     return w, h
 
 def _gifxy(data):
     """read the (width, height) from a GIF header"""
     return struct.unpack('<HH', data[6:10])
 
 
 class Image(DisplayObject):
 
     _read_flags = 'rb'
     _FMT_JPEG = u'jpeg'
     _FMT_PNG = u'png'
     _FMT_GIF = u'gif'
     _ACCEPTABLE_EMBEDDINGS = [_FMT_JPEG, _FMT_PNG, _FMT_GIF]
     _MIMETYPES = {
         _FMT_PNG: 'image/png',
         _FMT_JPEG: 'image/jpeg',
         _FMT_GIF: 'image/gif',
     }
 
     def __init__(self, data=None, url=None, filename=None, format=None,
                  embed=None, width=None, height=None, retina=False,
                  unconfined=False, metadata=None):
         """Create a PNG/JPEG/GIF image object given raw data.
 
         When this object is returned by an input cell or passed to the
         display function, it will result in the image being displayed
         in the frontend.
 
         Parameters
         ----------
         data : unicode, str or bytes
             The raw image data or a URL or filename to load the data from.
             This always results in embedded image data.
         url : unicode
             A URL to download the data from. If you specify `url=`,
             the image data will not be embedded unless you also specify `embed=True`.
         filename : unicode
             Path to a local file to load the data from.
             Images from a file are always embedded.
         format : unicode
             The format of the image data (png/jpeg/jpg/gif). If a filename or URL is given
             for format will be inferred from the filename extension.
         embed : bool
             Should the image data be embedded using a data URI (True) or be
             loaded using an <img> tag. Set this to True if you want the image
             to be viewable later with no internet connection in the notebook.
 
             Default is `True`, unless the keyword argument `url` is set, then
             default value is `False`.
 
             Note that QtConsole is not able to display images if `embed` is set to `False`
         width : int
             Width in pixels to which to constrain the image in html
         height : int
             Height in pixels to which to constrain the image in html
         retina : bool
             Automatically set the width and height to half of the measured
             width and height.
             This only works for embedded images because it reads the width/height
             from image data.
             For non-embedded images, you can just set the desired display width
             and height directly.
         unconfined: bool
             Set unconfined=True to disable max-width confinement of the image.
         metadata: dict
             Specify extra metadata to attach to the image.
 
         Examples
         --------
         # embedded image data, works in qtconsole and notebook
         # when passed positionally, the first arg can be any of raw image data,
         # a URL, or a filename from which to load image data.
         # The result is always embedding image data for inline images.
         Image('http://www.google.fr/images/srpr/logo3w.png')
         Image('/path/to/image.jpg')
         Image(b'RAW_PNG_DATA...')
 
         # Specifying Image(url=...) does not embed the image data,
         # it only generates `<img>` tag with a link to the source.
         # This will not work in the qtconsole or offline.
         Image(url='http://www.google.fr/images/srpr/logo3w.png')
 
         """
         if filename is not None:
             ext = self._find_ext(filename)
         elif url is not None:
             ext = self._find_ext(url)
         elif data is None:
             raise ValueError("No image data found. Expecting filename, url, or data.")
         elif isinstance(data, str) and (
             data.startswith('http') or _safe_exists(data)
         ):
             ext = self._find_ext(data)
         else:
             ext = None
 
         if format is None:
             if ext is not None:
                 if ext == u'jpg' or ext == u'jpeg':
                     format = self._FMT_JPEG
                 elif ext == u'png':
                     format = self._FMT_PNG
                 elif ext == u'gif':
                     format = self._FMT_GIF
                 else:
                     format = ext.lower()
             elif isinstance(data, bytes):
                 # infer image type from image data header,
                 # only if format has not been specified.
                 if data[:2] == _JPEG:
                     format = self._FMT_JPEG
 
         # failed to detect format, default png
         if format is None:
             format = self._FMT_PNG
 
         if format.lower() == 'jpg':
             # jpg->jpeg
             format = self._FMT_JPEG
 
         self.format = format.lower()
         self.embed = embed if embed is not None else (url is None)
 
         if self.embed and self.format not in self._ACCEPTABLE_EMBEDDINGS:
             raise ValueError("Cannot embed the '%s' image format" % (self.format))
         if self.embed:
             self._mimetype = self._MIMETYPES.get(self.format)
 
         self.width = width
         self.height = height
         self.retina = retina
         self.unconfined = unconfined
         super(Image, self).__init__(data=data, url=url, filename=filename, 
                 metadata=metadata)
 
         if self.width is None and self.metadata.get('width', {}):
             self.width = metadata['width']
 
         if self.height is None and self.metadata.get('height', {}):
             self.height = metadata['height']
 
         if retina:
             self._retina_shape()
 
 
     def _retina_shape(self):
         """load pixel-doubled width and height from image data"""
         if not self.embed:
             return
         if self.format == self._FMT_PNG:
             w, h = _pngxy(self.data)
         elif self.format == self._FMT_JPEG:
             w, h = _jpegxy(self.data)
         elif self.format == self._FMT_GIF:
             w, h = _gifxy(self.data)
         else:
             # retina only supports png
             return
         self.width = w // 2
         self.height = h // 2
 
     def reload(self):
         """Reload the raw data from file or URL."""
         if self.embed:
             super(Image,self).reload()
             if self.retina:
                 self._retina_shape()
 
     def _repr_html_(self):
         if not self.embed:
             width = height = klass = ''
             if self.width:
                 width = ' width="%d"' % self.width
             if self.height:
                 height = ' height="%d"' % self.height
             if self.unconfined:
                 klass = ' class="unconfined"'
             return u'<img src="{url}"{width}{height}{klass}/>'.format(
                 url=self.url,
                 width=width,
                 height=height,
                 klass=klass,
             )
 
     def _repr_mimebundle_(self, include=None, exclude=None):
         """Return the image as a mimebundle
 
         Any new mimetype support should be implemented here.
         """
         if self.embed:
             mimetype = self._mimetype
             data, metadata = self._data_and_metadata(always_both=True)
             if metadata:
                 metadata = {mimetype: metadata}
             return {mimetype: data}, metadata
         else:
             return {'text/html': self._repr_html_()}
 
     def _data_and_metadata(self, always_both=False):
         """shortcut for returning metadata with shape information, if defined"""
         b64_data = b2a_base64(self.data).decode('ascii')
         md = {}
         if self.metadata:
             md.update(self.metadata)
         if self.width:
             md['width'] = self.width
         if self.height:
             md['height'] = self.height
         if self.unconfined:
             md['unconfined'] = self.unconfined
         if md or always_both:
             return b64_data, md
         else:
             return b64_data
 
     def _repr_png_(self):
         if self.embed and self.format == self._FMT_PNG:
             return self._data_and_metadata()
 
     def _repr_jpeg_(self):
         if self.embed and self.format == self._FMT_JPEG:
             return self._data_and_metadata()
 
     def _find_ext(self, s):
         return s.split('.')[-1].lower()
 
 
 class Video(DisplayObject):
 
     def __init__(self, data=None, url=None, filename=None, embed=False,
                  mimetype=None, width=None, height=None):
         """Create a video object given raw data or an URL.
 
         When this object is returned by an input cell or passed to the
         display function, it will result in the video being displayed
         in the frontend.
 
         Parameters
         ----------
         data : unicode, str or bytes
             The raw video data or a URL or filename to load the data from.
             Raw data will require passing `embed=True`.
         url : unicode
             A URL for the video. If you specify `url=`,
             the image data will not be embedded.
         filename : unicode
             Path to a local file containing the video.
             Will be interpreted as a local URL unless `embed=True`.
         embed : bool
             Should the video be embedded using a data URI (True) or be
             loaded using a <video> tag (False).
 
             Since videos are large, embedding them should be avoided, if possible.
             You must confirm embedding as your intention by passing `embed=True`.
 
             Local files can be displayed with URLs without embedding the content, via::
 
                 Video('./video.mp4')
 
         mimetype: unicode
             Specify the mimetype for embedded videos.
             Default will be guessed from file extension, if available.
         width : int
             Width in pixels to which to constrain the video in HTML.
             If not supplied, defaults to the width of the video.
         height : int
             Height in pixels to which to constrain the video in html.
             If not supplied, defaults to the height of the video.
 
         Examples
         --------
 
         Video('https://archive.org/download/Sita_Sings_the_Blues/Sita_Sings_the_Blues_small.mp4')
         Video('path/to/video.mp4')
         Video('path/to/video.mp4', embed=True)
         Video(b'raw-videodata', embed=True)
         """
         if url is None and isinstance(data, str) and data.startswith(('http:', 'https:')):
             url = data
             data = None
         elif os.path.exists(data):
             filename = data
             data = None
 
         if data and not embed:
             msg = ''.join([
                 "To embed videos, you must pass embed=True ",
                 "(this may make your notebook files huge)\n",
                 "Consider passing Video(url='...')",
             ])
             raise ValueError(msg)
 
         self.mimetype = mimetype
         self.embed = embed
         self.width = width
         self.height = height
         super(Video, self).__init__(data=data, url=url, filename=filename)
 
     def _repr_html_(self):
         width = height = ''
         if self.width:
             width = ' width="%d"' % self.width
         if self.height:
             height = ' height="%d"' % self.height
 
         # External URLs and potentially local files are not embedded into the
         # notebook output.
         if not self.embed:
             url = self.url if self.url is not None else self.filename
             output = """<video src="{0}" controls {1} {2}>
       Your browser does not support the <code>video</code> element.
     </video>""".format(url, width, height)
             return output
 
         # Embedded videos are base64-encoded.
         mimetype = self.mimetype
         if self.filename is not None:
             if not mimetype:
                 mimetype, _ = mimetypes.guess_type(self.filename)
 
             with open(self.filename, 'rb') as f:
                 video = f.read()
         else:
             video = self.data
         if isinstance(video, str):
             # unicode input is already b64-encoded
             b64_video = video
         else:
             b64_video = b2a_base64(video).decode('ascii').rstrip()
 
         output = """<video controls {0} {1}>
  <source src="data:{2};base64,{3}" type="{2}">
  Your browser does not support the video tag.
  </video>""".format(width, height, mimetype, b64_video)
         return output
 
     def reload(self):
         # TODO
         pass
 
 
 def clear_output(wait=False):
     """Clear the output of the current cell receiving output.
 
     Parameters
     ----------
     wait : bool [default: false]
         Wait to clear the output until new output is available to replace it."""
     from IPython.core.interactiveshell import InteractiveShell
     if InteractiveShell.initialized():
         InteractiveShell.instance().display_pub.clear_output(wait)
     else:
         print('\033[2K\r', end='')
         sys.stdout.flush()
         print('\033[2K\r', end='')
         sys.stderr.flush()
 
 
 @skip_doctest
 def set_matplotlib_formats(*formats, **kwargs):
     """Select figure formats for the inline backend. Optionally pass quality for JPEG.
 
     For example, this enables PNG and JPEG output with a JPEG quality of 90%::
 
         In [1]: set_matplotlib_formats('png', 'jpeg', quality=90)
 
     To set this in your config files use the following::
 
         c.InlineBackend.figure_formats = {'png', 'jpeg'}
         c.InlineBackend.print_figure_kwargs.update({'quality' : 90})
 
     Parameters
     ----------
     *formats : strs
         One or more figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
     **kwargs :
         Keyword args will be relayed to ``figure.canvas.print_figure``.
     """
     from IPython.core.interactiveshell import InteractiveShell
     from IPython.core.pylabtools import select_figure_formats
     # build kwargs, starting with InlineBackend config
     kw = {}
     from ipykernel.pylab.config import InlineBackend
     cfg = InlineBackend.instance()
     kw.update(cfg.print_figure_kwargs)
     kw.update(**kwargs)
     shell = InteractiveShell.instance()
     select_figure_formats(shell, formats, **kw)
 
 @skip_doctest
 def set_matplotlib_close(close=True):
     """Set whether the inline backend closes all figures automatically or not.
 
     By default, the inline backend used in the IPython Notebook will close all
     matplotlib figures automatically after each cell is run. This means that
     plots in different cells won't interfere. Sometimes, you may want to make
     a plot in one cell and then refine it in later cells. This can be accomplished
     by::
 
         In [1]: set_matplotlib_close(False)
 
     To set this in your config files use the following::
 
         c.InlineBackend.close_figures = False
 
     Parameters
     ----------
     close : bool
         Should all matplotlib figures be automatically closed after each cell is
         run?
     """
     from ipykernel.pylab.config import InlineBackend
     cfg = InlineBackend.instance()
     cfg.close_figures = close

IPython/core/inputtransformer2.py

@@ -1,707 +1,707
 """Input transformer machinery to support IPython special syntax.
 
 This includes the machinery to recognise and transform ``%magic`` commands,
 ``!system`` commands, ``help?`` querying, prompt stripping, and so forth.
 
 Added: IPython 7.0. Replaces inputsplitter and inputtransformer which were
 deprecated in 7.0.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from codeop import compile_command
 import re
 import tokenize
 from typing import List, Tuple, Union
 import warnings
 
 _indent_re = re.compile(r'^[ \t]+')
 
 def leading_indent(lines):
     """Remove leading indentation.
 
     If the first line starts with a spaces or tabs, the same whitespace will be
     removed from each following line in the cell.
     """
     if not lines:
         return lines
     m = _indent_re.match(lines[0])
     if not m:
         return lines
     space = m.group(0)
     n = len(space)
     return [l[n:] if l.startswith(space) else l
             for l in lines]
 
 class PromptStripper:
     """Remove matching input prompts from a block of input.
 
     Parameters
     ----------
     prompt_re : regular expression
         A regular expression matching any input prompt (including continuation,
         e.g. ``...``)
     initial_re : regular expression, optional
         A regular expression matching only the initial prompt, but not continuation.
         If no initial expression is given, prompt_re will be used everywhere.
         Used mainly for plain Python prompts (``>>>``), where the continuation prompt
         ``...`` is a valid Python expression in Python 3, so shouldn't be stripped.
 
     If initial_re and prompt_re differ,
     only initial_re will be tested against the first line.
     If any prompt is found on the first two lines,
     prompts will be stripped from the rest of the block.
     """
     def __init__(self, prompt_re, initial_re=None):
         self.prompt_re = prompt_re
         self.initial_re = initial_re or prompt_re
 
     def _strip(self, lines):
         return [self.prompt_re.sub('', l, count=1) for l in lines]
 
     def __call__(self, lines):
         if not lines:
             return lines
         if self.initial_re.match(lines[0]) or \
                 (len(lines) > 1 and self.prompt_re.match(lines[1])):
             return self._strip(lines)
         return lines
 
 classic_prompt = PromptStripper(
     prompt_re=re.compile(r'^(>>>|\.\.\.)( |$)'),
     initial_re=re.compile(r'^>>>( |$)')
 )
 
 ipython_prompt = PromptStripper(re.compile(r'^(In \[\d+\]: |\s*\.{3,}: ?)'))
 
 def cell_magic(lines):
     if not lines or not lines[0].startswith('%%'):
         return lines
-    if re.match('%%\w+\?', lines[0]):
+    if re.match(r'%%\w+\?', lines[0]):
         # This case will be handled by help_end
         return lines
     magic_name, _, first_line = lines[0][2:-1].partition(' ')
     body = ''.join(lines[1:])
     return ['get_ipython().run_cell_magic(%r, %r, %r)\n'
             % (magic_name, first_line, body)]
 
 
 def _find_assign_op(token_line) -> Union[int, None]:
     """Get the index of the first assignment in the line ('=' not inside brackets)
 
     Note: We don't try to support multiple special assignment (a = b = %foo)
     """
     paren_level = 0
     for i, ti in enumerate(token_line):
         s = ti.string
         if s == '=' and paren_level == 0:
             return i
         if s in {'(','[','{'}:
             paren_level += 1
         elif s in {')', ']', '}'}:
             if paren_level > 0:
                 paren_level -= 1
 
 def find_end_of_continued_line(lines, start_line: int):
     """Find the last line of a line explicitly extended using backslashes.
 
     Uses 0-indexed line numbers.
     """
     end_line = start_line
     while lines[end_line].endswith('\\\n'):
         end_line += 1
         if end_line >= len(lines):
             break
     return end_line
 
 def assemble_continued_line(lines, start: Tuple[int, int], end_line: int):
-    """Assemble a single line from multiple continued line pieces
+    r"""Assemble a single line from multiple continued line pieces
 
     Continued lines are lines ending in ``\``, and the line following the last
     ``\`` in the block.
 
     For example, this code continues over multiple lines::
 
         if (assign_ix is not None) \
              and (len(line) >= assign_ix + 2) \
              and (line[assign_ix+1].string == '%') \
              and (line[assign_ix+2].type == tokenize.NAME):
 
     This statement contains four continued line pieces.
     Assembling these pieces into a single line would give::
 
         if (assign_ix is not None) and (len(line) >= assign_ix + 2) and (line[...
 
     This uses 0-indexed line numbers. *start* is (lineno, colno).
 
     Used to allow ``%magic`` and ``!system`` commands to be continued over
     multiple lines.
     """
     parts = [lines[start[0]][start[1]:]] + lines[start[0]+1:end_line+1]
     return ' '.join([p[:-2] for p in parts[:-1]]  # Strip backslash+newline
                     + [parts[-1][:-1]])         # Strip newline from last line
 
 class TokenTransformBase:
     """Base class for transformations which examine tokens.
 
     Special syntax should not be transformed when it occurs inside strings or
     comments. This is hard to reliably avoid with regexes. The solution is to
     tokenise the code as Python, and recognise the special syntax in the tokens.
 
     IPython's special syntax is not valid Python syntax, so tokenising may go
     wrong after the special syntax starts. These classes therefore find and
     transform *one* instance of special syntax at a time into regular Python
     syntax. After each transformation, tokens are regenerated to find the next
     piece of special syntax.
 
     Subclasses need to implement one class method (find)
     and one regular method (transform).
 
     The priority attribute can select which transformation to apply if multiple
     transformers match in the same place. Lower numbers have higher priority.
     This allows "%magic?" to be turned into a help call rather than a magic call.
     """
     # Lower numbers -> higher priority (for matches in the same location)
     priority = 10
 
     def sortby(self):
         return self.start_line, self.start_col, self.priority
 
     def __init__(self, start):
         self.start_line = start[0] - 1   # Shift from 1-index to 0-index
         self.start_col = start[1]
 
     @classmethod
     def find(cls, tokens_by_line):
         """Find one instance of special syntax in the provided tokens.
 
         Tokens are grouped into logical lines for convenience,
         so it is easy to e.g. look at the first token of each line.
         *tokens_by_line* is a list of lists of tokenize.TokenInfo objects.
 
         This should return an instance of its class, pointing to the start
         position it has found, or None if it found no match.
         """
         raise NotImplementedError
 
     def transform(self, lines: List[str]):
         """Transform one instance of special syntax found by ``find()``
 
         Takes a list of strings representing physical lines,
         returns a similar list of transformed lines.
         """
         raise NotImplementedError
 
 class MagicAssign(TokenTransformBase):
     """Transformer for assignments from magics (a = %foo)"""
     @classmethod
     def find(cls, tokens_by_line):
         """Find the first magic assignment (a = %foo) in the cell.
         """
         for line in tokens_by_line:
             assign_ix = _find_assign_op(line)
             if (assign_ix is not None) \
                     and (len(line) >= assign_ix + 2) \
                     and (line[assign_ix+1].string == '%') \
                     and (line[assign_ix+2].type == tokenize.NAME):
                 return cls(line[assign_ix+1].start)
 
     def transform(self, lines: List[str]):
         """Transform a magic assignment found by the ``find()`` classmethod.
         """
         start_line, start_col = self.start_line, self.start_col
         lhs = lines[start_line][:start_col]
         end_line = find_end_of_continued_line(lines, start_line)
         rhs = assemble_continued_line(lines, (start_line, start_col), end_line)
         assert rhs.startswith('%'), rhs
         magic_name, _, args = rhs[1:].partition(' ')
 
         lines_before = lines[:start_line]
         call = "get_ipython().run_line_magic({!r}, {!r})".format(magic_name, args)
         new_line = lhs + call + '\n'
         lines_after = lines[end_line+1:]
 
         return lines_before + [new_line] + lines_after
 
 
 class SystemAssign(TokenTransformBase):
     """Transformer for assignments from system commands (a = !foo)"""
     @classmethod
     def find(cls, tokens_by_line):
         """Find the first system assignment (a = !foo) in the cell.
         """
         for line in tokens_by_line:
             assign_ix = _find_assign_op(line)
             if (assign_ix is not None) \
                     and not line[assign_ix].line.strip().startswith('=') \
                     and (len(line) >= assign_ix + 2) \
                     and (line[assign_ix + 1].type == tokenize.ERRORTOKEN):
                 ix = assign_ix + 1
 
                 while ix < len(line) and line[ix].type == tokenize.ERRORTOKEN:
                     if line[ix].string == '!':
                         return cls(line[ix].start)
                     elif not line[ix].string.isspace():
                         break
                     ix += 1
 
     def transform(self, lines: List[str]):
         """Transform a system assignment found by the ``find()`` classmethod.
         """
         start_line, start_col = self.start_line, self.start_col
 
         lhs = lines[start_line][:start_col]
         end_line = find_end_of_continued_line(lines, start_line)
         rhs = assemble_continued_line(lines, (start_line, start_col), end_line)
         assert rhs.startswith('!'), rhs
         cmd = rhs[1:]
 
         lines_before = lines[:start_line]
         call = "get_ipython().getoutput({!r})".format(cmd)
         new_line = lhs + call + '\n'
         lines_after = lines[end_line + 1:]
 
         return lines_before + [new_line] + lines_after
 
 # The escape sequences that define the syntax transformations IPython will
 # apply to user input.  These can NOT be just changed here: many regular
 # expressions and other parts of the code may use their hardcoded values, and
 # for all intents and purposes they constitute the 'IPython syntax', so they
 # should be considered fixed.
 
 ESC_SHELL  = '!'     # Send line to underlying system shell
 ESC_SH_CAP = '!!'    # Send line to system shell and capture output
 ESC_HELP   = '?'     # Find information about object
 ESC_HELP2  = '??'    # Find extra-detailed information about object
 ESC_MAGIC  = '%'     # Call magic function
 ESC_MAGIC2 = '%%'    # Call cell-magic function
 ESC_QUOTE  = ','     # Split args on whitespace, quote each as string and call
 ESC_QUOTE2 = ';'     # Quote all args as a single string, call
 ESC_PAREN  = '/'     # Call first argument with rest of line as arguments
 
 ESCAPE_SINGLES = {'!', '?', '%', ',', ';', '/'}
 ESCAPE_DOUBLES = {'!!', '??'}  # %% (cell magic) is handled separately
 
 def _make_help_call(target, esc, next_input=None):
     """Prepares a pinfo(2)/psearch call from a target name and the escape
     (i.e. ? or ??)"""
     method  = 'pinfo2' if esc == '??' \
                 else 'psearch' if '*' in target \
                 else 'pinfo'
     arg = " ".join([method, target])
     #Prepare arguments for get_ipython().run_line_magic(magic_name, magic_args)
     t_magic_name, _, t_magic_arg_s = arg.partition(' ')
     t_magic_name = t_magic_name.lstrip(ESC_MAGIC)
     if next_input is None:
         return 'get_ipython().run_line_magic(%r, %r)' % (t_magic_name, t_magic_arg_s)
     else:
         return 'get_ipython().set_next_input(%r);get_ipython().run_line_magic(%r, %r)' % \
            (next_input, t_magic_name, t_magic_arg_s)
 
 def _tr_help(content):
     """Translate lines escaped with: ?
 
     A naked help line should fire the intro help screen (shell.show_usage())
     """
     if not content:
         return 'get_ipython().show_usage()'
 
     return _make_help_call(content, '?')
 
 def _tr_help2(content):
     """Translate lines escaped with: ??
 
     A naked help line should fire the intro help screen (shell.show_usage())
     """
     if not content:
         return 'get_ipython().show_usage()'
 
     return _make_help_call(content, '??')
 
 def _tr_magic(content):
     "Translate lines escaped with a percent sign: %"
     name, _, args = content.partition(' ')
     return 'get_ipython().run_line_magic(%r, %r)' % (name, args)
 
 def _tr_quote(content):
     "Translate lines escaped with a comma: ,"
     name, _, args = content.partition(' ')
     return '%s("%s")' % (name, '", "'.join(args.split()) )
 
 def _tr_quote2(content):
     "Translate lines escaped with a semicolon: ;"
     name, _, args = content.partition(' ')
     return '%s("%s")' % (name, args)
 
 def _tr_paren(content):
     "Translate lines escaped with a slash: /"
     name, _, args = content.partition(' ')
     return '%s(%s)' % (name, ", ".join(args.split()))
 
 tr = { ESC_SHELL  : 'get_ipython().system({!r})'.format,
        ESC_SH_CAP : 'get_ipython().getoutput({!r})'.format,
        ESC_HELP   : _tr_help,
        ESC_HELP2  : _tr_help2,
        ESC_MAGIC  : _tr_magic,
        ESC_QUOTE  : _tr_quote,
        ESC_QUOTE2 : _tr_quote2,
        ESC_PAREN  : _tr_paren }
 
 class EscapedCommand(TokenTransformBase):
     """Transformer for escaped commands like %foo, !foo, or /foo"""
     @classmethod
     def find(cls, tokens_by_line):
         """Find the first escaped command (%foo, !foo, etc.) in the cell.
         """
         for line in tokens_by_line:
             if not line:
                 continue
             ix = 0
             ll = len(line)
             while ll > ix and line[ix].type in {tokenize.INDENT, tokenize.DEDENT}:
                 ix += 1
             if ix >= ll:
                 continue
             if line[ix].string in ESCAPE_SINGLES:
                 return cls(line[ix].start)
 
     def transform(self, lines):
         """Transform an escaped line found by the ``find()`` classmethod.
         """
         start_line, start_col = self.start_line, self.start_col
 
         indent = lines[start_line][:start_col]
         end_line = find_end_of_continued_line(lines, start_line)
         line = assemble_continued_line(lines, (start_line, start_col), end_line)
 
         if len(line) > 1 and line[:2] in ESCAPE_DOUBLES:
             escape, content = line[:2], line[2:]
         else:
             escape, content = line[:1], line[1:]
 
         if escape in tr:
             call = tr[escape](content)
         else:
             call = ''
 
         lines_before = lines[:start_line]
         new_line = indent + call + '\n'
         lines_after = lines[end_line + 1:]
 
         return lines_before + [new_line] + lines_after
 
 _help_end_re = re.compile(r"""(%{0,2}
                               [a-zA-Z_*][\w*]*        # Variable name
                               (\.[a-zA-Z_*][\w*]*)*   # .etc.etc
                               )
                               (\?\??)$                # ? or ??
                               """,
                               re.VERBOSE)
 
 class HelpEnd(TokenTransformBase):
     """Transformer for help syntax: obj? and obj??"""
     # This needs to be higher priority (lower number) than EscapedCommand so
     # that inspecting magics (%foo?) works.
     priority = 5
 
     def __init__(self, start, q_locn):
         super().__init__(start)
         self.q_line = q_locn[0] - 1  # Shift from 1-indexed to 0-indexed
         self.q_col = q_locn[1]
 
     @classmethod
     def find(cls, tokens_by_line):
         """Find the first help command (foo?) in the cell.
         """
         for line in tokens_by_line:
             # Last token is NEWLINE; look at last but one
             if len(line) > 2 and line[-2].string == '?':
                 # Find the first token that's not INDENT/DEDENT
                 ix = 0
                 while line[ix].type in {tokenize.INDENT, tokenize.DEDENT}:
                     ix += 1
                 return cls(line[ix].start, line[-2].start)
 
     def transform(self, lines):
         """Transform a help command found by the ``find()`` classmethod.
         """
         piece = ''.join(lines[self.start_line:self.q_line+1])
         indent, content = piece[:self.start_col], piece[self.start_col:]
         lines_before = lines[:self.start_line]
         lines_after = lines[self.q_line + 1:]
 
         m = _help_end_re.search(content)
         if not m:
             raise SyntaxError(content)
         assert m is not None, content
         target = m.group(1)
         esc = m.group(3)
 
         # If we're mid-command, put it back on the next prompt for the user.
         next_input = None
         if (not lines_before) and (not lines_after) \
                 and content.strip() != m.group(0):
             next_input = content.rstrip('?\n')
 
         call = _make_help_call(target, esc, next_input=next_input)
         new_line = indent + call + '\n'
 
         return lines_before + [new_line] + lines_after
 
 def make_tokens_by_line(lines:List[str]):
     """Tokenize a series of lines and group tokens by line.
 
     The tokens for a multiline Python string or expression are grouped as one
     line. All lines except the last lines should keep their line ending ('\\n',
     '\\r\\n') for this to properly work. Use `.splitlines(keeplineending=True)`
     for example when passing block of text to this function.
 
     """
     # NL tokens are used inside multiline expressions, but also after blank
     # lines or comments. This is intentional - see https://bugs.python.org/issue17061
     # We want to group the former case together but split the latter, so we
     # track parentheses level, similar to the internals of tokenize.
     NEWLINE, NL = tokenize.NEWLINE, tokenize.NL
     tokens_by_line = [[]]
     if len(lines) > 1 and not lines[0].endswith(('\n', '\r', '\r\n', '\x0b', '\x0c')):
         warnings.warn("`make_tokens_by_line` received a list of lines which do not have lineending markers ('\\n', '\\r', '\\r\\n', '\\x0b', '\\x0c'), behavior will be unspecified")
     parenlev = 0
     try:
         for token in tokenize.generate_tokens(iter(lines).__next__):
             tokens_by_line[-1].append(token)
             if (token.type == NEWLINE) \
                     or ((token.type == NL) and (parenlev <= 0)):
                 tokens_by_line.append([])
             elif token.string in {'(', '[', '{'}:
                 parenlev += 1
             elif token.string in {')', ']', '}'}:
                 if parenlev > 0:
                     parenlev -= 1
     except tokenize.TokenError:
         # Input ended in a multiline string or expression. That's OK for us.
         pass
 
 
     if not tokens_by_line[-1]:
         tokens_by_line.pop()
 
 
     return tokens_by_line
 
 def show_linewise_tokens(s: str):
     """For investigation and debugging"""
     if not s.endswith('\n'):
         s += '\n'
     lines = s.splitlines(keepends=True)
     for line in make_tokens_by_line(lines):
         print("Line -------")
         for tokinfo in line:
             print(" ", tokinfo)
 
 # Arbitrary limit to prevent getting stuck in infinite loops
 TRANSFORM_LOOP_LIMIT = 500
 
 class TransformerManager:
     """Applies various transformations to a cell or code block.
 
     The key methods for external use are ``transform_cell()``
     and ``check_complete()``.
     """
     def __init__(self):
         self.cleanup_transforms = [
             leading_indent,
             classic_prompt,
             ipython_prompt,
         ]
         self.line_transforms = [
             cell_magic,
         ]
         self.token_transformers = [
             MagicAssign,
             SystemAssign,
             EscapedCommand,
             HelpEnd,
         ]
 
     def do_one_token_transform(self, lines):
         """Find and run the transform earliest in the code.
 
         Returns (changed, lines).
 
         This method is called repeatedly until changed is False, indicating
         that all available transformations are complete.
 
         The tokens following IPython special syntax might not be valid, so
         the transformed code is retokenised every time to identify the next
         piece of special syntax. Hopefully long code cells are mostly valid
         Python, not using lots of IPython special syntax, so this shouldn't be
         a performance issue.
         """
         tokens_by_line = make_tokens_by_line(lines)
         candidates = []
         for transformer_cls in self.token_transformers:
             transformer = transformer_cls.find(tokens_by_line)
             if transformer:
                 candidates.append(transformer)
 
         if not candidates:
             # Nothing to transform
             return False, lines
         ordered_transformers = sorted(candidates, key=TokenTransformBase.sortby)
         for transformer in ordered_transformers:
             try:
                 return True, transformer.transform(lines)
             except SyntaxError:
                 pass
         return False, lines
 
     def do_token_transforms(self, lines):
         for _ in range(TRANSFORM_LOOP_LIMIT):
             changed, lines = self.do_one_token_transform(lines)
             if not changed:
                 return lines
 
         raise RuntimeError("Input transformation still changing after "
                            "%d iterations. Aborting." % TRANSFORM_LOOP_LIMIT)
 
     def transform_cell(self, cell: str) -> str:
         """Transforms a cell of input code"""
         if not cell.endswith('\n'):
             cell += '\n'  # Ensure the cell has a trailing newline
         lines = cell.splitlines(keepends=True)
         for transform in self.cleanup_transforms + self.line_transforms:
             lines = transform(lines)
 
         lines = self.do_token_transforms(lines)
         return ''.join(lines)
 
     def check_complete(self, cell: str):
         """Return whether a block of code is ready to execute, or should be continued
 
         Parameters
         ----------
         source : string
           Python input code, which can be multiline.
 
         Returns
         -------
         status : str
           One of 'complete', 'incomplete', or 'invalid' if source is not a
           prefix of valid code.
         indent_spaces : int or None
           The number of spaces by which to indent the next line of code. If
           status is not 'incomplete', this is None.
         """
         # Remember if the lines ends in a new line.
         ends_with_newline = False
         for character in reversed(cell):
             if character == '\n':
                 ends_with_newline = True
                 break
             elif character.strip():
                 break
             else:
                 continue
 
         if not ends_with_newline:
             # Append an newline for consistent tokenization
             # See https://bugs.python.org/issue33899
             cell += '\n'
 
         lines = cell.splitlines(keepends=True)
 
         if not lines:
             return 'complete', None
 
         if lines[-1].endswith('\\'):
             # Explicit backslash continuation
             return 'incomplete', find_last_indent(lines)
 
         try:
             for transform in self.cleanup_transforms:
                 lines = transform(lines)
         except SyntaxError:
             return 'invalid', None
 
         if lines[0].startswith('%%'):
             # Special case for cell magics - completion marked by blank line
             if lines[-1].strip():
                 return 'incomplete', find_last_indent(lines)
             else:
                 return 'complete', None
 
         try:
             for transform in self.line_transforms:
                 lines = transform(lines)
             lines = self.do_token_transforms(lines)
         except SyntaxError:
             return 'invalid', None
 
         tokens_by_line = make_tokens_by_line(lines)
 
         if not tokens_by_line:
             return 'incomplete', find_last_indent(lines)
 
         if tokens_by_line[-1][-1].type != tokenize.ENDMARKER:
             # We're in a multiline string or expression
             return 'incomplete', find_last_indent(lines)
 
         newline_types = {tokenize.NEWLINE, tokenize.COMMENT, tokenize.ENDMARKER}
 
         # Pop the last line which only contains DEDENTs and ENDMARKER
         last_token_line = None
         if {t.type for t in tokens_by_line[-1]} in [
             {tokenize.DEDENT, tokenize.ENDMARKER},
             {tokenize.ENDMARKER}
         ] and len(tokens_by_line) > 1:
             last_token_line = tokens_by_line.pop()
 
         while tokens_by_line[-1] and tokens_by_line[-1][-1].type in newline_types:
             tokens_by_line[-1].pop()
 
         if len(tokens_by_line) == 1 and not tokens_by_line[-1]:
             return 'incomplete', 0
 
         if tokens_by_line[-1][-1].string == ':':
             # The last line starts a block (e.g. 'if foo:')
             ix = 0
             while tokens_by_line[-1][ix].type in {tokenize.INDENT, tokenize.DEDENT}:
                 ix += 1
 
             indent = tokens_by_line[-1][ix].start[1]
             return 'incomplete', indent + 4
 
         if tokens_by_line[-1][0].line.endswith('\\'):
             return 'incomplete', None
 
         # At this point, our checks think the code is complete (or invalid).
         # We'll use codeop.compile_command to check this with the real parser
         try:
             with warnings.catch_warnings():
                 warnings.simplefilter('error', SyntaxWarning)
                 res = compile_command(''.join(lines), symbol='exec')
         except (SyntaxError, OverflowError, ValueError, TypeError,
                 MemoryError, SyntaxWarning):
             return 'invalid', None
         else:
             if res is None:
                 return 'incomplete', find_last_indent(lines)
 
         if last_token_line and last_token_line[0].type == tokenize.DEDENT:
             if ends_with_newline:
                 return 'complete', None
             return 'incomplete', find_last_indent(lines)
 
         # If there's a blank line at the end, assume we're ready to execute
         if not lines[-1].strip():
             return 'complete', None
 
         return 'complete', None
 
 
 def find_last_indent(lines):
     m = _indent_re.match(lines[-1])
     if not m:
         return 0
     return len(m.group(0).replace('\t', ' '*4))

IPython/core/magics/namespace.py

@@ -1,702 +1,702
 """Implementation of namespace-related magic functions.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012 The IPython Development Team.
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib
 import gc
 import re
 import sys
 
 # Our own packages
 from IPython.core import page
 from IPython.core.error import StdinNotImplementedError, UsageError
 from IPython.core.magic import Magics, magics_class, line_magic
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils.encoding import DEFAULT_ENCODING
 from IPython.utils.openpy import read_py_file
 from IPython.utils.path import get_py_filename
 
 #-----------------------------------------------------------------------------
 # Magic implementation classes
 #-----------------------------------------------------------------------------
 
 @magics_class
 class NamespaceMagics(Magics):
     """Magics to manage various aspects of the user's namespace.
 
     These include listing variables, introspecting into them, etc.
     """
 
     @line_magic
     def pinfo(self, parameter_s='', namespaces=None):
         """Provide detailed information about an object.
 
         '%pinfo object' is just a synonym for object? or ?object."""
 
         #print 'pinfo par: <%s>' % parameter_s  # dbg
         # detail_level: 0 -> obj? , 1 -> obj??
         detail_level = 0
         # We need to detect if we got called as 'pinfo pinfo foo', which can
         # happen if the user types 'pinfo foo?' at the cmd line.
         pinfo,qmark1,oname,qmark2 = \
-               re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
+               re.match(r'(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
         if pinfo or qmark1 or qmark2:
             detail_level = 1
         if "*" in oname:
             self.psearch(oname)
         else:
             self.shell._inspect('pinfo', oname, detail_level=detail_level,
                                 namespaces=namespaces)
 
     @line_magic
     def pinfo2(self, parameter_s='', namespaces=None):
         """Provide extra detailed information about an object.
 
         '%pinfo2 object' is just a synonym for object?? or ??object."""
         self.shell._inspect('pinfo', parameter_s, detail_level=1,
                             namespaces=namespaces)
 
     @skip_doctest
     @line_magic
     def pdef(self, parameter_s='', namespaces=None):
         """Print the call signature for any callable object.
 
         If the object is a class, print the constructor information.
 
         Examples
         --------
         ::
 
           In [3]: %pdef urllib.urlopen
           urllib.urlopen(url, data=None, proxies=None)
         """
         self.shell._inspect('pdef',parameter_s, namespaces)
 
     @line_magic
     def pdoc(self, parameter_s='', namespaces=None):
         """Print the docstring for an object.
 
         If the given object is a class, it will print both the class and the
         constructor docstrings."""
         self.shell._inspect('pdoc',parameter_s, namespaces)
 
     @line_magic
     def psource(self, parameter_s='', namespaces=None):
         """Print (or run through pager) the source code for an object."""
         if not parameter_s:
             raise UsageError('Missing object name.')
         self.shell._inspect('psource',parameter_s, namespaces)
 
     @line_magic
     def pfile(self, parameter_s='', namespaces=None):
         """Print (or run through pager) the file where an object is defined.
 
         The file opens at the line where the object definition begins. IPython
         will honor the environment variable PAGER if set, and otherwise will
         do its best to print the file in a convenient form.
 
         If the given argument is not an object currently defined, IPython will
         try to interpret it as a filename (automatically adding a .py extension
         if needed). You can thus use %pfile as a syntax highlighting code
         viewer."""
 
         # first interpret argument as an object name
         out = self.shell._inspect('pfile',parameter_s, namespaces)
         # if not, try the input as a filename
         if out == 'not found':
             try:
                 filename = get_py_filename(parameter_s)
             except IOError as msg:
                 print(msg)
                 return
             page.page(self.shell.pycolorize(read_py_file(filename, skip_encoding_cookie=False)))
 
     @line_magic
     def psearch(self, parameter_s=''):
         """Search for object in namespaces by wildcard.
 
         %psearch [options] PATTERN [OBJECT TYPE]
 
         Note: ? can be used as a synonym for %psearch, at the beginning or at
         the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the
         rest of the command line must be unchanged (options come first), so
         for example the following forms are equivalent
 
         %psearch -i a* function
         -i a* function?
         ?-i a* function
 
         Arguments:
 
           PATTERN
 
           where PATTERN is a string containing * as a wildcard similar to its
           use in a shell.  The pattern is matched in all namespaces on the
           search path. By default objects starting with a single _ are not
           matched, many IPython generated objects have a single
           underscore. The default is case insensitive matching. Matching is
           also done on the attributes of objects and not only on the objects
           in a module.
 
           [OBJECT TYPE]
 
           Is the name of a python type from the types module. The name is
           given in lowercase without the ending type, ex. StringType is
           written string. By adding a type here only objects matching the
           given type are matched. Using all here makes the pattern match all
           types (this is the default).
 
         Options:
 
           -a: makes the pattern match even objects whose names start with a
           single underscore.  These names are normally omitted from the
           search.
 
           -i/-c: make the pattern case insensitive/sensitive.  If neither of
           these options are given, the default is read from your configuration
           file, with the option ``InteractiveShell.wildcards_case_sensitive``.
           If this option is not specified in your configuration file, IPython's
           internal default is to do a case sensitive search.
 
           -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you
           specify can be searched in any of the following namespaces:
           'builtin', 'user', 'user_global','internal', 'alias', where
           'builtin' and 'user' are the search defaults.  Note that you should
           not use quotes when specifying namespaces.
 
           'Builtin' contains the python module builtin, 'user' contains all
           user data, 'alias' only contain the shell aliases and no python
           objects, 'internal' contains objects used by IPython.  The
           'user_global' namespace is only used by embedded IPython instances,
           and it contains module-level globals.  You can add namespaces to the
           search with -s or exclude them with -e (these options can be given
           more than once).
 
         Examples
         --------
         ::
 
           %psearch a*            -> objects beginning with an a
           %psearch -e builtin a* -> objects NOT in the builtin space starting in a
           %psearch a* function   -> all functions beginning with an a
           %psearch re.e*         -> objects beginning with an e in module re
           %psearch r*.e*         -> objects that start with e in modules starting in r
           %psearch r*.* string   -> all strings in modules beginning with r
 
         Case sensitive search::
 
           %psearch -c a*         list all object beginning with lower case a
 
         Show objects beginning with a single _::
 
           %psearch -a _*         list objects beginning with a single underscore
         """
         try:
             parameter_s.encode('ascii')
         except UnicodeEncodeError:
             print('Python identifiers can only contain ascii characters.')
             return
 
         # default namespaces to be searched
         def_search = ['user_local', 'user_global', 'builtin']
 
         # Process options/args
         opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
         opt = opts.get
         shell = self.shell
         psearch = shell.inspector.psearch
 
         # select case options
         if 'i' in opts:
             ignore_case = True
         elif 'c' in opts:
             ignore_case = False
         else:
             ignore_case = not shell.wildcards_case_sensitive
 
         # Build list of namespaces to search from user options
         def_search.extend(opt('s',[]))
         ns_exclude = ns_exclude=opt('e',[])
         ns_search = [nm for nm in def_search if nm not in ns_exclude]
 
         # Call the actual search
         try:
             psearch(args,shell.ns_table,ns_search,
                     show_all=opt('a'),ignore_case=ignore_case)
         except:
             shell.showtraceback()
 
     @skip_doctest
     @line_magic
     def who_ls(self, parameter_s=''):
         """Return a sorted list of all interactive variables.
 
         If arguments are given, only variables of types matching these
         arguments are returned.
 
         Examples
         --------
 
         Define two variables and list them with who_ls::
 
           In [1]: alpha = 123
 
           In [2]: beta = 'test'
 
           In [3]: %who_ls
           Out[3]: ['alpha', 'beta']
 
           In [4]: %who_ls int
           Out[4]: ['alpha']
 
           In [5]: %who_ls str
           Out[5]: ['beta']
         """
 
         user_ns = self.shell.user_ns
         user_ns_hidden = self.shell.user_ns_hidden
         nonmatching = object()  # This can never be in user_ns
         out = [ i for i in user_ns
                 if not i.startswith('_') \
                 and (user_ns[i] is not user_ns_hidden.get(i, nonmatching)) ]
 
         typelist = parameter_s.split()
         if typelist:
             typeset = set(typelist)
             out = [i for i in out if type(user_ns[i]).__name__ in typeset]
 
         out.sort()
         return out
 
     @skip_doctest
     @line_magic
     def who(self, parameter_s=''):
         """Print all interactive variables, with some minimal formatting.
 
         If any arguments are given, only variables whose type matches one of
         these are printed.  For example::
 
           %who function str
 
         will only list functions and strings, excluding all other types of
         variables.  To find the proper type names, simply use type(var) at a
         command line to see how python prints type names.  For example:
 
         ::
 
           In [1]: type('hello')\\
           Out[1]: <type 'str'>
 
         indicates that the type name for strings is 'str'.
 
         ``%who`` always excludes executed names loaded through your configuration
         file and things which are internal to IPython.
 
         This is deliberate, as typically you may load many modules and the
         purpose of %who is to show you only what you've manually defined.
 
         Examples
         --------
 
         Define two variables and list them with who::
 
           In [1]: alpha = 123
 
           In [2]: beta = 'test'
 
           In [3]: %who
           alpha   beta
 
           In [4]: %who int
           alpha
 
           In [5]: %who str
           beta
         """
 
         varlist = self.who_ls(parameter_s)
         if not varlist:
             if parameter_s:
                 print('No variables match your requested type.')
             else:
                 print('Interactive namespace is empty.')
             return
 
         # if we have variables, move on...
         count = 0
         for i in varlist:
             print(i+'\t', end=' ')
             count += 1
             if count > 8:
                 count = 0
                 print()
         print()
 
     @skip_doctest
     @line_magic
     def whos(self, parameter_s=''):
         """Like %who, but gives some extra information about each variable.
 
         The same type filtering of %who can be applied here.
 
         For all variables, the type is printed. Additionally it prints:
 
           - For {},[],(): their length.
 
           - For numpy arrays, a summary with shape, number of
             elements, typecode and size in memory.
 
           - Everything else: a string representation, snipping their middle if
             too long.
 
         Examples
         --------
 
         Define two variables and list them with whos::
 
           In [1]: alpha = 123
 
           In [2]: beta = 'test'
 
           In [3]: %whos
           Variable   Type        Data/Info
           --------------------------------
           alpha      int         123
           beta       str         test
         """
 
         varnames = self.who_ls(parameter_s)
         if not varnames:
             if parameter_s:
                 print('No variables match your requested type.')
             else:
                 print('Interactive namespace is empty.')
             return
 
         # if we have variables, move on...
 
         # for these types, show len() instead of data:
         seq_types = ['dict', 'list', 'tuple']
 
         # for numpy arrays, display summary info
         ndarray_type = None
         if 'numpy' in sys.modules:
             try:
                 from numpy import ndarray
             except ImportError:
                 pass
             else:
                 ndarray_type = ndarray.__name__
 
         # Find all variable names and types so we can figure out column sizes
 
         # some types are well known and can be shorter
         abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
         def type_name(v):
             tn = type(v).__name__
             return abbrevs.get(tn,tn)
 
         varlist = [self.shell.user_ns[n] for n in varnames]
 
         typelist = []
         for vv in varlist:
             tt = type_name(vv)
 
             if tt=='instance':
                 typelist.append( abbrevs.get(str(vv.__class__),
                                              str(vv.__class__)))
             else:
                 typelist.append(tt)
 
         # column labels and # of spaces as separator
         varlabel = 'Variable'
         typelabel = 'Type'
         datalabel = 'Data/Info'
         colsep = 3
         # variable format strings
         vformat    = "{0:<{varwidth}}{1:<{typewidth}}"
         aformat    = "%s: %s elems, type `%s`, %s bytes"
         # find the size of the columns to format the output nicely
         varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
         typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
         # table header
         print(varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
               ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1))
         # and the table itself
         kb = 1024
         Mb = 1048576  # kb**2
         for vname,var,vtype in zip(varnames,varlist,typelist):
             print(vformat.format(vname, vtype, varwidth=varwidth, typewidth=typewidth), end=' ')
             if vtype in seq_types:
                 print("n="+str(len(var)))
             elif vtype == ndarray_type:
                 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
                 if vtype==ndarray_type:
                     # numpy
                     vsize  = var.size
                     vbytes = vsize*var.itemsize
                     vdtype = var.dtype
 
                 if vbytes < 100000:
                     print(aformat % (vshape, vsize, vdtype, vbytes))
                 else:
                     print(aformat % (vshape, vsize, vdtype, vbytes), end=' ')
                     if vbytes < Mb:
                         print('(%s kb)' % (vbytes/kb,))
                     else:
                         print('(%s Mb)' % (vbytes/Mb,))
             else:
                 try:
                     vstr = str(var)
                 except UnicodeEncodeError:
                     vstr = var.encode(DEFAULT_ENCODING,
                                       'backslashreplace')
                 except:
                     vstr = "<object with id %d (str() failed)>" % id(var)
                 vstr = vstr.replace('\n', '\\n')
                 if len(vstr) < 50:
                     print(vstr)
                 else:
                     print(vstr[:25] + "<...>" + vstr[-25:])
 
     @line_magic
     def reset(self, parameter_s=''):
         """Resets the namespace by removing all names defined by the user, if
         called without arguments, or by removing some types of objects, such
         as everything currently in IPython's In[] and Out[] containers (see
         the parameters for details).
 
         Parameters
         ----------
         -f : force reset without asking for confirmation.
 
         -s : 'Soft' reset: Only clears your namespace, leaving history intact.
             References to objects may be kept. By default (without this option),
             we do a 'hard' reset, giving you a new session and removing all
             references to objects from the current session.
 
         in : reset input history
 
         out : reset output history
 
         dhist : reset directory history
 
         array : reset only variables that are NumPy arrays
 
         See Also
         --------
         reset_selective : invoked as ``%reset_selective``
 
         Examples
         --------
         ::
 
           In [6]: a = 1
 
           In [7]: a
           Out[7]: 1
 
           In [8]: 'a' in _ip.user_ns
           Out[8]: True
 
           In [9]: %reset -f
 
           In [1]: 'a' in _ip.user_ns
           Out[1]: False
 
           In [2]: %reset -f in
           Flushing input history
 
           In [3]: %reset -f dhist in
           Flushing directory history
           Flushing input history
 
         Notes
         -----
         Calling this magic from clients that do not implement standard input,
         such as the ipython notebook interface, will reset the namespace
         without confirmation.
         """
         opts, args = self.parse_options(parameter_s,'sf', mode='list')
         if 'f' in opts:
             ans = True
         else:
             try:
                 ans = self.shell.ask_yes_no(
                 "Once deleted, variables cannot be recovered. Proceed (y/[n])?",
                 default='n')
             except StdinNotImplementedError:
                 ans = True
         if not ans:
             print('Nothing done.')
             return
 
         if 's' in opts:                     # Soft reset
             user_ns = self.shell.user_ns
             for i in self.who_ls():
                 del(user_ns[i])
         elif len(args) == 0:                # Hard reset
             self.shell.reset(new_session = False)
 
         # reset in/out/dhist/array: previously extensinions/clearcmd.py
         ip = self.shell
         user_ns = self.shell.user_ns  # local lookup, heavily used
 
         for target in args:
             target = target.lower() # make matches case insensitive
             if target == 'out':
                 print("Flushing output cache (%d entries)" % len(user_ns['_oh']))
                 self.shell.displayhook.flush()
 
             elif target == 'in':
                 print("Flushing input history")
                 pc = self.shell.displayhook.prompt_count + 1
                 for n in range(1, pc):
                     key = '_i'+repr(n)
                     user_ns.pop(key,None)
                 user_ns.update(dict(_i=u'',_ii=u'',_iii=u''))
                 hm = ip.history_manager
                 # don't delete these, as %save and %macro depending on the
                 # length of these lists to be preserved
                 hm.input_hist_parsed[:] = [''] * pc
                 hm.input_hist_raw[:] = [''] * pc
                 # hm has internal machinery for _i,_ii,_iii, clear it out
                 hm._i = hm._ii = hm._iii = hm._i00 =  u''
 
             elif target == 'array':
                 # Support cleaning up numpy arrays
                 try:
                     from numpy import ndarray
                     # This must be done with items and not iteritems because
                     # we're going to modify the dict in-place.
                     for x,val in list(user_ns.items()):
                         if isinstance(val,ndarray):
                             del user_ns[x]
                 except ImportError:
                     print("reset array only works if Numpy is available.")
 
             elif target == 'dhist':
                 print("Flushing directory history")
                 del user_ns['_dh'][:]
 
             else:
                 print("Don't know how to reset ", end=' ')
                 print(target + ", please run `%reset?` for details")
 
         gc.collect()
 
     @line_magic
     def reset_selective(self, parameter_s=''):
         """Resets the namespace by removing names defined by the user.
 
         Input/Output history are left around in case you need them.
 
         %reset_selective [-f] regex
 
         No action is taken if regex is not included
 
         Options
           -f : force reset without asking for confirmation.
 
         See Also
         --------
         reset : invoked as ``%reset``
 
         Examples
         --------
 
         We first fully reset the namespace so your output looks identical to
         this example for pedagogical reasons; in practice you do not need a
         full reset::
 
           In [1]: %reset -f
 
         Now, with a clean namespace we can make a few variables and use
         ``%reset_selective`` to only delete names that match our regexp::
 
           In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
 
           In [3]: who_ls
           Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
 
           In [4]: %reset_selective -f b[2-3]m
 
           In [5]: who_ls
           Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
 
           In [6]: %reset_selective -f d
 
           In [7]: who_ls
           Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
 
           In [8]: %reset_selective -f c
 
           In [9]: who_ls
           Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
 
           In [10]: %reset_selective -f b
 
           In [11]: who_ls
           Out[11]: ['a']
 
         Notes
         -----
         Calling this magic from clients that do not implement standard input,
         such as the ipython notebook interface, will reset the namespace
         without confirmation.
         """
 
         opts, regex = self.parse_options(parameter_s,'f')
 
         if 'f' in opts:
             ans = True
         else:
             try:
                 ans = self.shell.ask_yes_no(
                 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ",
                 default='n')
             except StdinNotImplementedError:
                 ans = True
         if not ans:
             print('Nothing done.')
             return
         user_ns = self.shell.user_ns
         if not regex:
             print('No regex pattern specified. Nothing done.')
             return
         else:
             try:
                 m = re.compile(regex)
             except TypeError:
                 raise TypeError('regex must be a string or compiled pattern')
             for i in self.who_ls():
                 if m.search(i):
                     del(user_ns[i])
 
     @line_magic
     def xdel(self, parameter_s=''):
         """Delete a variable, trying to clear it from anywhere that
         IPython's machinery has references to it. By default, this uses
         the identity of the named object in the user namespace to remove
         references held under other names. The object is also removed
         from the output history.
 
         Options
           -n : Delete the specified name from all namespaces, without
           checking their identity.
         """
         opts, varname = self.parse_options(parameter_s,'n')
         try:
             self.shell.del_var(varname, ('n' in opts))
         except (NameError, ValueError) as e:
             print(type(e).__name__ +": "+ str(e))

IPython/lib/demo.py

@@ -1,667 +1,667
 """Module for interactive demos using IPython.
 
 This module implements a few classes for running Python scripts interactively
 in IPython for demonstrations.  With very simple markup (a few tags in
 comments), you can control points where the script stops executing and returns
 control to IPython.
 
 
 Provided classes
 ----------------
 
 The classes are (see their docstrings for further details):
 
  - Demo: pure python demos
 
  - IPythonDemo: demos with input to be processed by IPython as if it had been
    typed interactively (so magics work, as well as any other special syntax you
    may have added via input prefilters).
 
  - LineDemo: single-line version of the Demo class.  These demos are executed
    one line at a time, and require no markup.
 
  - IPythonLineDemo: IPython version of the LineDemo class (the demo is
    executed a line at a time, but processed via IPython).
 
  - ClearMixin: mixin to make Demo classes with less visual clutter.  It
    declares an empty marquee and a pre_cmd that clears the screen before each
    block (see Subclassing below).
 
  - ClearDemo, ClearIPDemo: mixin-enabled versions of the Demo and IPythonDemo
    classes.
 
 Inheritance diagram:
 
 .. inheritance-diagram:: IPython.lib.demo
    :parts: 3
 
 Subclassing
 -----------
 
 The classes here all include a few methods meant to make customization by
 subclassing more convenient.  Their docstrings below have some more details:
 
   - highlight(): format every block and optionally highlight comments and
     docstring content.
 
   - marquee(): generates a marquee to provide visible on-screen markers at each
     block start and end.
 
   - pre_cmd(): run right before the execution of each block.
 
   - post_cmd(): run right after the execution of each block.  If the block
     raises an exception, this is NOT called.
 
 
 Operation
 ---------
 
 The file is run in its own empty namespace (though you can pass it a string of
 arguments as if in a command line environment, and it will see those as
 sys.argv).  But at each stop, the global IPython namespace is updated with the
 current internal demo namespace, so you can work interactively with the data
 accumulated so far.
 
 By default, each block of code is printed (with syntax highlighting) before
 executing it and you have to confirm execution.  This is intended to show the
 code to an audience first so you can discuss it, and only proceed with
 execution once you agree.  There are a few tags which allow you to modify this
 behavior.
 
 The supported tags are:
 
 # <demo> stop
 
   Defines block boundaries, the points where IPython stops execution of the
   file and returns to the interactive prompt.
 
   You can optionally mark the stop tag with extra dashes before and after the
   word 'stop', to help visually distinguish the blocks in a text editor:
 
   # <demo> --- stop ---
 
 
 # <demo> silent
 
   Make a block execute silently (and hence automatically).  Typically used in
   cases where you have some boilerplate or initialization code which you need
   executed but do not want to be seen in the demo.
 
 # <demo> auto
 
   Make a block execute automatically, but still being printed.  Useful for
   simple code which does not warrant discussion, since it avoids the extra
   manual confirmation.
 
 # <demo> auto_all
 
   This tag can _only_ be in the first block, and if given it overrides the
   individual auto tags to make the whole demo fully automatic (no block asks
   for confirmation).  It can also be given at creation time (or the attribute
   set later) to override what's in the file.
 
 While _any_ python file can be run as a Demo instance, if there are no stop
 tags the whole file will run in a single block (no different that calling
 first %pycat and then %run).  The minimal markup to make this useful is to
 place a set of stop tags; the other tags are only there to let you fine-tune
 the execution.
 
 This is probably best explained with the simple example file below.  You can
 copy this into a file named ex_demo.py, and try running it via::
 
     from IPython.lib.demo import Demo
     d = Demo('ex_demo.py')
     d()
 
 Each time you call the demo object, it runs the next block.  The demo object
 has a few useful methods for navigation, like again(), edit(), jump(), seek()
 and back().  It can be reset for a new run via reset() or reloaded from disk
 (in case you've edited the source) via reload().  See their docstrings below.
 
 Note: To make this simpler to explore, a file called "demo-exercizer.py" has
 been added to the "docs/examples/core" directory.  Just cd to this directory in
 an IPython session, and type::
 
   %run demo-exercizer.py
 
 and then follow the directions.
 
 Example
 -------
 
 The following is a very simple example of a valid demo file.
 
 ::
 
     #################### EXAMPLE DEMO <ex_demo.py> ###############################
     '''A simple interactive demo to illustrate the use of IPython's Demo class.'''
 
     print 'Hello, welcome to an interactive IPython demo.'
 
     # The mark below defines a block boundary, which is a point where IPython will
     # stop execution and return to the interactive prompt. The dashes are actually
     # optional and used only as a visual aid to clearly separate blocks while
     # editing the demo code.
     # <demo> stop
 
     x = 1
     y = 2
 
     # <demo> stop
 
     # the mark below makes this block as silent
     # <demo> silent
 
     print 'This is a silent block, which gets executed but not printed.'
 
     # <demo> stop
     # <demo> auto
     print 'This is an automatic block.'
     print 'It is executed without asking for confirmation, but printed.'
     z = x+y
 
     print 'z=',x
 
     # <demo> stop
     # This is just another normal block.
     print 'z is now:', z
 
     print 'bye!'
     ################### END EXAMPLE DEMO <ex_demo.py> ############################
 """
 
 
 #*****************************************************************************
 #     Copyright (C) 2005-2006 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #
 #*****************************************************************************
 
 import os
 import re
 import shlex
 import sys
 import pygments
 
 from IPython.utils.text import marquee
 from IPython.utils import openpy
 from IPython.utils import py3compat
 __all__ = ['Demo','IPythonDemo','LineDemo','IPythonLineDemo','DemoError']
 
 class DemoError(Exception): pass
 
 def re_mark(mark):
     return re.compile(r'^\s*#\s+<demo>\s+%s\s*$' % mark,re.MULTILINE)
 
 class Demo(object):
 
-    re_stop     = re_mark('-*\s?stop\s?-*')
+    re_stop     = re_mark(r'-*\s?stop\s?-*')
     re_silent   = re_mark('silent')
     re_auto     = re_mark('auto')
     re_auto_all = re_mark('auto_all')
 
     def __init__(self,src,title='',arg_str='',auto_all=None, format_rst=False,
                  formatter='terminal', style='default'):
         """Make a new demo object.  To run the demo, simply call the object.
 
         See the module docstring for full details and an example (you can use
         IPython.Demo? in IPython to see it).
 
         Inputs:
 
           - src is either a file, or file-like object, or a
               string that can be resolved to a filename.
 
         Optional inputs:
 
           - title: a string to use as the demo name.  Of most use when the demo
             you are making comes from an object that has no filename, or if you
             want an alternate denotation distinct from the filename.
 
           - arg_str(''): a string of arguments, internally converted to a list
             just like sys.argv, so the demo script can see a similar
             environment.
 
           - auto_all(None): global flag to run all blocks automatically without
             confirmation.  This attribute overrides the block-level tags and
             applies to the whole demo.  It is an attribute of the object, and
             can be changed at runtime simply by reassigning it to a boolean
             value.
 
           - format_rst(False): a bool to enable comments and doc strings
             formatting with pygments rst lexer
 
           - formatter('terminal'): a string of pygments formatter name to be
             used. Useful values for terminals: terminal, terminal256,
             terminal16m
 
           - style('default'): a string of pygments style name to be used.
           """
         if hasattr(src, "read"):
              # It seems to be a file or a file-like object
             self.fname = "from a file-like object"
             if title == '':
                 self.title = "from a file-like object"
             else:
                 self.title = title
         else:
              # Assume it's a string or something that can be converted to one
             self.fname = src
             if title == '':
                 (filepath, filename) = os.path.split(src)
                 self.title = filename
             else:
                 self.title = title
         self.sys_argv = [src] + shlex.split(arg_str)
         self.auto_all = auto_all
         self.src = src
 
         self.inside_ipython = "get_ipython" in globals()
         if self.inside_ipython:
             # get a few things from ipython.  While it's a bit ugly design-wise,
             # it ensures that things like color scheme and the like are always in
             # sync with the ipython mode being used.  This class is only meant to
             # be used inside ipython anyways,  so it's OK.
             ip = get_ipython()  # this is in builtins whenever IPython is running
             self.ip_ns       = ip.user_ns
             self.ip_colorize = ip.pycolorize
             self.ip_showtb   = ip.showtraceback
             self.ip_run_cell = ip.run_cell
             self.shell       = ip
 
         self.formatter = pygments.formatters.get_formatter_by_name(formatter,
                                                                    style=style)
         self.python_lexer = pygments.lexers.get_lexer_by_name("py3")
         self.format_rst = format_rst
         if format_rst:
             self.rst_lexer = pygments.lexers.get_lexer_by_name("rst")
 
         # load user data and initialize data structures
         self.reload()
 
     def fload(self):
         """Load file object."""
         # read data and parse into blocks
         if hasattr(self, 'fobj') and self.fobj is not None:
            self.fobj.close()
         if hasattr(self.src, "read"):
              # It seems to be a file or a file-like object
             self.fobj = self.src
         else:
              # Assume it's a string or something that can be converted to one
             self.fobj = openpy.open(self.fname)
 
     def reload(self):
         """Reload source from disk and initialize state."""
         self.fload()
 
         self.src     = "".join(openpy.strip_encoding_cookie(self.fobj))
         src_b        = [b.strip() for b in self.re_stop.split(self.src) if b]
         self._silent = [bool(self.re_silent.findall(b)) for b in src_b]
         self._auto   = [bool(self.re_auto.findall(b)) for b in src_b]
 
         # if auto_all is not given (def. None), we read it from the file
         if self.auto_all is None:
             self.auto_all = bool(self.re_auto_all.findall(src_b[0]))
         else:
             self.auto_all = bool(self.auto_all)
 
         # Clean the sources from all markup so it doesn't get displayed when
         # running the demo
         src_blocks = []
         auto_strip = lambda s: self.re_auto.sub('',s)
         for i,b in enumerate(src_b):
             if self._auto[i]:
                 src_blocks.append(auto_strip(b))
             else:
                 src_blocks.append(b)
         # remove the auto_all marker
         src_blocks[0] = self.re_auto_all.sub('',src_blocks[0])
 
         self.nblocks = len(src_blocks)
         self.src_blocks = src_blocks
 
         # also build syntax-highlighted source
         self.src_blocks_colored = list(map(self.highlight,self.src_blocks))
 
         # ensure clean namespace and seek offset
         self.reset()
 
     def reset(self):
         """Reset the namespace and seek pointer to restart the demo"""
         self.user_ns     = {}
         self.finished    = False
         self.block_index = 0
 
     def _validate_index(self,index):
         if index<0 or index>=self.nblocks:
             raise ValueError('invalid block index %s' % index)
 
     def _get_index(self,index):
         """Get the current block index, validating and checking status.
 
         Returns None if the demo is finished"""
 
         if index is None:
             if self.finished:
                 print('Demo finished.  Use <demo_name>.reset() if you want to rerun it.')
                 return None
             index = self.block_index
         else:
             self._validate_index(index)
         return index
 
     def seek(self,index):
         """Move the current seek pointer to the given block.
 
         You can use negative indices to seek from the end, with identical
         semantics to those of Python lists."""
         if index<0:
             index = self.nblocks + index
         self._validate_index(index)
         self.block_index = index
         self.finished = False
 
     def back(self,num=1):
         """Move the seek pointer back num blocks (default is 1)."""
         self.seek(self.block_index-num)
 
     def jump(self,num=1):
         """Jump a given number of blocks relative to the current one.
 
         The offset can be positive or negative, defaults to 1."""
         self.seek(self.block_index+num)
 
     def again(self):
         """Move the seek pointer back one block and re-execute."""
         self.back(1)
         self()
 
     def edit(self,index=None):
         """Edit a block.
 
         If no number is given, use the last block executed.
 
         This edits the in-memory copy of the demo, it does NOT modify the
         original source file.  If you want to do that, simply open the file in
         an editor and use reload() when you make changes to the file.  This
         method is meant to let you change a block during a demonstration for
         explanatory purposes, without damaging your original script."""
 
         index = self._get_index(index)
         if index is None:
             return
         # decrease the index by one (unless we're at the very beginning), so
         # that the default demo.edit() call opens up the sblock we've last run
         if index>0:
             index -= 1
 
         filename = self.shell.mktempfile(self.src_blocks[index])
         self.shell.hooks.editor(filename,1)
         with open(filename, 'r') as f:
             new_block = f.read()
         # update the source and colored block
         self.src_blocks[index] = new_block
         self.src_blocks_colored[index] = self.highlight(new_block)
         self.block_index = index
         # call to run with the newly edited index
         self()
 
     def show(self,index=None):
         """Show a single block on screen"""
 
         index = self._get_index(index)
         if index is None:
             return
 
         print(self.marquee('<%s> block # %s (%s remaining)' %
                            (self.title,index,self.nblocks-index-1)))
         print(self.src_blocks_colored[index])
         sys.stdout.flush()
 
     def show_all(self):
         """Show entire demo on screen, block by block"""
 
         fname = self.title
         title = self.title
         nblocks = self.nblocks
         silent = self._silent
         marquee = self.marquee
         for index,block in enumerate(self.src_blocks_colored):
             if silent[index]:
                 print(marquee('<%s> SILENT block # %s (%s remaining)' %
                               (title,index,nblocks-index-1)))
             else:
                 print(marquee('<%s> block # %s (%s remaining)' %
                               (title,index,nblocks-index-1)))
             print(block, end=' ')
         sys.stdout.flush()
 
     def run_cell(self,source):
         """Execute a string with one or more lines of code"""
 
         exec(source, self.user_ns)
 
     def __call__(self,index=None):
         """run a block of the demo.
 
         If index is given, it should be an integer >=1 and <= nblocks.  This
         means that the calling convention is one off from typical Python
         lists.  The reason for the inconsistency is that the demo always
         prints 'Block n/N, and N is the total, so it would be very odd to use
         zero-indexing here."""
 
         index = self._get_index(index)
         if index is None:
             return
         try:
             marquee = self.marquee
             next_block = self.src_blocks[index]
             self.block_index += 1
             if self._silent[index]:
                 print(marquee('Executing silent block # %s (%s remaining)' %
                               (index,self.nblocks-index-1)))
             else:
                 self.pre_cmd()
                 self.show(index)
                 if self.auto_all or self._auto[index]:
                     print(marquee('output:'))
                 else:
                     print(marquee('Press <q> to quit, <Enter> to execute...'), end=' ')
                     ans = py3compat.input().strip()
                     if ans:
                         print(marquee('Block NOT executed'))
                         return
             try:
                 save_argv = sys.argv
                 sys.argv = self.sys_argv
                 self.run_cell(next_block)
                 self.post_cmd()
             finally:
                 sys.argv = save_argv
 
         except:
             if self.inside_ipython:
                 self.ip_showtb(filename=self.fname)
         else:
             if self.inside_ipython:
                 self.ip_ns.update(self.user_ns)
 
         if self.block_index == self.nblocks:
             mq1 = self.marquee('END OF DEMO')
             if mq1:
                 # avoid spurious print if empty marquees are used
                 print()
                 print(mq1)
                 print(self.marquee('Use <demo_name>.reset() if you want to rerun it.'))
             self.finished = True
 
     # These methods are meant to be overridden by subclasses who may wish to
     # customize the behavior of of their demos.
     def marquee(self,txt='',width=78,mark='*'):
         """Return the input string centered in a 'marquee'."""
         return marquee(txt,width,mark)
 
     def pre_cmd(self):
         """Method called before executing each block."""
         pass
 
     def post_cmd(self):
         """Method called after executing each block."""
         pass
 
     def highlight(self, block):
         """Method called on each block to highlight it content"""
         tokens = pygments.lex(block, self.python_lexer)
         if self.format_rst:
             from pygments.token import Token
             toks = []
             for token in tokens:
                 if token[0] == Token.String.Doc and len(token[1]) > 6:
                     toks += pygments.lex(token[1][:3], self.python_lexer)
                     # parse doc string content by rst lexer
                     toks += pygments.lex(token[1][3:-3], self.rst_lexer)
                     toks += pygments.lex(token[1][-3:], self.python_lexer)
                 elif token[0] == Token.Comment.Single:
                     toks.append((Token.Comment.Single, token[1][0]))
                     # parse comment content by rst lexer
                     # remove the extrat newline added by rst lexer
                     toks += list(pygments.lex(token[1][1:], self.rst_lexer))[:-1]
                 else:
                     toks.append(token)
             tokens = toks
         return pygments.format(tokens, self.formatter)
 
 
 class IPythonDemo(Demo):
     """Class for interactive demos with IPython's input processing applied.
 
     This subclasses Demo, but instead of executing each block by the Python
     interpreter (via exec), it actually calls IPython on it, so that any input
     filters which may be in place are applied to the input block.
 
     If you have an interactive environment which exposes special input
     processing, you can use this class instead to write demo scripts which
     operate exactly as if you had typed them interactively.  The default Demo
     class requires the input to be valid, pure Python code.
     """
 
     def run_cell(self,source):
         """Execute a string with one or more lines of code"""
 
         self.shell.run_cell(source)
 
 class LineDemo(Demo):
     """Demo where each line is executed as a separate block.
 
     The input script should be valid Python code.
 
     This class doesn't require any markup at all, and it's meant for simple
     scripts (with no nesting or any kind of indentation) which consist of
     multiple lines of input to be executed, one at a time, as if they had been
     typed in the interactive prompt.
 
     Note: the input can not have *any* indentation, which means that only
     single-lines of input are accepted, not even function definitions are
     valid."""
 
     def reload(self):
         """Reload source from disk and initialize state."""
         # read data and parse into blocks
         self.fload()
         lines           = self.fobj.readlines()
         src_b           = [l for l in lines if l.strip()]
         nblocks         = len(src_b)
         self.src        = ''.join(lines)
         self._silent    = [False]*nblocks
         self._auto      = [True]*nblocks
         self.auto_all   = True
         self.nblocks    = nblocks
         self.src_blocks = src_b
 
         # also build syntax-highlighted source
         self.src_blocks_colored = list(map(self.highlight,self.src_blocks))
 
         # ensure clean namespace and seek offset
         self.reset()
 
 
 class IPythonLineDemo(IPythonDemo,LineDemo):
     """Variant of the LineDemo class whose input is processed by IPython."""
     pass
 
 
 class ClearMixin(object):
     """Use this mixin to make Demo classes with less visual clutter.
 
     Demos using this mixin will clear the screen before every block and use
     blank marquees.
 
     Note that in order for the methods defined here to actually override those
     of the classes it's mixed with, it must go /first/ in the inheritance
     tree.  For example:
 
         class ClearIPDemo(ClearMixin,IPythonDemo): pass
 
     will provide an IPythonDemo class with the mixin's features.
     """
 
     def marquee(self,txt='',width=78,mark='*'):
         """Blank marquee that returns '' no matter what the input."""
         return ''
 
     def pre_cmd(self):
         """Method called before executing each block.
 
         This one simply clears the screen."""
         from IPython.utils.terminal import _term_clear
         _term_clear()
 
 class ClearDemo(ClearMixin,Demo):
     pass
 
 
 class ClearIPDemo(ClearMixin,IPythonDemo):
     pass
 
 
 def slide(file_path, noclear=False, format_rst=True, formatter="terminal",
           style="native", auto_all=False, delimiter='...'):
     if noclear:
         demo_class = Demo
     else:
         demo_class = ClearDemo
     demo = demo_class(file_path, format_rst=format_rst, formatter=formatter,
                       style=style, auto_all=auto_all)
     while not demo.finished:
         demo()
         try:
             py3compat.input('\n' + delimiter)
         except KeyboardInterrupt:
             exit(1)
 
 if __name__ == '__main__':
     import argparse
     parser = argparse.ArgumentParser(description='Run python demos')
     parser.add_argument('--noclear', '-C', action='store_true',
                         help='Do not clear terminal on each slide')
     parser.add_argument('--rst', '-r', action='store_true',
                         help='Highlight comments and dostrings as rst')
     parser.add_argument('--formatter', '-f', default='terminal',
                         help='pygments formatter name could be: terminal, '
                         'terminal256, terminal16m')
     parser.add_argument('--style', '-s', default='default',
                         help='pygments style name')
     parser.add_argument('--auto', '-a', action='store_true',
                         help='Run all blocks automatically without'
                         'confirmation')
     parser.add_argument('--delimiter', '-d', default='...',
                         help='slides delimiter added after each slide run')
     parser.add_argument('file', nargs=1,
                         help='python demo file')
     args = parser.parse_args()
     slide(args.file[0], noclear=args.noclear, format_rst=args.rst,
           formatter=args.formatter, style=args.style, auto_all=args.auto,
           delimiter=args.delimiter)

IPython/lib/latextools.py

@@ -1,201 +1,201
 # -*- coding: utf-8 -*-
 """Tools for handling LaTeX."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from io import BytesIO, open
 import os
 import tempfile
 import shutil
 import subprocess
 from base64 import encodebytes
 
 from IPython.utils.process import find_cmd, FindCmdError
 from traitlets.config import get_config
 from traitlets.config.configurable import SingletonConfigurable
 from traitlets import List, Bool, Unicode
 from IPython.utils.py3compat import cast_unicode
 
 
 class LaTeXTool(SingletonConfigurable):
     """An object to store configuration of the LaTeX tool."""
     def _config_default(self):
         return get_config()
     
     backends = List(
         Unicode(), ["matplotlib", "dvipng"],
         help="Preferred backend to draw LaTeX math equations. "
         "Backends in the list are checked one by one and the first "
         "usable one is used.  Note that `matplotlib` backend "
         "is usable only for inline style equations.  To draw  "
         "display style equations, `dvipng` backend must be specified. ",
         # It is a List instead of Enum, to make configuration more
         # flexible.  For example, to use matplotlib mainly but dvipng
         # for display style, the default ["matplotlib", "dvipng"] can
         # be used.  To NOT use dvipng so that other repr such as
         # unicode pretty printing is used, you can use ["matplotlib"].
         ).tag(config=True)
 
     use_breqn = Bool(
         True,
         help="Use breqn.sty to automatically break long equations. "
         "This configuration takes effect only for dvipng backend.",
         ).tag(config=True)
 
     packages = List(
         ['amsmath', 'amsthm', 'amssymb', 'bm'],
         help="A list of packages to use for dvipng backend. "
         "'breqn' will be automatically appended when use_breqn=True.",
         ).tag(config=True)
 
     preamble = Unicode(
         help="Additional preamble to use when generating LaTeX source "
         "for dvipng backend.",
         ).tag(config=True)
 
 
 def latex_to_png(s, encode=False, backend=None, wrap=False):
     """Render a LaTeX string to PNG.
 
     Parameters
     ----------
     s : str
         The raw string containing valid inline LaTeX.
     encode : bool, optional
         Should the PNG data base64 encoded to make it JSON'able.
     backend : {matplotlib, dvipng}
         Backend for producing PNG data.
     wrap : bool
         If true, Automatically wrap `s` as a LaTeX equation.
 
     None is returned when the backend cannot be used.
 
     """
     s = cast_unicode(s)
     allowed_backends = LaTeXTool.instance().backends
     if backend is None:
         backend = allowed_backends[0]
     if backend not in allowed_backends:
         return None
     if backend == 'matplotlib':
         f = latex_to_png_mpl
     elif backend == 'dvipng':
         f = latex_to_png_dvipng
     else:
         raise ValueError('No such backend {0}'.format(backend))
     bin_data = f(s, wrap)
     if encode and bin_data:
         bin_data = encodebytes(bin_data)
     return bin_data
 
 
 def latex_to_png_mpl(s, wrap):
     try:
         from matplotlib import mathtext
         from pyparsing import ParseFatalException
     except ImportError:
         return None
 
     # mpl mathtext doesn't support display math, force inline
     s = s.replace('$$', '$')
     if wrap:
         s = u'${0}$'.format(s)
 
     try:
         mt = mathtext.MathTextParser('bitmap')
         f = BytesIO()
         mt.to_png(f, s, fontsize=12)
         return f.getvalue()
     except (ValueError, RuntimeError, ParseFatalException):
         return None
 
 
 def latex_to_png_dvipng(s, wrap):
     try:
         find_cmd('latex')
         find_cmd('dvipng')
     except FindCmdError:
         return None
     try:
         workdir = tempfile.mkdtemp()
         tmpfile = os.path.join(workdir, "tmp.tex")
         dvifile = os.path.join(workdir, "tmp.dvi")
         outfile = os.path.join(workdir, "tmp.png")
 
         with open(tmpfile, "w", encoding='utf8') as f:
             f.writelines(genelatex(s, wrap))
 
         with open(os.devnull, 'wb') as devnull:
             subprocess.check_call(
                 ["latex", "-halt-on-error", "-interaction", "batchmode", tmpfile],
                 cwd=workdir, stdout=devnull, stderr=devnull)
 
             subprocess.check_call(
                 ["dvipng", "-T", "tight", "-x", "1500", "-z", "9",
                  "-bg", "transparent", "-o", outfile, dvifile], cwd=workdir,
                 stdout=devnull, stderr=devnull)
 
         with open(outfile, "rb") as f:
             return f.read()
     except subprocess.CalledProcessError:
         return None
     finally:
         shutil.rmtree(workdir)
 
 
 def kpsewhich(filename):
     """Invoke kpsewhich command with an argument `filename`."""
     try:
         find_cmd("kpsewhich")
         proc = subprocess.Popen(
             ["kpsewhich", filename],
             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         (stdout, stderr) = proc.communicate()
         return stdout.strip().decode('utf8', 'replace')
     except FindCmdError:
         pass
 
 
 def genelatex(body, wrap):
     """Generate LaTeX document for dvipng backend."""
     lt = LaTeXTool.instance()
     breqn = wrap and lt.use_breqn and kpsewhich("breqn.sty")
     yield r'\documentclass{article}'
     packages = lt.packages
     if breqn:
         packages = packages + ['breqn']
     for pack in packages:
         yield r'\usepackage{{{0}}}'.format(pack)
     yield r'\pagestyle{empty}'
     if lt.preamble:
         yield lt.preamble
     yield r'\begin{document}'
     if breqn:
         yield r'\begin{dmath*}'
         yield body
         yield r'\end{dmath*}'
     elif wrap:
         yield u'$${0}$$'.format(body)
     else:
         yield body
-    yield u'\end{document}'
+    yield u'\\end{document}'
 
 
 _data_uri_template_png = u"""<img src="data:image/png;base64,%s" alt=%s />"""
 
 def latex_to_html(s, alt='image'):
     """Render LaTeX to HTML with embedded PNG data using data URIs.
 
     Parameters
     ----------
     s : str
         The raw string containing valid inline LateX.
     alt : str
         The alt text to use for the HTML.
     """
     base64_data = latex_to_png(s, encode=True).decode('ascii')
     if base64_data:
         return _data_uri_template_png  % (base64_data, alt)
 
 

IPython/lib/lexers.py

@@ -1,532 +1,532
 # -*- coding: utf-8 -*-
 """
 Defines a variety of Pygments lexers for highlighting IPython code.
 
 This includes:
 
     IPythonLexer, IPython3Lexer
         Lexers for pure IPython (python + magic/shell commands)
 
     IPythonPartialTracebackLexer, IPythonTracebackLexer
         Supports 2.x and 3.x via keyword `python3`.  The partial traceback
         lexer reads everything but the Python code appearing in a traceback.
         The full lexer combines the partial lexer with an IPython lexer.
 
     IPythonConsoleLexer
         A lexer for IPython console sessions, with support for tracebacks.
 
     IPyLexer
         A friendly lexer which examines the first line of text and from it,
         decides whether to use an IPython lexer or an IPython console lexer.
         This is probably the only lexer that needs to be explicitly added
         to Pygments.
 
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 # Standard library
 import re
 
 # Third party
 from pygments.lexers import (
     BashLexer, HtmlLexer, JavascriptLexer, RubyLexer, PerlLexer, PythonLexer,
     Python3Lexer, TexLexer)
 from pygments.lexer import (
     Lexer, DelegatingLexer, RegexLexer, do_insertions, bygroups, using,
 )
 from pygments.token import (
     Generic, Keyword, Literal, Name, Operator, Other, Text, Error,
 )
 from pygments.util import get_bool_opt
 
 # Local
 
 line_re = re.compile('.*?\n')
 
 __all__ = ['build_ipy_lexer', 'IPython3Lexer', 'IPythonLexer',
            'IPythonPartialTracebackLexer', 'IPythonTracebackLexer',
            'IPythonConsoleLexer', 'IPyLexer']
 
 
 def build_ipy_lexer(python3):
     """Builds IPython lexers depending on the value of `python3`.
 
     The lexer inherits from an appropriate Python lexer and then adds
     information about IPython specific keywords (i.e. magic commands,
     shell commands, etc.)
 
     Parameters
     ----------
     python3 : bool
         If `True`, then build an IPython lexer from a Python 3 lexer.
 
     """
     # It would be nice to have a single IPython lexer class which takes
     # a boolean `python3`.  But since there are two Python lexer classes,
     # we will also have two IPython lexer classes.
     if python3:
         PyLexer = Python3Lexer
         name = 'IPython3'
         aliases = ['ipython3']
         doc = """IPython3 Lexer"""
     else:
         PyLexer = PythonLexer
         name = 'IPython'
         aliases = ['ipython2', 'ipython']
         doc = """IPython Lexer"""
 
     ipython_tokens = [
        (r'(?s)(\s*)(%%capture)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
         (r'(?s)(\s*)(%%debug)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
         (r'(?is)(\s*)(%%html)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(HtmlLexer))),
         (r'(?s)(\s*)(%%javascript)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(JavascriptLexer))),
         (r'(?s)(\s*)(%%js)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(JavascriptLexer))),
         (r'(?s)(\s*)(%%latex)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(TexLexer))),
         (r'(?s)(\s*)(%%perl)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PerlLexer))),
         (r'(?s)(\s*)(%%prun)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
         (r'(?s)(\s*)(%%pypy)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
         (r'(?s)(\s*)(%%python)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
         (r'(?s)(\s*)(%%python2)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PythonLexer))),
         (r'(?s)(\s*)(%%python3)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(Python3Lexer))),
         (r'(?s)(\s*)(%%ruby)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(RubyLexer))),
         (r'(?s)(\s*)(%%time)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
         (r'(?s)(\s*)(%%timeit)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
         (r'(?s)(\s*)(%%writefile)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
         (r'(?s)(\s*)(%%file)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))),
         (r"(?s)(\s*)(%%)(\w+)(.*)", bygroups(Text, Operator, Keyword, Text)),
         (r'(?s)(^\s*)(%%!)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(BashLexer))),
         (r"(%%?)(\w+)(\?\??)$",  bygroups(Operator, Keyword, Operator)),
         (r"\b(\?\??)(\s*)$",  bygroups(Operator, Text)),
         (r'(%)(sx|sc|system)(.*)(\n)', bygroups(Operator, Keyword,
                                                 using(BashLexer), Text)),
         (r'(%)(\w+)(.*\n)', bygroups(Operator, Keyword, Text)),
         (r'^(!!)(.+)(\n)', bygroups(Operator, using(BashLexer), Text)),
         (r'(!)(?!=)(.+)(\n)', bygroups(Operator, using(BashLexer), Text)),
         (r'^(\s*)(\?\??)(\s*%{0,2}[\w\.\*]*)', bygroups(Text, Operator, Text)),
         (r'(\s*%{0,2}[\w\.\*]*)(\?\??)(\s*)$', bygroups(Text, Operator, Text)),
     ]
 
     tokens = PyLexer.tokens.copy()
     tokens['root'] = ipython_tokens + tokens['root']
 
     attrs = {'name': name, 'aliases': aliases, 'filenames': [],
              '__doc__': doc, 'tokens': tokens}
 
     return type(name, (PyLexer,), attrs)
 
 
 IPython3Lexer = build_ipy_lexer(python3=True)
 IPythonLexer = build_ipy_lexer(python3=False)
 
 
 class IPythonPartialTracebackLexer(RegexLexer):
     """
     Partial lexer for IPython tracebacks.
 
     Handles all the non-python output. This works for both Python 2.x and 3.x.
 
     """
     name = 'IPython Partial Traceback'
 
     tokens = {
         'root': [
             # Tracebacks for syntax errors have a different style.
             # For both types of tracebacks, we mark the first line with
             # Generic.Traceback.  For syntax errors, we mark the filename
             # as we mark the filenames for non-syntax tracebacks.
             #
             # These two regexps define how IPythonConsoleLexer finds a
             # traceback.
             #
             ## Non-syntax traceback
             (r'^(\^C)?(-+\n)', bygroups(Error, Generic.Traceback)),
             ## Syntax traceback
             (r'^(  File)(.*)(, line )(\d+\n)',
              bygroups(Generic.Traceback, Name.Namespace,
                       Generic.Traceback, Literal.Number.Integer)),
 
             # (Exception Identifier)(Whitespace)(Traceback Message)
             (r'(?u)(^[^\d\W]\w*)(\s*)(Traceback.*?\n)',
              bygroups(Name.Exception, Generic.Whitespace, Text)),
             # (Module/Filename)(Text)(Callee)(Function Signature)
             # Better options for callee and function signature?
             (r'(.*)( in )(.*)(\(.*\)\n)',
              bygroups(Name.Namespace, Text, Name.Entity, Name.Tag)),
             # Regular line: (Whitespace)(Line Number)(Python Code)
             (r'(\s*?)(\d+)(.*?\n)',
              bygroups(Generic.Whitespace, Literal.Number.Integer, Other)),
             # Emphasized line: (Arrow)(Line Number)(Python Code)
             # Using Exception token so arrow color matches the Exception.
             (r'(-*>?\s?)(\d+)(.*?\n)',
              bygroups(Name.Exception, Literal.Number.Integer, Other)),
             # (Exception Identifier)(Message)
             (r'(?u)(^[^\d\W]\w*)(:.*?\n)',
              bygroups(Name.Exception, Text)),
             # Tag everything else as Other, will be handled later.
             (r'.*\n', Other),
         ],
     }
 
 
 class IPythonTracebackLexer(DelegatingLexer):
     """
     IPython traceback lexer.
 
     For doctests, the tracebacks can be snipped as much as desired with the
     exception to the lines that designate a traceback. For non-syntax error
     tracebacks, this is the line of hyphens. For syntax error tracebacks,
     this is the line which lists the File and line number.
 
     """
     # The lexer inherits from DelegatingLexer.  The "root" lexer is an
     # appropriate IPython lexer, which depends on the value of the boolean
     # `python3`.  First, we parse with the partial IPython traceback lexer.
     # Then, any code marked with the "Other" token is delegated to the root
     # lexer.
     #
     name = 'IPython Traceback'
     aliases = ['ipythontb']
 
     def __init__(self, **options):
         self.python3 = get_bool_opt(options, 'python3', False)
         if self.python3:
             self.aliases = ['ipython3tb']
         else:
             self.aliases = ['ipython2tb', 'ipythontb']
 
         if self.python3:
             IPyLexer = IPython3Lexer
         else:
             IPyLexer = IPythonLexer
 
         DelegatingLexer.__init__(self, IPyLexer,
                                  IPythonPartialTracebackLexer, **options)
 
 class IPythonConsoleLexer(Lexer):
     """
     An IPython console lexer for IPython code-blocks and doctests, such as:
 
     .. code-block:: rst
 
         .. code-block:: ipythonconsole
 
             In [1]: a = 'foo'
 
             In [2]: a
             Out[2]: 'foo'
 
             In [3]: print a
             foo
 
             In [4]: 1 / 0
 
 
     Support is also provided for IPython exceptions:
 
     .. code-block:: rst
 
         .. code-block:: ipythonconsole
 
             In [1]: raise Exception
 
             ---------------------------------------------------------------------------
             Exception                                 Traceback (most recent call last)
             <ipython-input-1-fca2ab0ca76b> in <module>
             ----> 1 raise Exception
 
             Exception:
 
     """
     name = 'IPython console session'
     aliases = ['ipythonconsole']
     mimetypes = ['text/x-ipython-console']
 
     # The regexps used to determine what is input and what is output.
     # The default prompts for IPython are:
     #
     #    in           = 'In [#]: '
     #    continuation = '   .D.: '
     #    template     = 'Out[#]: '
     #
     # Where '#' is the 'prompt number' or 'execution count' and 'D' 
     # D is a number of dots  matching the width of the execution count 
     #
     in1_regex = r'In \[[0-9]+\]: '
     in2_regex = r'   \.\.+\.: '
     out_regex = r'Out\[[0-9]+\]: '
 
     #: The regex to determine when a traceback starts.
     ipytb_start = re.compile(r'^(\^C)?(-+\n)|^(  File)(.*)(, line )(\d+\n)')
 
     def __init__(self, **options):
         """Initialize the IPython console lexer.
 
         Parameters
         ----------
         python3 : bool
             If `True`, then the console inputs are parsed using a Python 3
             lexer. Otherwise, they are parsed using a Python 2 lexer.
         in1_regex : RegexObject
             The compiled regular expression used to detect the start
             of inputs. Although the IPython configuration setting may have a
             trailing whitespace, do not include it in the regex. If `None`,
             then the default input prompt is assumed.
         in2_regex : RegexObject
             The compiled regular expression used to detect the continuation
             of inputs. Although the IPython configuration setting may have a
             trailing whitespace, do not include it in the regex. If `None`,
             then the default input prompt is assumed.
         out_regex : RegexObject
             The compiled regular expression used to detect outputs. If `None`,
             then the default output prompt is assumed.
 
         """
         self.python3 = get_bool_opt(options, 'python3', False)
         if self.python3:
             self.aliases = ['ipython3console']
         else:
             self.aliases = ['ipython2console', 'ipythonconsole']
 
         in1_regex = options.get('in1_regex', self.in1_regex)
         in2_regex = options.get('in2_regex', self.in2_regex)
         out_regex = options.get('out_regex', self.out_regex)
 
         # So that we can work with input and output prompts which have been
         # rstrip'd (possibly by editors) we also need rstrip'd variants. If
         # we do not do this, then such prompts will be tagged as 'output'.
         # The reason can't just use the rstrip'd variants instead is because
         # we want any whitespace associated with the prompt to be inserted
         # with the token. This allows formatted code to be modified so as hide
         # the appearance of prompts, with the whitespace included. One example
         # use of this is in copybutton.js from the standard lib Python docs.
         in1_regex_rstrip = in1_regex.rstrip() + '\n'
         in2_regex_rstrip = in2_regex.rstrip() + '\n'
         out_regex_rstrip = out_regex.rstrip() + '\n'
 
         # Compile and save them all.
         attrs = ['in1_regex', 'in2_regex', 'out_regex',
                  'in1_regex_rstrip', 'in2_regex_rstrip', 'out_regex_rstrip']
         for attr in attrs:
             self.__setattr__(attr, re.compile(locals()[attr]))
 
         Lexer.__init__(self, **options)
 
         if self.python3:
             pylexer = IPython3Lexer
             tblexer = IPythonTracebackLexer
         else:
             pylexer = IPythonLexer
             tblexer = IPythonTracebackLexer
 
         self.pylexer = pylexer(**options)
         self.tblexer = tblexer(**options)
 
         self.reset()
 
     def reset(self):
         self.mode = 'output'
         self.index = 0
         self.buffer = u''
         self.insertions = []
 
     def buffered_tokens(self):
         """
         Generator of unprocessed tokens after doing insertions and before
         changing to a new state.
 
         """
         if self.mode == 'output':
             tokens = [(0, Generic.Output, self.buffer)]
         elif self.mode == 'input':
             tokens = self.pylexer.get_tokens_unprocessed(self.buffer)
         else: # traceback
             tokens = self.tblexer.get_tokens_unprocessed(self.buffer)
 
         for i, t, v in do_insertions(self.insertions, tokens):
             # All token indexes are relative to the buffer.
             yield self.index + i, t, v
 
         # Clear it all
         self.index += len(self.buffer)
         self.buffer = u''
         self.insertions = []
 
     def get_mci(self, line):
         """
         Parses the line and returns a 3-tuple: (mode, code, insertion).
 
         `mode` is the next mode (or state) of the lexer, and is always equal
         to 'input', 'output', or 'tb'.
 
         `code` is a portion of the line that should be added to the buffer
         corresponding to the next mode and eventually lexed by another lexer.
         For example, `code` could be Python code if `mode` were 'input'.
 
         `insertion` is a 3-tuple (index, token, text) representing an
         unprocessed "token" that will be inserted into the stream of tokens
         that are created from the buffer once we change modes. This is usually
         the input or output prompt.
 
         In general, the next mode depends on current mode and on the contents
         of `line`.
 
         """
         # To reduce the number of regex match checks, we have multiple
         # 'if' blocks instead of 'if-elif' blocks.
 
         # Check for possible end of input
         in2_match = self.in2_regex.match(line)
         in2_match_rstrip = self.in2_regex_rstrip.match(line)
         if (in2_match and in2_match.group().rstrip() == line.rstrip()) or \
            in2_match_rstrip:
             end_input = True
         else:
             end_input = False
         if end_input and self.mode != 'tb':
             # Only look for an end of input when not in tb mode.
             # An ellipsis could appear within the traceback.
             mode = 'output'
             code = u''
             insertion = (0, Generic.Prompt, line)
             return mode, code, insertion
 
         # Check for output prompt
         out_match = self.out_regex.match(line)
         out_match_rstrip = self.out_regex_rstrip.match(line)
         if out_match or out_match_rstrip:
             mode = 'output'
             if out_match:
                 idx = out_match.end()
             else:
                 idx = out_match_rstrip.end()
             code = line[idx:]
             # Use the 'heading' token for output.  We cannot use Generic.Error
             # since it would conflict with exceptions.
             insertion = (0, Generic.Heading, line[:idx])
             return mode, code, insertion
 
 
         # Check for input or continuation prompt (non stripped version)
         in1_match = self.in1_regex.match(line)
         if in1_match or (in2_match and self.mode != 'tb'):
             # New input or when not in tb, continued input.
             # We do not check for continued input when in tb since it is
             # allowable to replace a long stack with an ellipsis.
             mode = 'input'
             if in1_match:
                 idx = in1_match.end()
             else: # in2_match
                 idx = in2_match.end()
             code = line[idx:]
             insertion = (0, Generic.Prompt, line[:idx])
             return mode, code, insertion
 
         # Check for input or continuation prompt (stripped version)
         in1_match_rstrip = self.in1_regex_rstrip.match(line)
         if in1_match_rstrip or (in2_match_rstrip and self.mode != 'tb'):
             # New input or when not in tb, continued input.
             # We do not check for continued input when in tb since it is
             # allowable to replace a long stack with an ellipsis.
             mode = 'input'
             if in1_match_rstrip:
                 idx = in1_match_rstrip.end()
             else: # in2_match
                 idx = in2_match_rstrip.end()
             code = line[idx:]
             insertion = (0, Generic.Prompt, line[:idx])
             return mode, code, insertion
 
         # Check for traceback
         if self.ipytb_start.match(line):
             mode = 'tb'
             code = line
             insertion = None
             return mode, code, insertion
 
         # All other stuff...
         if self.mode in ('input', 'output'):
             # We assume all other text is output. Multiline input that
             # does not use the continuation marker cannot be detected.
             # For example, the 3 in the following is clearly output:
             #
             #    In [1]: print 3
             #    3
             #
             # But the following second line is part of the input:
             #
             #    In [2]: while True:
             #        print True
             #
             # In both cases, the 2nd line will be 'output'.
             #
             mode = 'output'
         else:
             mode = 'tb'
 
         code = line
         insertion = None
 
         return mode, code, insertion
 
     def get_tokens_unprocessed(self, text):
         self.reset()
         for match in line_re.finditer(text):
             line = match.group()
             mode, code, insertion = self.get_mci(line)
 
             if mode != self.mode:
                 # Yield buffered tokens before transitioning to new mode.
                 for token in self.buffered_tokens():
                     yield token
                 self.mode = mode
 
             if insertion:
                 self.insertions.append((len(self.buffer), [insertion]))
             self.buffer += code
 
         for token in self.buffered_tokens():
             yield token
 
 class IPyLexer(Lexer):
-    """
+    r"""
     Primary lexer for all IPython-like code.
 
     This is a simple helper lexer.  If the first line of the text begins with
     "In \[[0-9]+\]:", then the entire text is parsed with an IPython console
     lexer. If not, then the entire text is parsed with an IPython lexer.
 
     The goal is to reduce the number of lexers that are registered
     with Pygments.
 
     """
     name = 'IPy session'
     aliases = ['ipy']
 
     def __init__(self, **options):
         self.python3 = get_bool_opt(options, 'python3', False)
         if self.python3:
             self.aliases = ['ipy3']
         else:
             self.aliases = ['ipy2', 'ipy']
 
         Lexer.__init__(self, **options)
 
         self.IPythonLexer = IPythonLexer(**options)
         self.IPythonConsoleLexer = IPythonConsoleLexer(**options)
 
     def get_tokens_unprocessed(self, text):
         # Search for the input prompt anywhere...this allows code blocks to
         # begin with comments as well.
         if re.match(r'.*(In \[[0-9]+\]:)', text.strip(), re.DOTALL):
             lex = self.IPythonConsoleLexer
         else:
             lex = self.IPythonLexer
         for token in lex.get_tokens_unprocessed(text):
             yield token
 

IPython/testing/ipunittest.py

@@ -1,177 +1,177
 """Experimental code for cleaner support of IPython syntax with unittest.
 
 In IPython up until 0.10, we've used very hacked up nose machinery for running
 tests with IPython special syntax, and this has proved to be extremely slow.
 This module provides decorators to try a different approach, stemming from a
 conversation Brian and I (FP) had about this problem Sept/09.
 
 The goal is to be able to easily write simple functions that can be seen by
 unittest as tests, and ultimately for these to support doctests with full
 IPython syntax.  Nose already offers this based on naming conventions and our
 hackish plugins, but we are seeking to move away from nose dependencies if
 possible.
 
 This module follows a different approach, based on decorators.
 
 - A decorator called @ipdoctest can mark any function as having a docstring
   that should be viewed as a doctest, but after syntax conversion.
 
 Authors
 -------
 
 - Fernando Perez <[e-mail]>
 """
 
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib
 import re
 import unittest
 from doctest import DocTestFinder, DocTestRunner, TestResults
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 def count_failures(runner):
     """Count number of failures in a doctest runner.
 
     Code modeled after the summarize() method in doctest.
     """
     return [TestResults(f, t) for f, t in runner._name2ft.values() if f > 0 ]
 
 
 class IPython2PythonConverter(object):
     """Convert IPython 'syntax' to valid Python.
 
     Eventually this code may grow to be the full IPython syntax conversion
     implementation, but for now it only does prompt conversion."""
     
     def __init__(self):
         self.rps1 = re.compile(r'In\ \[\d+\]: ')
         self.rps2 = re.compile(r'\ \ \ \.\.\.+: ')
         self.rout = re.compile(r'Out\[\d+\]: \s*?\n?')
         self.pyps1 = '>>> '
         self.pyps2 = '... '
-        self.rpyps1 = re.compile ('(\s*%s)(.*)$' % self.pyps1)
-        self.rpyps2 = re.compile ('(\s*%s)(.*)$' % self.pyps2)
+        self.rpyps1 = re.compile (r'(\s*%s)(.*)$' % self.pyps1)
+        self.rpyps2 = re.compile (r'(\s*%s)(.*)$' % self.pyps2)
 
     def __call__(self, ds):
         """Convert IPython prompts to python ones in a string."""
         from . import globalipapp
 
         pyps1 = '>>> '
         pyps2 = '... '
         pyout = ''
 
         dnew = ds
         dnew = self.rps1.sub(pyps1, dnew)
         dnew = self.rps2.sub(pyps2, dnew)
         dnew = self.rout.sub(pyout, dnew)
         ip = globalipapp.get_ipython()
 
         # Convert input IPython source into valid Python.
         out = []
         newline = out.append
         for line in dnew.splitlines():
 
             mps1 = self.rpyps1.match(line)
             if mps1 is not None:
                 prompt, text = mps1.groups()
                 newline(prompt+ip.prefilter(text, False))
                 continue
 
             mps2 = self.rpyps2.match(line)
             if mps2 is not None:
                 prompt, text = mps2.groups()
                 newline(prompt+ip.prefilter(text, True))
                 continue
             
             newline(line)
         newline('')  # ensure a closing newline, needed by doctest
         #print "PYSRC:", '\n'.join(out)  # dbg
         return '\n'.join(out)
 
     #return dnew
 
 
 class Doc2UnitTester(object):
     """Class whose instances act as a decorator for docstring testing.
 
     In practice we're only likely to need one instance ever, made below (though
     no attempt is made at turning it into a singleton, there is no need for
     that).
     """
     def __init__(self, verbose=False):
         """New decorator.
 
         Parameters
         ----------
 
         verbose : boolean, optional (False)
           Passed to the doctest finder and runner to control verbosity.
         """
         self.verbose = verbose
         # We can reuse the same finder for all instances
         self.finder = DocTestFinder(verbose=verbose, recurse=False)
 
     def __call__(self, func):
         """Use as a decorator: doctest a function's docstring as a unittest.
         
         This version runs normal doctests, but the idea is to make it later run
         ipython syntax instead."""
 
         # Capture the enclosing instance with a different name, so the new
         # class below can see it without confusion regarding its own 'self'
         # that will point to the test instance at runtime
         d2u = self
 
         # Rewrite the function's docstring to have python syntax
         if func.__doc__ is not None:
             func.__doc__ = ip2py(func.__doc__)
 
         # Now, create a tester object that is a real unittest instance, so
         # normal unittest machinery (or Nose, or Trial) can find it.
         class Tester(unittest.TestCase):
             def test(self):
                 # Make a new runner per function to be tested
                 runner = DocTestRunner(verbose=d2u.verbose)
                 for the_test in d2u.finder.find(func, func.__name__):
                     runner.run(the_test)
                 failed = count_failures(runner)
                 if failed:
                     # Since we only looked at a single function's docstring,
                     # failed should contain at most one item.  More than that
                     # is a case we can't handle and should error out on
                     if len(failed) > 1:
                         err = "Invalid number of test results:" % failed
                         raise ValueError(err)
                     # Report a normal failure.
                     self.fail('failed doctests: %s' % str(failed[0]))
                     
         # Rename it so test reports have the original signature.
         Tester.__name__ = func.__name__
         return Tester
 
 
 def ipdocstring(func):
     """Change the function docstring via ip2py.
     """
     if func.__doc__ is not None:
         func.__doc__ = ip2py(func.__doc__)
     return func
 
         
 # Make an instance of the classes for public use
 ipdoctest = Doc2UnitTester()
 ip2py = IPython2PythonConverter()