Fix various warnings for broken references etc

IPython/core/completer.py

@@ -1,1267 +1,1267 b''
 # encoding: utf-8
 """Word completion for IPython.
 
 This module is a fork of the rlcompleter module in the Python standard
 library.  The original enhancements made to rlcompleter have been sent
 upstream and were accepted as of Python 2.3, but we need a lot more
 functionality specific to IPython, so this module will continue to live as an
 IPython-specific utility.
 
 Original rlcompleter documentation:
 
 This requires the latest extension to the readline module (the
 completes keywords, built-ins and globals in __main__; when completing
 NAME.NAME..., it evaluates (!) the expression up to the last dot and
 completes its attributes.
 
 It's very cool to do "import string" type "string.", hit the
 completion key (twice), and see the list of names defined by the
 string module!
 
 Tip: to use the tab key as the completion key, call
 
     readline.parse_and_bind("tab: complete")
 
 Notes:
 
 - Exceptions raised by the completer function are *ignored* (and
   generally cause the completion to fail).  This is a feature -- since
   readline sets the tty device in raw (or cbreak) mode, printing a
   traceback wouldn't work well without some complicated hoopla to save,
   reset and restore the tty state.
 
 - The evaluation of the NAME.NAME... form may cause arbitrary
   application defined code to be executed if an object with a
   ``__getattr__`` hook is found.  Since it is the responsibility of the
   application (or the user) to enable this feature, I consider this an
   acceptable risk.  More complicated expressions (e.g. function calls or
   indexing operations) are *not* evaluated.
 
 - GNU readline is also used by the built-in functions input() and
   raw_input(), and thus these also benefit/suffer from the completer
   features.  Clearly an interactive application can benefit by
   specifying its own completer function and using raw_input() for all
   its input.
 
 - When the original stdin is not a tty device, GNU readline is never
   used, and this module (and the readline module) are silently inactive.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 #
 # Some of this code originated from rlcompleter in the Python standard library
 # Copyright (C) 2001 Python Software Foundation, www.python.org
 
 import __main__
 import glob
 import inspect
 import itertools
 import keyword
 import os
 import re
 import sys
 import unicodedata
 import string
 
 from traitlets.config.configurable import Configurable 
 from IPython.core.error import TryNext
 from IPython.core.inputsplitter import ESC_MAGIC
 from IPython.core.latex_symbols import latex_symbols, reverse_latex_symbol
 from IPython.utils import generics
 from IPython.utils import io
 from IPython.utils.decorators import undoc
 from IPython.utils.dir2 import dir2
 from IPython.utils.process import arg_split
 from IPython.utils.py3compat import builtin_mod, string_types, PY3
 from traitlets import CBool, Enum
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 # Public API
 __all__ = ['Completer','IPCompleter']
 
 if sys.platform == 'win32':
     PROTECTABLES = ' '
 else:
     PROTECTABLES = ' ()[]{}?=\\|;:\'#*"^&'
 
 
 #-----------------------------------------------------------------------------
 # Main functions and classes
 #-----------------------------------------------------------------------------
 
 def has_open_quotes(s):
     """Return whether a string has open quotes.
 
     This simply counts whether the number of quote characters of either type in
     the string is odd.
 
     Returns
     -------
     If there is an open quote, the quote character is returned.  Else, return
     False.
     """
     # We check " first, then ', so complex cases with nested quotes will get
     # the " to take precedence.
     if s.count('"') % 2:
         return '"'
     elif s.count("'") % 2:
         return "'"
     else:
         return False
 
 
 def protect_filename(s):
     """Escape a string to protect certain characters."""
 
     return "".join([(ch in PROTECTABLES and '\\' + ch or ch)
                     for ch in s])
 
 def expand_user(path):
     """Expand '~'-style usernames in strings.
 
     This is similar to :func:`os.path.expanduser`, but it computes and returns
     extra information that will be useful if the input was being used in
     computing completions, and you wish to return the completions with the
     original '~' instead of its expanded value.
 
     Parameters
     ----------
     path : str
       String to be expanded.  If no ~ is present, the output is the same as the
       input.
 
     Returns
     -------
     newpath : str
       Result of ~ expansion in the input path.
     tilde_expand : bool
       Whether any expansion was performed or not.
     tilde_val : str
       The value that ~ was replaced with.
     """
     # Default values
     tilde_expand = False
     tilde_val = ''
     newpath = path
 
     if path.startswith('~'):
         tilde_expand = True
         rest = len(path)-1
         newpath = os.path.expanduser(path)
         if rest:
             tilde_val = newpath[:-rest]
         else:
             tilde_val = newpath
 
     return newpath, tilde_expand, tilde_val
 
 
 def compress_user(path, tilde_expand, tilde_val):
     """Does the opposite of expand_user, with its outputs.
     """
     if tilde_expand:
         return path.replace(tilde_val, '~')
     else:
         return path
 
 
 
 def penalize_magics_key(word):
     """key for sorting that penalizes magic commands in the ordering
 
     Normal words are left alone.
 
     Magic commands have the initial % moved to the end, e.g.
     %matplotlib is transformed as follows:
 
     %matplotlib -> matplotlib%
 
     [The choice of the final % is arbitrary.]
 
     Since "matplotlib" < "matplotlib%" as strings, 
     "timeit" will appear before the magic "%timeit" in the ordering
 
     For consistency, move "%%" to the end, so cell magics appear *after*
     line magics with the same name.
 
     A check is performed that there are no other "%" in the string; 
     if there are, then the string is not a magic command and is left unchanged.
 
     """
 
     # Move any % signs from start to end of the key 
     # provided there are no others elsewhere in the string
 
     if word[:2] == "%%":
         if not "%" in word[2:]:
             return word[2:] + "%%" 
 
     if word[:1] == "%":
         if not "%" in word[1:]:
             return word[1:] + "%"
     
     return word
 
 
 @undoc
 class Bunch(object): pass
 
 
 DELIMS = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
 GREEDY_DELIMS = ' =\r\n'
 
 
 class CompletionSplitter(object):
     """An object to split an input line in a manner similar to readline.
 
     By having our own implementation, we can expose readline-like completion in
     a uniform manner to all frontends.  This object only needs to be given the
     line of text to be split and the cursor position on said line, and it
     returns the 'word' to be completed on at the cursor after splitting the
     entire line.
 
     What characters are used as splitting delimiters can be controlled by
     setting the `delims` attribute (this is a property that internally
     automatically builds the necessary regular expression)"""
 
     # Private interface
 
     # A string of delimiter characters.  The default value makes sense for
     # IPython's most typical usage patterns.
     _delims = DELIMS
 
     # The expression (a normal string) to be compiled into a regular expression
     # for actual splitting.  We store it as an attribute mostly for ease of
     # debugging, since this type of code can be so tricky to debug.
     _delim_expr = None
 
     # The regular expression that does the actual splitting
     _delim_re = None
 
     def __init__(self, delims=None):
         delims = CompletionSplitter._delims if delims is None else delims
         self.delims = delims
 
     @property
     def delims(self):
         """Return the string of delimiter characters."""
         return self._delims
 
     @delims.setter
     def delims(self, delims):
         """Set the delimiters for line splitting."""
         expr = '[' + ''.join('\\'+ c for c in delims) + ']'
         self._delim_re = re.compile(expr)
         self._delims = delims
         self._delim_expr = expr
 
     def split_line(self, line, cursor_pos=None):
         """Split a line of text with a cursor at the given position.
         """
         l = line if cursor_pos is None else line[:cursor_pos]
         return self._delim_re.split(l)[-1]
 
 
 class Completer(Configurable):
 
     greedy = CBool(False, config=True,
         help="""Activate greedy completion
 
         This will enable completion on elements of lists, results of function calls, etc.,
         but can be unsafe because the code is actually evaluated on TAB.
         """
     )
     
 
     def __init__(self, namespace=None, global_namespace=None, **kwargs):
         """Create a new completer for the command line.
 
         Completer(namespace=ns,global_namespace=ns2) -> completer instance.
 
         If unspecified, the default namespace where completions are performed
         is __main__ (technically, __main__.__dict__). Namespaces should be
         given as dictionaries.
 
         An optional second namespace can be given.  This allows the completer
         to handle cases where both the local and global scopes need to be
         distinguished.
 
         Completer instances should be used as the completion mechanism of
         readline via the set_completer() call:
 
         readline.set_completer(Completer(my_namespace).complete)
         """
 
         # Don't bind to namespace quite yet, but flag whether the user wants a
         # specific namespace or to use __main__.__dict__. This will allow us
         # to bind to __main__.__dict__ at completion time, not now.
         if namespace is None:
             self.use_main_ns = 1
         else:
             self.use_main_ns = 0
             self.namespace = namespace
 
         # The global namespace, if given, can be bound directly
         if global_namespace is None:
             self.global_namespace = {}
         else:
             self.global_namespace = global_namespace
 
         super(Completer, self).__init__(**kwargs)
 
     def complete(self, text, state):
         """Return the next possible completion for 'text'.
 
         This is called successively with state == 0, 1, 2, ... until it
         returns None.  The completion should begin with 'text'.
 
         """
         if self.use_main_ns:
             self.namespace = __main__.__dict__
 
         if state == 0:
             if "." in text:
                 self.matches = self.attr_matches(text)
             else:
                 self.matches = self.global_matches(text)
         try:
             return self.matches[state]
         except IndexError:
             return None
 
     def global_matches(self, text):
         """Compute matches when text is a simple name.
 
         Return a list of all keywords, built-in functions and names currently
         defined in self.namespace or self.global_namespace that match.
 
         """
         #print 'Completer->global_matches, txt=%r' % text # dbg
         matches = []
         match_append = matches.append
         n = len(text)
         for lst in [keyword.kwlist,
                     builtin_mod.__dict__.keys(),
                     self.namespace.keys(),
                     self.global_namespace.keys()]:
             for word in lst:
                 if word[:n] == text and word != "__builtins__":
                     match_append(word)
         return matches
 
     def attr_matches(self, text):
         """Compute matches when text contains a dot.
 
         Assuming the text is of the form NAME.NAME....[NAME], and is
         evaluatable in self.namespace or self.global_namespace, it will be
         evaluated and its attributes (as revealed by dir()) are used as
         possible completions.  (For class instances, class members are are
         also considered.)
 
         WARNING: this can still invoke arbitrary C code, if an object
         with a __getattr__ hook is evaluated.
 
         """
 
         #io.rprint('Completer->attr_matches, txt=%r' % text) # dbg
         # Another option, seems to work great. Catches things like ''.<tab>
         m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
     
         if m:
             expr, attr = m.group(1, 3)
         elif self.greedy:
             m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer)
             if not m2:
                 return []
             expr, attr = m2.group(1,2)
         else:
             return []
     
         try:
             obj = eval(expr, self.namespace)
         except:
             try:
                 obj = eval(expr, self.global_namespace)
             except:
                 return []
 
         if self.limit_to__all__ and hasattr(obj, '__all__'):
             words = get__all__entries(obj)
         else: 
             words = dir2(obj)
 
         try:
             words = generics.complete_object(obj, words)
         except TryNext:
             pass
         except Exception:
             # Silence errors from completion function
             #raise # dbg
             pass
         # Build match list to return
         n = len(attr)
         res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
         return res
 
 
 def get__all__entries(obj):
     """returns the strings in the __all__ attribute"""
     try:
         words = getattr(obj, '__all__')
     except:
         return []
     
     return [w for w in words if isinstance(w, string_types)]
 
 
 def match_dict_keys(keys, prefix, delims):
     """Used by dict_key_matches, matching the prefix to a list of keys"""
     if not prefix:
         return None, 0, [repr(k) for k in keys
                       if isinstance(k, (string_types, bytes))]
     quote_match = re.search('["\']', prefix)
     quote = quote_match.group()
     try:
         prefix_str = eval(prefix + quote, {})
     except Exception:
         return None, 0, []
 
     pattern = '[^' + ''.join('\\' + c for c in delims) + ']*$'
     token_match = re.search(pattern, prefix, re.UNICODE)
     token_start = token_match.start()
     token_prefix = token_match.group()
 
     # TODO: support bytes in Py3k
     matched = []
     for key in keys:
         try:
             if not key.startswith(prefix_str):
                 continue
         except (AttributeError, TypeError, UnicodeError):
             # Python 3+ TypeError on b'a'.startswith('a') or vice-versa
             continue
 
         # reformat remainder of key to begin with prefix
         rem = key[len(prefix_str):]
         # force repr wrapped in '
         rem_repr = repr(rem + '"')
         if rem_repr.startswith('u') and prefix[0] not in 'uU':
             # Found key is unicode, but prefix is Py2 string.
             # Therefore attempt to interpret key as string.
             try:
                 rem_repr = repr(rem.encode('ascii') + '"')
             except UnicodeEncodeError:
                 continue
 
         rem_repr = rem_repr[1 + rem_repr.index("'"):-2]
         if quote == '"':
             # The entered prefix is quoted with ",
             # but the match is quoted with '.
             # A contained " hence needs escaping for comparison:
             rem_repr = rem_repr.replace('"', '\\"')
 
         # then reinsert prefix from start of token
         matched.append('%s%s' % (token_prefix, rem_repr))
     return quote, token_start, matched
 
 
 def _safe_isinstance(obj, module, class_name):
     """Checks if obj is an instance of module.class_name if loaded
     """
     return (module in sys.modules and
             isinstance(obj, getattr(__import__(module), class_name)))
 
 
 
 def back_unicode_name_matches(text):
     u"""Match unicode characters back to unicode name
     
     This does  ☃ -> \\snowman
 
     Note that snowman is not a valid python3 combining character but will be expanded.
     Though it will not recombine back to the snowman character by the completion machinery.
 
-    This will not either back-complete standard sequences like \n, \b ...
+    This will not either back-complete standard sequences like \\n, \\b ...
     
     Used on Python 3 only.
     """
     if len(text)<2:
         return u'', ()
     maybe_slash = text[-2]
     if maybe_slash != '\\':
         return u'', ()
 
     char = text[-1]
     # no expand on quote for completion in strings.
     # nor backcomplete standard ascii keys
     if char in string.ascii_letters or char in ['"',"'"]:
         return u'', ()
     try :
         unic = unicodedata.name(char)
         return '\\'+char,['\\'+unic]
     except KeyError as e:
         pass
     return u'', ()
 
 def back_latex_name_matches(text):
     u"""Match latex characters back to unicode name
     
     This does  ->\\sqrt
 
     Used on Python 3 only.
     """
     if len(text)<2:
         return u'', ()
     maybe_slash = text[-2]
     if maybe_slash != '\\':
         return u'', ()
 
 
     char = text[-1]
     # no expand on quote for completion in strings.
     # nor backcomplete standard ascii keys
     if char in string.ascii_letters or char in ['"',"'"]:
         return u'', ()
     try :
         latex = reverse_latex_symbol[char]
         # '\\' replace the \ as well
         return '\\'+char,[latex]
     except KeyError as e:
         pass
     return u'', ()
 
 
 class IPCompleter(Completer):
     """Extension of the completer class with IPython-specific features"""
 
     def _greedy_changed(self, name, old, new):
         """update the splitter and readline delims when greedy is changed"""
         if new:
             self.splitter.delims = GREEDY_DELIMS
         else:
             self.splitter.delims = DELIMS
 
         if self.readline:
             self.readline.set_completer_delims(self.splitter.delims)
     
     merge_completions = CBool(True, config=True,
         help="""Whether to merge completion results into a single list
         
         If False, only the completion results from the first non-empty
         completer will be returned.
         """
     )
     omit__names = Enum((0,1,2), default_value=2, config=True,
         help="""Instruct the completer to omit private method names
         
         Specifically, when completing on ``object.<tab>``.
         
         When 2 [default]: all names that start with '_' will be excluded.
         
         When 1: all 'magic' names (``__foo__``) will be excluded.
         
         When 0: nothing will be excluded.
         """
     )
     limit_to__all__ = CBool(default_value=False, config=True,
         help="""Instruct the completer to use __all__ for the completion
         
         Specifically, when completing on ``object.<tab>``.
         
         When True: only those names in obj.__all__ will be included.
         
         When False [default]: the __all__ attribute is ignored 
         """
     )
 
     def __init__(self, shell=None, namespace=None, global_namespace=None,
                  use_readline=True, config=None, **kwargs):
         """IPCompleter() -> completer
 
         Return a completer object suitable for use by the readline library
         via readline.set_completer().
 
         Inputs:
 
         - shell: a pointer to the ipython shell itself.  This is needed
           because this completer knows about magic functions, and those can
           only be accessed via the ipython instance.
 
         - namespace: an optional dict where completions are performed.
 
         - global_namespace: secondary optional dict for completions, to
           handle cases (such as IPython embedded inside functions) where
           both Python scopes are visible.
 
         use_readline : bool, optional
           If true, use the readline library.  This completer can still function
           without readline, though in that case callers must provide some extra
           information on each call about the current line."""
 
         self.magic_escape = ESC_MAGIC
         self.splitter = CompletionSplitter()
 
         # Readline configuration, only used by the rlcompleter method.
         if use_readline:
             # We store the right version of readline so that later code
             import IPython.utils.rlineimpl as readline
             self.readline = readline
         else:
             self.readline = None
 
         # _greedy_changed() depends on splitter and readline being defined:
         Completer.__init__(self, namespace=namespace, global_namespace=global_namespace,
                             config=config, **kwargs)
 
         # List where completion matches will be stored
         self.matches = []
         self.shell = shell
         # Regexp to split filenames with spaces in them
         self.space_name_re = re.compile(r'([^\\] )')
         # Hold a local ref. to glob.glob for speed
         self.glob = glob.glob
 
         # Determine if we are running on 'dumb' terminals, like (X)Emacs
         # buffers, to avoid completion problems.
         term = os.environ.get('TERM','xterm')
         self.dumb_terminal = term in ['dumb','emacs']
 
         # Special handling of backslashes needed in win32 platforms
         if sys.platform == "win32":
             self.clean_glob = self._clean_glob_win32
         else:
             self.clean_glob = self._clean_glob
 
         #regexp to parse docstring for function signature
         self.docstring_sig_re = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
         self.docstring_kwd_re = re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
         #use this if positional argument name is also needed
         #= re.compile(r'[\s|\[]*(\w+)(?:\s*=?\s*.*)')
 
         # All active matcher routines for completion
         self.matchers = [self.python_matches,
                          self.file_matches,
                          self.magic_matches,
                          self.python_func_kw_matches,
                          self.dict_key_matches,
                          ]
 
     def all_completions(self, text):
         """
         Wrapper around the complete method for the benefit of emacs
         and pydb.
         """
         return self.complete(text)[1]
 
     def _clean_glob(self,text):
         return self.glob("%s*" % text)
 
     def _clean_glob_win32(self,text):
         return [f.replace("\\","/")
                 for f in self.glob("%s*" % text)]
 
     def file_matches(self, text):
         """Match filenames, expanding ~USER type strings.
 
         Most of the seemingly convoluted logic in this completer is an
         attempt to handle filenames with spaces in them.  And yet it's not
         quite perfect, because Python's readline doesn't expose all of the
         GNU readline details needed for this to be done correctly.
 
         For a filename with a space in it, the printed completions will be
         only the parts after what's already been typed (instead of the
         full completions, as is normally done).  I don't think with the
         current (as of Python 2.3) Python readline it's possible to do
         better."""
 
         #io.rprint('Completer->file_matches: <%r>' % text) # dbg
 
         # chars that require escaping with backslash - i.e. chars
         # that readline treats incorrectly as delimiters, but we
         # don't want to treat as delimiters in filename matching
         # when escaped with backslash
         if text.startswith('!'):
             text = text[1:]
             text_prefix = '!'
         else:
             text_prefix = ''
 
         text_until_cursor = self.text_until_cursor
         # track strings with open quotes
         open_quotes = has_open_quotes(text_until_cursor)
 
         if '(' in text_until_cursor or '[' in text_until_cursor:
             lsplit = text
         else:
             try:
                 # arg_split ~ shlex.split, but with unicode bugs fixed by us
                 lsplit = arg_split(text_until_cursor)[-1]
             except ValueError:
                 # typically an unmatched ", or backslash without escaped char.
                 if open_quotes:
                     lsplit = text_until_cursor.split(open_quotes)[-1]
                 else:
                     return []
             except IndexError:
                 # tab pressed on empty line
                 lsplit = ""
 
         if not open_quotes and lsplit != protect_filename(lsplit):
             # if protectables are found, do matching on the whole escaped name
             has_protectables = True
             text0,text = text,lsplit
         else:
             has_protectables = False
             text = os.path.expanduser(text)
 
         if text == "":
             return [text_prefix + protect_filename(f) for f in self.glob("*")]
 
         # Compute the matches from the filesystem
         m0 = self.clean_glob(text.replace('\\',''))
 
         if has_protectables:
             # If we had protectables, we need to revert our changes to the
             # beginning of filename so that we don't double-write the part
             # of the filename we have so far
             len_lsplit = len(lsplit)
             matches = [text_prefix + text0 +
                        protect_filename(f[len_lsplit:]) for f in m0]
         else:
             if open_quotes:
                 # if we have a string with an open quote, we don't need to
                 # protect the names at all (and we _shouldn't_, as it
                 # would cause bugs when the filesystem call is made).
                 matches = m0
             else:
                 matches = [text_prefix +
                            protect_filename(f) for f in m0]
 
         #io.rprint('mm', matches)  # dbg
 
         # Mark directories in input list by appending '/' to their names.
         matches = [x+'/' if os.path.isdir(x) else x for x in matches]
         return matches
 
     def magic_matches(self, text):
         """Match magics"""
         #print 'Completer->magic_matches:',text,'lb',self.text_until_cursor # dbg
         # Get all shell magics now rather than statically, so magics loaded at
         # runtime show up too.
         lsm = self.shell.magics_manager.lsmagic()
         line_magics = lsm['line']
         cell_magics = lsm['cell']
         pre = self.magic_escape
         pre2 = pre+pre
         
         # Completion logic:
         # - user gives %%: only do cell magics
         # - user gives %: do both line and cell magics
         # - no prefix: do both
         # In other words, line magics are skipped if the user gives %% explicitly
         bare_text = text.lstrip(pre)
         comp = [ pre2+m for m in cell_magics if m.startswith(bare_text)]
         if not text.startswith(pre2):
             comp += [ pre+m for m in line_magics if m.startswith(bare_text)]
         return comp
 
     def python_matches(self,text):
         """Match attributes or global python names"""
         
         #io.rprint('Completer->python_matches, txt=%r' % text) # dbg
         if "." in text:
             try:
                 matches = self.attr_matches(text)
                 if text.endswith('.') and self.omit__names:
                     if self.omit__names == 1:
                         # true if txt is _not_ a __ name, false otherwise:
                         no__name = (lambda txt:
                                     re.match(r'.*\.__.*?__',txt) is None)
                     else:
                         # true if txt is _not_ a _ name, false otherwise:
                         no__name = (lambda txt:
                                     re.match(r'\._.*?',txt[txt.rindex('.'):]) is None)
                     matches = filter(no__name, matches)
             except NameError:
                 # catches <undefined attributes>.<tab>
                 matches = []
         else:
             matches = self.global_matches(text)
 
         return matches
 
     def _default_arguments_from_docstring(self, doc):
         """Parse the first line of docstring for call signature.
 
         Docstring should be of the form 'min(iterable[, key=func])\n'.
         It can also parse cython docstring of the form
         'Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)'.
         """
         if doc is None:
             return []
 
         #care only the firstline
         line = doc.lstrip().splitlines()[0]
 
         #p = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
         #'min(iterable[, key=func])\n' -> 'iterable[, key=func]'
         sig = self.docstring_sig_re.search(line)
         if sig is None:
             return []
         # iterable[, key=func]' -> ['iterable[' ,' key=func]']
         sig = sig.groups()[0].split(',')
         ret = []
         for s in sig:
             #re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
             ret += self.docstring_kwd_re.findall(s)
         return ret
 
     def _default_arguments(self, obj):
         """Return the list of default arguments of obj if it is callable,
         or empty list otherwise."""
         call_obj = obj
         ret = []
         if inspect.isbuiltin(obj):
             pass
         elif not (inspect.isfunction(obj) or inspect.ismethod(obj)):
             if inspect.isclass(obj):
                 #for cython embededsignature=True the constructor docstring
                 #belongs to the object itself not __init__
                 ret += self._default_arguments_from_docstring(
                             getattr(obj, '__doc__', ''))
                 # for classes, check for __init__,__new__
                 call_obj = (getattr(obj, '__init__', None) or
                        getattr(obj, '__new__', None))
             # for all others, check if they are __call__able
             elif hasattr(obj, '__call__'):
                 call_obj = obj.__call__
 
         ret += self._default_arguments_from_docstring(
                  getattr(call_obj, '__doc__', ''))
 
         try:
             args,_,_1,defaults = inspect.getargspec(call_obj)
             if defaults:
                 ret+=args[-len(defaults):]
         except TypeError:
             pass
 
         return list(set(ret))
 
     def python_func_kw_matches(self,text):
         """Match named parameters (kwargs) of the last open function"""
         
         if "." in text: # a parameter cannot be dotted
             return []
         try: regexp = self.__funcParamsRegex
         except AttributeError:
             regexp = self.__funcParamsRegex = re.compile(r'''
                 '.*?(?<!\\)' |    # single quoted strings or
                 ".*?(?<!\\)" |    # double quoted strings or
                 \w+          |    # identifier
                 \S                # other characters
                 ''', re.VERBOSE | re.DOTALL)
         # 1. find the nearest identifier that comes before an unclosed
         # parenthesis before the cursor
         # e.g. for "foo (1+bar(x), pa<cursor>,a=1)", the candidate is "foo"
         tokens = regexp.findall(self.text_until_cursor)
         tokens.reverse()
         iterTokens = iter(tokens); openPar = 0
 
         for token in iterTokens:
             if token == ')':
                 openPar -= 1
             elif token == '(':
                 openPar += 1
                 if openPar > 0:
                     # found the last unclosed parenthesis
                     break
         else:
             return []
         # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
         ids = []
         isId = re.compile(r'\w+$').match
 
         while True:
             try:
                 ids.append(next(iterTokens))
                 if not isId(ids[-1]):
                     ids.pop(); break
                 if not next(iterTokens) == '.':
                     break
             except StopIteration:
                 break
         # lookup the candidate callable matches either using global_matches
         # or attr_matches for dotted names
         if len(ids) == 1:
             callableMatches = self.global_matches(ids[0])
         else:
             callableMatches = self.attr_matches('.'.join(ids[::-1]))
         argMatches = []
         for callableMatch in callableMatches:
             try:
                 namedArgs = self._default_arguments(eval(callableMatch,
                                                         self.namespace))
             except:
                 continue
 
             for namedArg in namedArgs:
                 if namedArg.startswith(text):
                     argMatches.append("%s=" %namedArg)
         return argMatches
 
     def dict_key_matches(self, text):
         "Match string keys in a dictionary, after e.g. 'foo[' "
         def get_keys(obj):
             # Only allow completion for known in-memory dict-like types
             if isinstance(obj, dict) or\
                _safe_isinstance(obj, 'pandas', 'DataFrame'):
                 try:
                     return list(obj.keys())
                 except Exception:
                     return []
             elif _safe_isinstance(obj, 'numpy', 'ndarray') or\
                  _safe_isinstance(obj, 'numpy', 'void'):
                 return obj.dtype.names or []
             return []
 
         try:
             regexps = self.__dict_key_regexps
         except AttributeError:
             dict_key_re_fmt = r'''(?x)
             (  # match dict-referring expression wrt greedy setting
                 %s
             )
             \[   # open bracket
             \s*  # and optional whitespace
             ([uUbB]?  # string prefix (r not handled)
                 (?:   # unclosed string
                     '(?:[^']|(?<!\\)\\')*
                 |
                     "(?:[^"]|(?<!\\)\\")*
                 )
             )?
             $
             '''
             regexps = self.__dict_key_regexps = {
                 False: re.compile(dict_key_re_fmt % '''
                                   # identifiers separated by .
                                   (?!\d)\w+
                                   (?:\.(?!\d)\w+)*
                                   '''),
                 True: re.compile(dict_key_re_fmt % '''
                                  .+
                                  ''')
             }
 
         match = regexps[self.greedy].search(self.text_until_cursor)
         if match is None:
             return []
 
         expr, prefix = match.groups()
         try:
             obj = eval(expr, self.namespace)
         except Exception:
             try:
                 obj = eval(expr, self.global_namespace)
             except Exception:
                 return []
 
         keys = get_keys(obj)
         if not keys:
             return keys
         closing_quote, token_offset, matches = match_dict_keys(keys, prefix, self.splitter.delims)
         if not matches:
             return matches
         
         # get the cursor position of
         # - the text being completed
         # - the start of the key text
         # - the start of the completion
         text_start = len(self.text_until_cursor) - len(text)
         if prefix:
             key_start = match.start(2)
             completion_start = key_start + token_offset
         else:
             key_start = completion_start = match.end()
         
         # grab the leading prefix, to make sure all completions start with `text`
         if text_start > key_start:
             leading = ''
         else:
             leading = text[text_start:completion_start]
         
         # the index of the `[` character
         bracket_idx = match.end(1)
 
         # append closing quote and bracket as appropriate
         # this is *not* appropriate if the opening quote or bracket is outside
         # the text given to this method
         suf = ''
         continuation = self.line_buffer[len(self.text_until_cursor):]
         if key_start > text_start and closing_quote:
             # quotes were opened inside text, maybe close them
             if continuation.startswith(closing_quote):
                 continuation = continuation[len(closing_quote):]
             else:
                 suf += closing_quote
         if bracket_idx > text_start:
             # brackets were opened inside text, maybe close them
             if not continuation.startswith(']'):
                 suf += ']'
         
         return [leading + k + suf for k in matches]
 
     def unicode_name_matches(self, text):
         u"""Match Latex-like syntax for unicode characters base 
         on the name of the character.
         
         This does  \\GREEK SMALL LETTER ETA -> η
 
         Works only on valid python 3 identifier, or on combining characters that 
         will combine to form a valid identifier.
         
         Used on Python 3 only.
         """
         slashpos = text.rfind('\\')
         if slashpos > -1:
             s = text[slashpos+1:]
             try :
                 unic = unicodedata.lookup(s)
                 # allow combining chars
                 if ('a'+unic).isidentifier():
                     return '\\'+s,[unic]
             except KeyError as e:
                 pass
         return u'', []
 
 
 
 
     def latex_matches(self, text):
         u"""Match Latex syntax for unicode characters.
         
         This does both \\alp -> \\alpha and \\alpha -> α
         
         Used on Python 3 only.
         """
         slashpos = text.rfind('\\')
         if slashpos > -1:
             s = text[slashpos:]
             if s in latex_symbols:
                 # Try to complete a full latex symbol to unicode
                 # \\alpha -> α
                 return s, [latex_symbols[s]]
             else:
                 # If a user has partially typed a latex symbol, give them
                 # a full list of options \al -> [\aleph, \alpha]
                 matches = [k for k in latex_symbols if k.startswith(s)]
                 return s, matches
         return u'', []
 
     def dispatch_custom_completer(self, text):
         #io.rprint("Custom! '%s' %s" % (text, self.custom_completers)) # dbg
         line = self.line_buffer
         if not line.strip():
             return None
 
         # Create a little structure to pass all the relevant information about
         # the current completion to any custom completer.
         event = Bunch()
         event.line = line
         event.symbol = text
         cmd = line.split(None,1)[0]
         event.command = cmd
         event.text_until_cursor = self.text_until_cursor
 
         #print "\ncustom:{%s]\n" % event # dbg
 
         # for foo etc, try also to find completer for %foo
         if not cmd.startswith(self.magic_escape):
             try_magic = self.custom_completers.s_matches(
                 self.magic_escape + cmd)
         else:
             try_magic = []
 
         for c in itertools.chain(self.custom_completers.s_matches(cmd),
                  try_magic,
                  self.custom_completers.flat_matches(self.text_until_cursor)):
             #print "try",c # dbg
             try:
                 res = c(event)
                 if res:
                     # first, try case sensitive match
                     withcase = [r for r in res if r.startswith(text)]
                     if withcase:
                         return withcase
                     # if none, then case insensitive ones are ok too
                     text_low = text.lower()
                     return [r for r in res if r.lower().startswith(text_low)]
             except TryNext:
                 pass
 
         return None
 
     def complete(self, text=None, line_buffer=None, cursor_pos=None):
         """Find completions for the given text and line context.
 
         Note that both the text and the line_buffer are optional, but at least
         one of them must be given.
 
         Parameters
         ----------
           text : string, optional
             Text to perform the completion on.  If not given, the line buffer
             is split using the instance's CompletionSplitter object.
 
           line_buffer : string, optional
             If not given, the completer attempts to obtain the current line
             buffer via readline.  This keyword allows clients which are
             requesting for text completions in non-readline contexts to inform
             the completer of the entire text.
 
           cursor_pos : int, optional
             Index of the cursor in the full line buffer.  Should be provided by
             remote frontends where kernel has no access to frontend state.
 
         Returns
         -------
         text : str
           Text that was actually used in the completion.
 
         matches : list
           A list of completion matches.
         """
         # io.rprint('\nCOMP1 %r %r %r' % (text, line_buffer, cursor_pos))  # dbg
 
         # if the cursor position isn't given, the only sane assumption we can
         # make is that it's at the end of the line (the common case)
         if cursor_pos is None:
             cursor_pos = len(line_buffer) if text is None else len(text)
 
         if PY3:
 
             base_text = text if not line_buffer else line_buffer[:cursor_pos]
             latex_text, latex_matches = self.latex_matches(base_text)
             if latex_matches:
                  return latex_text, latex_matches
             name_text = ''
             name_matches = []
             for meth in (self.unicode_name_matches, back_latex_name_matches, back_unicode_name_matches):
                 name_text, name_matches = meth(base_text)
                 if name_text:
                     return name_text, name_matches
         
         # if text is either None or an empty string, rely on the line buffer
         if not text:
             text = self.splitter.split_line(line_buffer, cursor_pos)
 
         # If no line buffer is given, assume the input text is all there was
         if line_buffer is None:
             line_buffer = text
 
         self.line_buffer = line_buffer
         self.text_until_cursor = self.line_buffer[:cursor_pos]
         # io.rprint('COMP2 %r %r %r' % (text, line_buffer, cursor_pos))  # dbg
 
         # Start with a clean slate of completions
         self.matches[:] = []
         custom_res = self.dispatch_custom_completer(text)
         if custom_res is not None:
             # did custom completers produce something?
             self.matches = custom_res
         else:
             # Extend the list of completions with the results of each
             # matcher, so we return results to the user from all
             # namespaces.
             if self.merge_completions:
                 self.matches = []
                 for matcher in self.matchers:
                     try:
                         self.matches.extend(matcher(text))
                     except:
                         # Show the ugly traceback if the matcher causes an
                         # exception, but do NOT crash the kernel!
                         sys.excepthook(*sys.exc_info())
             else:
                 for matcher in self.matchers:
                     self.matches = matcher(text)
                     if self.matches:
                         break
         # FIXME: we should extend our api to return a dict with completions for
         # different types of objects.  The rlcomplete() method could then
         # simply collapse the dict into a list for readline, but we'd have
         # richer completion semantics in other evironments.
 
         # use penalize_magics_key to put magics after variables with same name
         self.matches = sorted(set(self.matches), key=penalize_magics_key)
 
         #io.rprint('COMP TEXT, MATCHES: %r, %r' % (text, self.matches)) # dbg
         return text, self.matches
 
     def rlcomplete(self, text, state):
         """Return the state-th possible completion for 'text'.
 
         This is called successively with state == 0, 1, 2, ... until it
         returns None.  The completion should begin with 'text'.
 
         Parameters
         ----------
           text : string
             Text to perform the completion on.
 
           state : int
             Counter used by readline.
         """
         if state==0:
 
             self.line_buffer = line_buffer = self.readline.get_line_buffer()
             cursor_pos = self.readline.get_endidx()
 
             #io.rprint("\nRLCOMPLETE: %r %r %r" %
             #          (text, line_buffer, cursor_pos) ) # dbg
 
             # if there is only a tab on a line with only whitespace, instead of
             # the mostly useless 'do you want to see all million completions'
             # message, just do the right thing and give the user his tab!
             # Incidentally, this enables pasting of tabbed text from an editor
             # (as long as autoindent is off).
 
             # It should be noted that at least pyreadline still shows file
             # completions - is there a way around it?
 
             # don't apply this on 'dumb' terminals, such as emacs buffers, so
             # we don't interfere with their own tab-completion mechanism.
             if not (self.dumb_terminal or line_buffer.strip()):
                 self.readline.insert_text('\t')
                 sys.stdout.flush()
                 return None
 
             # Note: debugging exceptions that may occur in completion is very
             # tricky, because readline unconditionally silences them.  So if
             # during development you suspect a bug in the completion code, turn
             # this flag on temporarily by uncommenting the second form (don't
             # flip the value in the first line, as the '# dbg' marker can be
             # automatically detected and is used elsewhere).
             DEBUG = False
             #DEBUG = True # dbg
             if DEBUG:
                 try:
                     self.complete(text, line_buffer, cursor_pos)
                 except:
                     import traceback; traceback.print_exc()
             else:
                 # The normal production version is here
 
                 # This method computes the self.matches array
                 self.complete(text, line_buffer, cursor_pos)
 
         try:
             return self.matches[state]
         except IndexError:
             return None
 

IPython/core/magics/pylab.py

@@ -1,167 +1,167 b''
 """Implementation of magic functions for matplotlib/pylab support.
 """
 from __future__ import print_function
 #-----------------------------------------------------------------------------
 #  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
 #-----------------------------------------------------------------------------
 
 # Our own packages
 from traitlets.config.application import Application
 from IPython.core import magic_arguments
 from IPython.core.magic import Magics, magics_class, line_magic
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils.warn import warn
 from IPython.core.pylabtools import backends
 
 #-----------------------------------------------------------------------------
 # Magic implementation classes
 #-----------------------------------------------------------------------------
 
 magic_gui_arg = magic_arguments.argument(
         'gui', nargs='?',
         help="""Name of the matplotlib backend to use %s.
         If given, the corresponding matplotlib backend is used,
         otherwise it will be matplotlib's default
         (which you can set in your matplotlib config file).
         """ % str(tuple(sorted(backends.keys())))
 )
 
 
 @magics_class
 class PylabMagics(Magics):
     """Magics related to matplotlib's pylab support"""
     
     @skip_doctest
     @line_magic
     @magic_arguments.magic_arguments()
     @magic_arguments.argument('-l', '--list', action='store_true',
                               help='Show available matplotlib backends')
     @magic_gui_arg
     def matplotlib(self, line=''):
         """Set up matplotlib to work interactively.
         
         This function lets you activate matplotlib interactive support
         at any point during an IPython session. It does not import anything
         into the interactive namespace.
         
         If you are using the inline matplotlib backend in the IPython Notebook
         you can set which figure formats are enabled using the following::
         
             In [1]: from IPython.display import set_matplotlib_formats
             
             In [2]: set_matplotlib_formats('pdf', 'svg')
 
         The default for inline figures sets `bbox_inches` to 'tight'. This can
         cause discrepancies between the displayed image and the identical
         image created using `savefig`. This behavior can be disabled using the
         `%config` magic::
             
             In [3]: %config InlineBackend.print_figure_kwargs = {'bbox_inches':None}
 
         In addition, see the docstring of
         `IPython.display.set_matplotlib_formats` and
         `IPython.display.set_matplotlib_close` for more information on
         changing additional behaviors of the inline backend.
 
         Examples
         --------
         To enable the inline backend for usage with the IPython Notebook::
         
             In [1]: %matplotlib inline
 
         In this case, where the matplotlib default is TkAgg::
 
             In [2]: %matplotlib
             Using matplotlib backend: TkAgg
 
         But you can explicitly request a different GUI backend::
 
             In [3]: %matplotlib qt
 
-        You can list the available backends using the -l/--list option
+        You can list the available backends using the -l/--list option::
 
            In [4]: %matplotlib --list
            Available matplotlib backends: ['osx', 'qt4', 'qt5', 'gtk3', 'notebook', 'wx', 'qt', 'nbagg',
-            'gtk', 'tk', 'inline']
+           'gtk', 'tk', 'inline']
         """
         args = magic_arguments.parse_argstring(self.matplotlib, line)
         if args.list:
             backends_list = list(backends.keys())
             print("Available matplotlib backends: %s" % backends_list)
         else:
             gui, backend = self.shell.enable_matplotlib(args.gui)
             self._show_matplotlib_backend(args.gui, backend)
 
     @skip_doctest
     @line_magic
     @magic_arguments.magic_arguments()
     @magic_arguments.argument(
         '--no-import-all', action='store_true', default=None,
         help="""Prevent IPython from performing ``import *`` into the interactive namespace.
         
         You can govern the default behavior of this flag with the
         InteractiveShellApp.pylab_import_all configurable.
         """
     )
     @magic_gui_arg
     def pylab(self, line=''):
         """Load numpy and matplotlib to work interactively.
 
         This function lets you activate pylab (matplotlib, numpy and
         interactive support) at any point during an IPython session.
         
         %pylab makes the following imports::
         
             import numpy
             import matplotlib
             from matplotlib import pylab, mlab, pyplot
             np = numpy
             plt = pyplot
             
             from IPython.display import display
             from IPython.core.pylabtools import figsize, getfigs
             
             from pylab import *
             from numpy import *
 
         If you pass `--no-import-all`, the last two `*` imports will be excluded.
         
         See the %matplotlib magic for more details about activating matplotlib
         without affecting the interactive namespace.
         """
         args = magic_arguments.parse_argstring(self.pylab, line)
         if args.no_import_all is None:
             # get default from Application
             if Application.initialized():
                 app = Application.instance()
                 try:
                     import_all = app.pylab_import_all
                 except AttributeError:
                     import_all = True
             else:
                 # nothing specified, no app - default True
                 import_all = True
         else:
             # invert no-import flag
             import_all = not args.no_import_all
 
         gui, backend, clobbered = self.shell.enable_pylab(args.gui, import_all=import_all)
         self._show_matplotlib_backend(args.gui, backend)
         print ("Populating the interactive namespace from numpy and matplotlib")
         if clobbered:
             warn("pylab import has clobbered these variables: %s"  % clobbered +
             "\n`%matplotlib` prevents importing * from pylab and numpy"
             )
     
     def _show_matplotlib_backend(self, gui, backend):
         """show matplotlib message backend message"""
         if not gui or gui == 'auto':
             print("Using matplotlib backend: %s" % backend)

docs/source/interactive/tutorial.rst

@@ -1,203 +1,205 b''
 .. _tutorial:
 
 ======================
 Introducing IPython
 ======================
 
 You don't need to know anything beyond Python to start using IPython – just type
 commands as you would at the standard Python prompt. But IPython can do much
 more than the standard prompt. Some key features are described here. For more
 information, check the :ref:`tips page <tips>`, or look at examples in the
 `IPython cookbook <https://github.com/ipython/ipython/wiki/Cookbook%3A-Index>`_.
 
 If you've never used Python before, you might want to look at `the official
 tutorial <http://docs.python.org/tutorial/>`_ or an alternative, `Dive into
 Python <http://diveintopython.net/toc/index.html>`_.
 
 The four most helpful commands 
 ===============================
 
 The four most helpful commands, as well as their brief description, is shown
 to you in a banner, every time you start IPython:
 
 ==========    =========================================================
 command       description
 ==========    =========================================================
 ?             Introduction and overview of IPython's features.
 %quickref     Quick reference.
 help          Python's own help system.
 object?       Details about 'object', use 'object??' for extra details.
 ==========    =========================================================
 
 Tab completion
 ==============
 
 Tab completion, especially for attributes, is a convenient way to explore the
 structure of any object you're dealing with. Simply type ``object_name.<TAB>``
 to view the object's attributes (see :ref:`the readline section <readline>` for
 more). Besides Python objects and keywords, tab completion also works on file
 and directory names.
 
 Exploring your objects
 ======================
 
 Typing ``object_name?`` will print all sorts of details about any object,
 including docstrings, function definition lines (for call arguments) and
 constructor details for classes. To get specific information on an object, you
 can use the magic commands ``%pdoc``, ``%pdef``, ``%psource`` and ``%pfile``
 
 .. _magics_explained:
 
 Magic functions
 ===============
 
 IPython has a set of predefined 'magic functions' that you can call with a
 command line style syntax.  There are two kinds of magics, line-oriented and
 cell-oriented.  **Line magics** are prefixed with the ``%`` character and work much
 like OS command-line calls: they get as an argument the rest of the line, where
 arguments are passed without parentheses or quotes.  **Cell magics** are
 prefixed with a double ``%%``, and they are functions that get as an argument
 not only the rest of the line, but also the lines below it in a separate
 argument.
 
 The following examples show how to call the builtin :magic:`timeit` magic, both in
 line and cell mode::
 
       In [1]: %timeit range(1000)
       100000 loops, best of 3: 7.76 us per loop
 
       In [2]: %%timeit x = range(10000)
 	 ...: max(x)
 	 ...: 
       1000 loops, best of 3: 223 us per loop
 
 The builtin magics include:
 
 - Functions that work with code: :magic:`run`, :magic:`edit`, :magic:`save`, :magic:`macro`,
   :magic:`recall`, etc.
 - Functions which affect the shell: :magic:`colors`, :magic:`xmode`, :magic:`autoindent`,
   :magic:`automagic`, etc.
 - Other functions such as :magic:`reset`, :magic:`timeit`, :cellmagic:`writefile`, :magic:`load`, or
   :magic:`paste`.
 
 You can always call them using the ``%`` prefix, and if you're calling a line
 magic on a line by itself, you can omit even that::
 
     run thescript.py
 
 You can toggle this behavior by running the :magic:`automagic` magic.  Cell magics
 must always have the ``%%`` prefix.
 
 A more detailed explanation of the magic system can be obtained by calling
 ``%magic``, and for more details on any magic function, call ``%somemagic?`` to
 read its docstring. To see all the available magic functions, call
 ``%lsmagic``.
 
 .. seealso::
 
     :doc:`magics`
 
     `Cell magics`_ example notebook
 
 Running and Editing
 -------------------
 
 The :magic:`run` magic command allows you to run any python script and load all of
 its data directly into the interactive namespace. Since the file is re-read
 from disk each time, changes you make to it are reflected immediately (unlike
 imported modules, which have to be specifically reloaded). IPython also
 includes :ref:`dreload <dreload>`, a recursive reload function.
 
 ``%run`` has special flags for timing the execution of your scripts (-t), or
 for running them under the control of either Python's pdb debugger (-d) or
 profiler (-p).
 
 The :magic:`edit` command gives a reasonable approximation of multiline editing,
 by invoking your favorite editor on the spot. IPython will execute the
 code you type in there as if it were typed interactively.
 
 Debugging
 ---------
 
 After an exception occurs, you can call :magic:`debug` to jump into the Python
 debugger (pdb) and examine the problem. Alternatively, if you call :magic:`pdb`,
 IPython will automatically start the debugger on any uncaught exception. You can
 print variables, see code, execute statements and even walk up and down the
 call stack to track down the true source of the problem. This can be an efficient
 way to develop and debug code, in many cases eliminating the need for print
 statements or external debugging tools.
 
 You can also step through a program from the beginning by calling
 ``%run -d theprogram.py``.
 
 History
 =======
 
 IPython stores both the commands you enter, and the results it produces. You
 can easily go through previous commands with the up- and down-arrow keys, or
 access your history in more sophisticated ways.
 
 Input and output history are kept in variables called ``In`` and ``Out``, keyed
 by the prompt numbers, e.g. ``In[4]``. The last three objects in output history
 are also kept in variables named ``_``, ``__`` and ``___``.
 
 You can use the ``%history`` magic function to examine past input and output.
 Input history from previous sessions is saved in a database, and IPython can be
 configured to save output history.
 
 Several other magic functions can use your input history, including ``%edit``, 
 ``%rerun``, ``%recall``, ``%macro``, ``%save`` and ``%pastebin``. You can use a
 standard format to refer to lines::
 
     %pastebin 3 18-20 ~1/1-5
     
 This will take line 3 and lines 18 to 20 from the current session, and lines
 1-5 from the previous session.
 
 System shell commands
 =====================
 
 To run any command at the system shell, simply prefix it with !, e.g.::
 
     !ping www.bbc.co.uk
     
 You can capture the output into a Python list, e.g.: ``files = !ls``. To pass
 the values of Python variables or expressions to system commands, prefix them
 with $: ``!grep -rF $pattern ipython/*``. See :ref:`our shell section
 <system_shell_access>` for more details.
 
 Define your own system aliases
 ------------------------------
 
 It's convenient to have aliases to the system commands you use most often.
 This allows you to work seamlessly from inside IPython with the same commands
 you are used to in your system shell. IPython comes with some pre-defined
 aliases and a complete system for changing directories, both via a stack (see
 :magic:`pushd`, :magic:`popd` and :magic:`dhist`) and via direct :magic:`cd`. The latter keeps a history of
 visited directories and allows you to go to any previously visited one.
 
 
 Configuration
 =============
 
 Much of IPython can be tweaked through :doc:`configuration </config/intro>`.
 To get started, use the command ``ipython profile create`` to produce the
 default config files. These will be placed in
 :file:`~/.ipython/profile_default`, and contain comments explaining
 what the various options do.
 
 Profiles allow you to use IPython for different tasks, keeping separate config
 files and history for each one. More details in :ref:`the profiles section
 <profiles>`.
 
+.. _startup_files:
+
 Startup Files
 -------------
 
 If you want some code to be run at the beginning of every IPython session, the
 easiest way is to add Python (.py) or IPython (.ipy) scripts to your
 :file:`profile_default/startup/` directory. Files here will be executed as soon
 as the IPython shell is constructed, before any other code or scripts you have
 specified. The files will be run in order of their names, so you can control the
 ordering with prefixes, like ``10-myimports.py``.
 
 .. include:: ../links.txt

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

@@ -1,220 +1,220 b''
 .. _issues_list_3:
 
 Issues closed in the 3.x development cycle
 ==========================================
 
 Issues closed in 3.1
 --------------------
 
 GitHub stats for 2015/02/27 - 2015/04/03 (since 3.0)
 
 These lists are automatically generated, and may be incomplete or contain duplicates.
 
 We closed 46 issues and merged 133 pull requests.
-The full list can be seen `on GitHub <https://github.com/ipython/ipython/milestones/3.1>`_.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/milestones/3.1>`__.
 
 The following 33 authors contributed 344 commits:
 
 * Abe Guerra
 * Adal Chiriliuc
 * Benjamin Ragan-Kelley
 * Brian Drawert
 * Fernando Perez
 * Gareth Elston
 * Gert-Ludwig Ingold
 * Giuseppe Venturini
 * Jakob Gager
 * Jan Schulz
 * Jason Grout
 * Jessica B. Hamrick
 * Jonathan Frederic
 * Justin Tyberg
 * Lorena Pantano
 * mashenjun
 * Mathieu
 * Matthias Bussonnier
 * Morten Enemark Lund
 * Naveen Nathan
 * Nicholas Bollweg
 * onesandzeroes
 * Patrick Snape
 * Peter Parente
 * RickWinter
 * Robert Smith
 * Ryan Nelson
 * Scott Sanderson
 * Sylvain Corlay
 * Thomas Kluyver
 * tmtabor
 * Wieland Hoffmann
 * Yuval Langer
 
 
 Issues closed in 3.0
 --------------------
 
 GitHub stats for 2014/04/02 - 2015/02/13 (since 2.0)
 
 These lists are automatically generated, and may be incomplete or contain duplicates.
 
 We closed 469 issues and merged 925 pull requests.
-The full list can be seen `on GitHub <https://github.com/ipython/ipython/milestones/3.0>`_.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/milestones/3.0>`__.
 
 The following 155 authors contributed 5975 commits.
 
 * A.J. Holyoake
 * abalkin
 * Adam Hodgen
 * Adrian Price-Whelan
 * Amin Bandali
 * Andreas Amann
 * Andrew Dawes
 * Andrew Jesaitis
 * Andrew Payne
 * AnneTheAgile
 * Aron Ahmadia
 * Ben Duffield
 * Benjamin ABEL
 * Benjamin Ragan-Kelley
 * Benjamin Schultz
 * Björn Grüning
 * Björn Linse
 * Blake Griffith
 * Boris Egorov
 * Brian E. Granger
 * bsvh
 * Carlos Cordoba
 * Cedric GESTES
 * cel
 * chebee7i
 * Christoph Gohlke
 * CJ Carey
 * Cyrille Rossant
 * Dale Jung
 * Damián Avila
 * Damon Allen
 * Daniel B. Vasquez
 * Daniel Rocco
 * Daniel Wehner
 * Dav Clark
 * David Hirschfeld
 * David Neto
 * dexterdev
 * Dimitry Kloper
 * dongweiming
 * Doug Blank
 * drevicko
 * Dustin Rodriguez
 * Eric Firing
 * Eric Galloway
 * Erik M. Bray
 * Erik Tollerud
 * Ezequiel (Zac) Panepucci
 * Fernando Perez
 * foogunlana
 * Francisco de la Peña
 * George Titsworth
 * Gordon Ball
 * gporras
 * Grzegorz Rożniecki
 * Helen ST
 * immerrr
 * Ingolf Becker
 * Jakob Gager
 * James Goppert
 * James Porter
 * Jan Schulz
 * Jason Goad
 * Jason Gors
 * Jason Grout
 * Jason Newton
 * jdavidheiser
 * Jean-Christophe Jaskula
 * Jeff Hemmelgarn
 * Jeffrey Bush
 * Jeroen Demeyer
 * Jessica B. Hamrick
 * Jessica Frazelle
 * jhemmelg
 * Jim Garrison
 * Joel Nothman
 * Johannes Feist
 * John Stowers
 * John Zwinck
 * jonasc
 * Jonathan Frederic
 * Juergen Hasch
 * Julia Evans
 * Justyna Ilczuk
 * Jörg Dietrich
 * K.-Michael Aye
 * Kalibri
 * Kester Tong
 * Kyle Kelley
 * Kyle Rawlins
 * Lev Abalkin
 * Manuel Riel
 * Martin Bergtholdt
 * Martin Spacek
 * Mateusz Paprocki
 * Mathieu
 * Matthias Bussonnier
 * Maximilian Albert
 * mbyt
 * MechCoder
 * Mohan Raj Rajamanickam
 * mvr
 * Narahari
 * Nathan Goldbaum
 * Nathan Heijermans
 * Nathaniel J. Smith
 * ncornette
 * Nicholas Bollweg
 * Nick White
 * Nikolay Koldunov
 * Nile Geisinger
 * Olga Botvinnik
 * Osada Paranaliyanage
 * Pankaj Pandey
 * Pascal Bugnion
 * patricktokeeffe
 * Paul Ivanov
 * Peter Odding
 * Peter Parente
 * Peter Würtz
 * Phil Elson
 * Phillip Nordwall
 * Pierre Gerold
 * Pierre Haessig
 * Raffaele De Feo
 * Ramiro Gómez
 * Reggie Pierce
 * Remi Rampin
 * Renaud Richardet
 * Richard Everson
 * Scott Sanderson
 * Silvia Vinyes
 * Simon Guillot
 * Spencer Nelson
 * Stefan Zimmermann
 * Steve Chan
 * Steven Anton
 * Steven Silvester
 * sunny
 * Susan Tan
 * Sylvain Corlay
 * Tarun Gaba
 * Thomas Ballinger
 * Thomas Kluyver
 * Thomas Robitaille
 * Thomas Spura
 * Tobias Oberstein
 * Torsten Bittner
 * unknown
 * v923z
 * vaibhavsagar
 * W. Trevor King
 * weichm
 * Xiuming Chen
 * Yaroslav Halchenko
 * zah

docs/source/whatsnew/version0.11.rst

@@ -1,765 +1,765 b''
 =============
  0.11 Series
 =============
 
 Release 0.11
 ============
 
 IPython 0.11 is a *major* overhaul of IPython, two years in the making.  Most
 of the code base has been rewritten or at least reorganized, breaking backward
 compatibility with several APIs in previous versions.  It is the first major
 release in two years, and probably the most significant change to IPython since
 its inception.  We plan to have a relatively quick succession of releases, as
 people discover new bugs and regressions.  Once we iron out any significant
 bugs in this process and settle down the new APIs, this series will become
 IPython 1.0.  We encourage feedback now on the core APIs, which we hope to
 maintain stable during the 1.0 series.
 
 Since the internal APIs have changed so much, projects using IPython as a
 library (as opposed to end-users of the application) are the most likely to
 encounter regressions or changes that break their existing use patterns.  We
 will make every effort to provide updated versions of the APIs to facilitate
 the transition, and we encourage you to contact us on the `development mailing
 list`__ with questions and feedback.
 
 .. __: http://mail.scipy.org/mailman/listinfo/ipython-dev
 
 Chris Fonnesbeck recently wrote an `excellent post`__ that highlights some of
 our major new features, with examples and screenshots.  We encourage you to
 read it as it provides an illustrated, high-level overview complementing the
 detailed feature breakdown in this document.
 
 .. __: http://stronginference.com/post/innovations-in-ipython
 
 A quick summary of the major changes (see below for details):
 
 * **Standalone Qt console**: a new rich console has been added to IPython,
   started with `ipython qtconsole`.  In this application we have tried to
   retain the feel of a terminal for fast and efficient workflows, while adding
   many features that a line-oriented terminal simply can not support, such as
   inline figures, full multiline editing with syntax highlighting, graphical
   tooltips for function calls and much more.  This development was sponsored by
   `Enthought Inc.`__. See :ref:`below <qtconsole_011>` for details.
 
 .. __: http://enthought.com
 
 * **High-level parallel computing with ZeroMQ**. Using the same architecture
   that our Qt console is based on, we have completely rewritten our high-level
   parallel computing machinery that in prior versions used the Twisted
   networking framework.  While this change will require users to update their
   codes, the improvements in performance, memory control and internal
   consistency across our codebase convinced us it was a price worth paying.  We
   have tried to explain how to best proceed with this update, and will be happy
   to answer questions that may arise.  A full tutorial describing these
   features `was presented at SciPy'11`__, more details :ref:`below
   <parallel_011>`.
 
 .. __: http://minrk.github.com/scipy-tutorial-2011
 
 * **New model for GUI/plotting support in the terminal**.  Now instead of the
   various `-Xthread` flags we had before, GUI support is provided without the
   use of any threads, by directly integrating GUI event loops with Python's
   `PyOS_InputHook` API.  A new command-line flag `--gui` controls GUI support,
   and it can also be enabled after IPython startup via the new `%gui` magic.
   This requires some changes if you want to execute GUI-using scripts inside
   IPython, see :ref:`the GUI support section <gui_support>` for more details.
 
 * **A two-process architecture.** The Qt console is the first use of a new
   model that splits IPython between a kernel process where code is executed and
   a client that handles user interaction.  We plan on also providing terminal
   and web-browser based clients using this infrastructure in future releases.
   This model allows multiple clients to interact with an IPython process
   through a :ref:`well-documented messaging protocol <messaging>` using the
   ZeroMQ networking library.
 
 * **Refactoring.** the entire codebase has been refactored, in order to make it
   more modular and easier to contribute to.  IPython has traditionally been a
   hard project to participate because the old codebase was very monolithic.  We
   hope this (ongoing) restructuring will make it easier for new developers to
   join us.
 
 * **Vim integration**. Vim can be configured to seamlessly control an IPython
   kernel, see the files in :file:`docs/examples/vim` for the full details.
   This work was done by Paul Ivanov, who prepared a nice `video
   demonstration`__ of the features it provides.
 
 .. __: http://pirsquared.org/blog/2011/07/28/vim-ipython/
   
 * **Integration into Microsoft Visual Studio**. Thanks to the work of the
   Microsoft `Python Tools for Visual Studio`__ team, this version of IPython
   has been integrated into Microsoft Visual Studio's Python tools open source
   plug-in.  `Details below`_
 
 .. __: http://pytools.codeplex.com
 .. _details below: ms_visual_studio_011_
 
 * **Improved unicode support**. We closed many bugs related to unicode input.
 
 * **Python 3**. IPython now runs on Python 3.x. See :ref:`python3_011` for
   details.
 
 * **New profile model**. Profiles are now directories that contain all relevant
   information for that session, and thus better isolate IPython use-cases.
 
 * **SQLite storage for history**. All history is now stored in a SQLite
   database, providing support for multiple simultaneous sessions that won't
   clobber each other as well as the ability to perform queries on all stored
   data.
 
 * **New configuration system**. All parts of IPython are now configured via a
   mechanism inspired by the Enthought Traits library.  Any configurable element
   can have its attributes set either via files that now use real Python syntax
   or from the command-line.
 
 * **Pasting of code with prompts**. IPython now intelligently strips out input
   prompts , be they plain Python ones (``>>>`` and ``...``) or IPython ones
   (``In [N]:`` and ``...:``).  More details :ref:`here <pasting_with_prompts>`.
   
 
 Authors and support
 -------------------
 
 Over 60 separate authors have contributed to this release, see :ref:`below
 <credits_011>` for a full list.  In particular, we want to highlight the
 extremely active participation of two new core team members: Evan Patterson
 implemented the Qt console, and Thomas Kluyver started with our Python 3 port
 and by now has made major contributions to just about every area of IPython.
 
 We are also grateful for the support we have received during this development
 cycle from several institutions:
 
 - `Enthought Inc`__ funded the development of our new Qt console, an effort that
   required developing major pieces of underlying infrastructure, which now
   power not only the Qt console but also our new parallel machinery.  We'd like
   to thank Eric Jones and Travis Oliphant for their support, as well as Ilan
   Schnell for his tireless work integrating and testing IPython in the
   `Enthought Python Distribution`_.
 
 .. __: http://enthought.com
 .. _Enthought Python Distribution: http://www.enthought.com/products/epd.php
 
 - Nipy/NIH: funding via the `NiPy project`__ (NIH grant 5R01MH081909-02) helped
   us jumpstart the development of this series by restructuring the entire
   codebase two years ago in a way that would make modular development and
   testing more approachable.  Without this initial groundwork, all the new
   features we have added would have been impossible to develop.
 
 .. __: http://nipy.org
 
 - Sage/NSF: funding via the grant `Sage: Unifying Mathematical Software for
   Scientists, Engineers, and Mathematicians`__ (NSF grant DMS-1015114)
   supported a meeting in spring 2011 of several of the core IPython developers
   where major progress was made integrating the last key pieces leading to this
   release.
 
 .. __: http://modular.math.washington.edu/grants/compmath09
 
 - Microsoft's team working on `Python Tools for Visual Studio`__ developed the 
   integraton of IPython into the Python plugin for Visual Studio 2010.
 
 .. __: http://pytools.codeplex.com
 
 - Google Summer of Code: in 2010, we had two students developing prototypes of
   the new machinery that is now maturing in this release: `Omar Zapata`_ and
   `Gerardo Gutiérrez`_.
 
 .. _Omar Zapata: http://ipythonzmq.blogspot.com/2010/08/ipython-zmq-status.html
 .. _Gerardo Gutiérrez: http://ipythonqt.blogspot.com/2010/04/ipython-qt-interface-gsoc-2010-proposal.html>
 
 
 Development summary: moving to Git and Github
 ---------------------------------------------
 
 In April 2010, after `one breakage too many with bzr`__, we decided to move our
 entire development process to Git and Github.com.  This has proven to be one of
 the best decisions in the project's history, as the combination of git and
 github have made us far, far more productive than we could be with our previous
 tools.  We first converted our bzr repo to a git one without losing history,
 and a few weeks later ported all open Launchpad bugs to github issues with
 their comments mostly intact (modulo some formatting changes).  This ensured a
 smooth transition where no development history or submitted bugs were lost.
 Feel free to use our little Launchpad to Github issues `porting script`_ if you
 need to make a similar transition.
 
 .. __: http://mail.scipy.org/pipermail/ipython-dev/2010-April/005944.html
 .. _porting script: https://gist.github.com/835577
 
 These simple statistics show how much work has been done on the new release, by
 comparing the current code to the last point it had in common with the 0.10
 series.  A huge diff and ~2200 commits make up this cycle::
 
     git diff $(git merge-base 0.10.2 HEAD)  | wc -l
     288019
 
     git log $(git merge-base 0.10.2 HEAD)..HEAD --oneline | wc -l
     2200
 
 Since our move to github, 511 issues were closed, 226 of which were pull
 requests and 285 regular issues (:ref:`a full list with links
 <issues_list_011>` is available for those interested in the details).  Github's
 pull requests are a fantastic mechanism for reviewing code and building a
 shared ownership of the project, and we are making enthusiastic use of it.
 
 .. Note::
 
    This undercounts the number of issues closed in this development cycle,
    since we only moved to github for issue tracking in May 2010, but we have no
    way of collecting statistics on the number of issues closed in the old
    Launchpad bug tracker prior to that.
 
    
 .. _qtconsole_011:
 
 Qt Console
 ----------
 
 IPython now ships with a Qt application that feels very much like a terminal,
 but is in fact a rich GUI that runs an IPython client but supports inline
 figures, saving sessions to PDF and HTML, multiline editing with syntax
 highlighting, graphical calltips and much more:
 
 .. figure:: ../_images/qtconsole.png
     :width: 400px
     :alt: IPython Qt console with embedded plots
     :align: center
     :target: ../_images/qtconsole.png
 
     The Qt console for IPython, using inline matplotlib plots.
 
 We hope that many projects will embed this widget, which we've kept
 deliberately very lightweight, into their own environments.  In the future we
 may also offer a slightly more featureful application (with menus and other GUI
 elements), but we remain committed to always shipping this easy to embed
 widget.
 
 See the :ref:`Qt console section <qtconsole>` of the docs for a detailed
 description of the console's features and use.
 
 
 .. _parallel_011:
 
 High-level parallel computing with ZeroMQ
 -----------------------------------------
 
 We have completely rewritten the Twisted-based code for high-level parallel
 computing to work atop our new ZeroMQ architecture.  While we realize this will
 break compatibility for a number of users, we hope to make the transition as
 easy as possible with our docs, and we are convinced the change is worth it.
 ZeroMQ provides us with much tighter control over memory, higher performance,
 and its communications are impervious to the Python Global Interpreter Lock
 because they take place in a system-level C++ thread.  The impact of the GIL in
 our previous code was something we could simply not work around, given that
 Twisted is itself a Python library.  So while Twisted is a very capable
 framework, we think ZeroMQ fits our needs much better and we hope you will find
 the change to be a significant improvement in the long run.
 
-Our manual contains :ref:`a full description of how to use IPython for parallel
-computing <parallel_overview>`, and the `tutorial`__ presented by Min
+Our manual contains a full description of how to use IPython for parallel
+computing, and the `tutorial`__ presented by Min
 Ragan-Kelley at the SciPy 2011 conference provides a hands-on complement to the
 reference docs.
 
 .. __: http://minrk.github.com/scipy-tutorial-2011
 
 
 Refactoring
 -----------
 
 As of this release, a signifiant portion of IPython has been refactored.  This
 refactoring is founded on a number of new abstractions.  The main new classes
 that implement these abstractions are:
 
 * :class:`traitlets.HasTraits`.
 * :class:`traitlets.config.configurable.Configurable`.
 * :class:`traitlets.config.application.Application`.
 * :class:`traitlets.config.loader.ConfigLoader`.
 * :class:`traitlets.config.loader.Config`
 
 We are still in the process of writing developer focused documentation about
 these classes, but for now our :ref:`configuration documentation
 <config_overview>` contains a high level overview of the concepts that these
 classes express.
 
 The biggest user-visible change is likely the move to using the config system
 to determine the command-line arguments for IPython applications. The benefit
 of this is that *all* configurable values in IPython are exposed on the
 command-line, but the syntax for specifying values has changed. The gist is
 that assigning values is pure Python assignment.  Simple flags exist for
 commonly used options, these are always prefixed with '--'.
 
 The IPython command-line help has the details of all the options (via
-``ipythyon --help``), but a simple example should clarify things; the ``pylab``
+``ipython --help``), but a simple example should clarify things; the ``pylab``
 flag can be used to start in pylab mode with the qt4 backend::
 
   ipython --pylab=qt
 
 which is equivalent to using the fully qualified form::
 
   ipython --TerminalIPythonApp.pylab=qt
 
 The long-form options can be listed via ``ipython --help-all``.
 
 
 ZeroMQ architecture
 -------------------
 
 There is a new GUI framework for IPython, based on a client-server model in
 which multiple clients can communicate with one IPython kernel, using the
 ZeroMQ messaging framework. There is already a Qt console client, which can
 be started by calling ``ipython qtconsole``. The protocol is :ref:`documented
 <messaging>`.
 
 The parallel computing framework has also been rewritten using ZMQ. The
 protocol is described :ref:`here <parallel_messages>`, and the code is in the
 new :mod:`IPython.parallel` module.
 
 .. _python3_011:
 
 Python 3 support
 ----------------
 
 A Python 3 version of IPython has been prepared. For the time being, this is
 maintained separately and updated from the main codebase. Its code can be found
 `here <https://github.com/ipython/ipython-py3k>`_. The parallel computing
 components are not perfect on Python3, but most functionality appears to be
 working.  As this work is evolving quickly, the best place to find updated
 information about it is our `Python 3 wiki page`__.
 
 .. __: http://wiki.ipython.org/index.php?title=Python_3
 
 
 Unicode
 -------
 
 Entering non-ascii characters in unicode literals (``u"€ø"``) now works
 properly on all platforms. However, entering these in byte/string literals
 (``"€ø"``) will not work as expected on Windows (or any platform where the
 terminal encoding is not UTF-8, as it typically is for Linux & Mac OS X). You
 can use escape sequences (``"\xe9\x82"``) to get bytes above 128, or use
 unicode literals and encode them. This is a limitation of Python 2 which we
 cannot easily work around.
 
 .. _ms_visual_studio_011:
 
 Integration with Microsoft Visual Studio
 ----------------------------------------
 
 IPython can be used as the interactive shell in the `Python plugin for
 Microsoft Visual Studio`__, as seen here:
 
 .. figure:: ../_images/ms_visual_studio.png
     :width: 500px
     :alt: IPython console embedded in Microsoft Visual Studio.
     :align: center
     :target: ../_images/ms_visual_studio.png
 
     IPython console embedded in Microsoft Visual Studio.
 
 The Microsoft team developing this currently has a release candidate out using
 IPython 0.11. We will continue to collaborate with them to ensure that as they
 approach their final release date, the integration with IPython remains smooth.
 We'd like to thank Dino Viehland and Shahrokh Mortazavi for the work they have
 done towards this feature, as well as Wenming Ye for his support of our WinHPC
 capabilities.
 
 .. __: http://pytools.codeplex.com
 
 
 Additional new features
 -----------------------
 
 * Added ``Bytes`` traitlet, removing ``Str``.  All 'string' traitlets should
   either be ``Unicode`` if a real string, or ``Bytes`` if a C-string. This
   removes ambiguity and helps the Python 3 transition.
 
 * New magic ``%loadpy`` loads a python file from disk or web URL into
   the current input buffer.
 
 * New magic ``%pastebin`` for sharing code via the 'Lodge it' pastebin.
 
 * New magic ``%precision`` for controlling float and numpy pretty printing.
 
 * IPython applications initiate logging, so any object can gain access to
   a the logger of the currently running Application with:
 
 .. sourcecode:: python
 
     from traitlets.config.application import Application
     logger = Application.instance().log
 
 * You can now get help on an object halfway through typing a command. For
   instance, typing ``a = zip?`` shows the details of :func:`zip`. It also
   leaves the command at the next prompt so you can carry on with it.
 
 * The input history is now written to an SQLite database. The API for
   retrieving items from the history has also been redesigned.
 
 * The :mod:`IPython.extensions.pretty` extension has been moved out of
   quarantine and fully updated to the new extension API.
 
 * New magics for loading/unloading/reloading extensions have been added:
   ``%load_ext``, ``%unload_ext`` and ``%reload_ext``.
 
 * The configuration system and configuration files are brand new. See the
   configuration system :ref:`documentation <config_index>` for more details.
 
 * The :class:`~IPython.core.interactiveshell.InteractiveShell` class is now a
   :class:`~traitlets.config.configurable.Configurable` subclass and has traitlets
   that determine the defaults and runtime environment. The ``__init__`` method
   has also been refactored so this class can be instantiated and run without
   the old :mod:`ipmaker` module.
 
 * The methods of :class:`~IPython.core.interactiveshell.InteractiveShell` have
   been organized into sections to make it easier to turn more sections
   of functionality into components.
 
 * The embedded shell has been refactored into a truly standalone subclass of
   :class:`InteractiveShell` called :class:`InteractiveShellEmbed`.  All
   embedding logic has been taken out of the base class and put into the 
   embedded subclass.
 
 * Added methods of :class:`~IPython.core.interactiveshell.InteractiveShell` to
   help it cleanup after itself. The :meth:`cleanup` method controls this. We
   couldn't do this in :meth:`__del__` because we have cycles in our object
   graph that prevent it from being called.
 
 * Created a new module :mod:`IPython.utils.importstring` for resolving
   strings like ``foo.bar.Bar`` to the actual class.
 
 * Completely refactored the :mod:`IPython.core.prefilter` module into
   :class:`~traitlets.config.configurable.Configurable` subclasses. Added a new
   layer into the prefilter system, called "transformations" that all new
   prefilter logic should use (rather than the older "checker/handler"
   approach).
 
 * Aliases are now components (:mod:`IPython.core.alias`).
 
 * New top level :func:`~IPython.frontend.terminal.embed.embed` function that can
   be called to embed IPython at any place in user's code. On the first call it
   will create an :class:`~IPython.frontend.terminal.embed.InteractiveShellEmbed`
   instance and call it. In later calls, it just calls the previously created
   :class:`~IPython.frontend.terminal.embed.InteractiveShellEmbed`.
 
 * Created a configuration system (:mod:`traitlets.config.configurable`) that is
   based on :mod:`traitlets`. Configurables are arranged into a
   runtime containment tree (not inheritance) that i) automatically propagates
   configuration information and ii) allows singletons to discover each other in
   a loosely coupled manner. In the future all parts of IPython will be
   subclasses of :class:`~traitlets.config.configurable.Configurable`. All IPython
   developers should become familiar with the config system.
 
 * Created a new :class:`~traitlets.config.loader.Config` for holding
   configuration information. This is a dict like class with a few extras: i)
   it supports attribute style access, ii) it has a merge function that merges
   two :class:`~traitlets.config.loader.Config` instances recursively and iii) it
   will automatically create sub-:class:`~traitlets.config.loader.Config`
   instances for attributes that start with an uppercase character.
 
 * Created new configuration loaders in :mod:`traitlets.config.loader`. These
   loaders provide a unified loading interface for all configuration
   information including command line arguments and configuration files. We
   have two default implementations based on :mod:`argparse` and plain python
   files.  These are used to implement the new configuration system.
 
 * Created a top-level :class:`Application` class in
   :mod:`IPython.core.application` that is designed to encapsulate the starting
   of any basic Python program. An application loads and merges all the
   configuration objects, constructs the main application, configures and
   initiates logging, and creates and configures any :class:`Configurable`
   instances and then starts the application running. An extended
   :class:`BaseIPythonApplication` class adds logic for handling the
   IPython directory as well as profiles, and all IPython entry points
   extend it.
 
 * The :class:`Type` and :class:`Instance` traitlets now handle classes given
   as strings, like ``foo.bar.Bar``. This is needed for forward declarations.
   But, this was implemented in a careful way so that string to class
   resolution is done at a single point, when the parent
   :class:`~traitlets.HasTraitlets` is instantiated.
 
 * :mod:`IPython.utils.ipstruct` has been refactored to be a subclass of 
   dict.  It also now has full docstrings and doctests.
 
 * Created a Traits like implementation in :mod:`traitlets`.  This
   is a pure Python, lightweight version of a library that is similar to
   Enthought's Traits project, but has no dependencies on Enthought's code.  We
   are using this for validation, defaults and notification in our new component
   system.  Although it is not 100% API compatible with Enthought's Traits, we
   plan on moving in this direction so that eventually our implementation could
   be replaced by a (yet to exist) pure Python version of Enthought Traits.
 
 * Added a new module :mod:`IPython.lib.inputhook` to manage the integration
   with GUI event loops using `PyOS_InputHook`.  See the docstrings in this
   module or the main IPython docs for details.
 
 * For users, GUI event loop integration is now handled through the new
   :command:`%gui` magic command.  Type ``%gui?`` at an IPython prompt for
   documentation.
 
 * For developers :mod:`IPython.lib.inputhook` provides a simple interface
   for managing the event loops in their interactive GUI applications.
   Examples can be found in our :file:`examples/lib` directory.
 
 Backwards incompatible changes
 ------------------------------
 
 * The Twisted-based :mod:`IPython.kernel` has been removed, and completely
   rewritten as :mod:`IPython.parallel`, using ZeroMQ.
 
 * Profiles are now directories. Instead of a profile being a single config file,
   profiles are now self-contained directories. By default, profiles get their
   own IPython history, log files, and everything. To create a new profile, do
   ``ipython profile create <name>``.
 
 * All IPython applications have been rewritten to use
   :class:`~traitlets.config.loader.KeyValueConfigLoader`. This means that
   command-line options have changed. Now, all configurable values are accessible
   from the command-line with the same syntax as in a configuration file.
 
 * The command line options ``-wthread``, ``-qthread`` and
   ``-gthread`` have been removed. Use ``--gui=wx``, ``--gui=qt``, ``--gui=gtk``
   instead.
 
 * The extension loading functions have been renamed to
   :func:`load_ipython_extension` and :func:`unload_ipython_extension`.
 
 * :class:`~IPython.core.interactiveshell.InteractiveShell` no longer takes an
   ``embedded`` argument. Instead just use the
   :class:`~IPython.core.interactiveshell.InteractiveShellEmbed` class.
 
 * ``__IPYTHON__`` is no longer injected into ``__builtin__``.
 
 * :meth:`Struct.__init__` no longer takes `None` as its first argument.  It
   must be a :class:`dict` or :class:`Struct`.
 
 * :meth:`~IPython.core.interactiveshell.InteractiveShell.ipmagic` has been
   renamed :meth:`~IPython.core.interactiveshell.InteractiveShell.magic.`
 
 * The functions :func:`ipmagic` and :func:`ipalias` have been removed from
   :mod:`__builtins__`.
 
 * The references to the global
   :class:`~IPython.core.interactivehell.InteractiveShell` instance (``_ip``, and
   ``__IP``) have been removed from the user's namespace. They are replaced by a
   new function called :func:`get_ipython` that returns the current
   :class:`~IPython.core.interactiveshell.InteractiveShell` instance. This
   function is injected into the user's namespace and is now the main way of
   accessing the running IPython.
 
 * Old style configuration files :file:`ipythonrc` and :file:`ipy_user_conf.py`
   are no longer supported. Users should migrate there configuration files to
   the new format described :doc:`here </config/intro>` and
   :ref:`here <config_overview>`.
 
 * The old IPython extension API that relied on :func:`ipapi` has been
   completely removed. The new extension API is described :ref:`here
   <extensions_overview>`.
 
 * Support for ``qt3`` has been dropped.  Users who need this should use
   previous versions of IPython.
 
 * Removed :mod:`shellglobals` as it was obsolete.
 
 * Removed all the threaded shells in :mod:`IPython.core.shell`. These are no
   longer needed because of the new capabilities in
   :mod:`IPython.lib.inputhook`.
 
 * New top-level sub-packages have been created: :mod:`IPython.core`, 
   :mod:`IPython.lib`, :mod:`IPython.utils`, :mod:`IPython.deathrow`,
   :mod:`IPython.quarantine`.  All existing top-level modules have been
   moved to appropriate sub-packages.  All internal import statements
   have been updated and tests have been added.  The build system (setup.py
   and friends) have been updated. See :doc:`/api/index` for details of these
   new sub-packages.
 
 * :mod:`IPython.ipapi` has been moved to :mod:`IPython.core.ipapi`.
   :mod:`IPython.Shell` and :mod:`IPython.iplib` have been split and removed as
   part of the refactor.
 
 * :mod:`Extensions` has been moved to :mod:`extensions` and all existing
   extensions have been moved to either :mod:`IPython.quarantine` or
   :mod:`IPython.deathrow`. :mod:`IPython.quarantine` contains modules that we
   plan on keeping but that need to be updated. :mod:`IPython.deathrow` contains
   modules that are either dead or that should be maintained as third party
   libraries.
 
 * Previous IPython GUIs in :mod:`IPython.frontend` and :mod:`IPython.gui` are
   likely broken, and have been removed to :mod:`IPython.deathrow` because of the
   refactoring in the core. With proper updates, these should still work.
 
 
 Known Regressions
 -----------------
 
 We do our best to improve IPython, but there are some known regressions in 0.11
 relative to 0.10.2.  First of all, there are features that have yet to be
 ported to the new APIs, and in order to ensure that all of the installed code
 runs for our users, we have moved them to two separate directories in the
 source distribution, `quarantine` and `deathrow`.  Finally, we have some other
 miscellaneous regressions that we hope to fix as soon as possible.  We now
 describe all of these in more detail.
 
 Quarantine
 ~~~~~~~~~~
 
 These are tools and extensions that we consider relatively easy to update to
 the new classes and APIs, but that we simply haven't had time for.  Any user
 who is interested in one of these is encouraged to help us by porting it and
 submitting a pull request on our `development site`_.
 
 .. _development site: http://github.com/ipython/ipython
 
 Currently, the quarantine directory contains::
 
     clearcmd.py            ipy_fsops.py            ipy_signals.py
     envpersist.py          ipy_gnuglobal.py        ipy_synchronize_with.py
     ext_rescapture.py      ipy_greedycompleter.py  ipy_system_conf.py
     InterpreterExec.py     ipy_jot.py              ipy_which.py
     ipy_app_completers.py  ipy_lookfor.py          ipy_winpdb.py
     ipy_autoreload.py      ipy_profile_doctest.py  ipy_workdir.py
     ipy_completers.py      ipy_pydb.py             jobctrl.py
     ipy_editors.py         ipy_rehashdir.py        ledit.py
     ipy_exportdb.py        ipy_render.py           pspersistence.py
     ipy_extutil.py         ipy_server.py           win32clip.py
 
 Deathrow
 ~~~~~~~~
 
 These packages may be harder to update or make most sense as third-party
 libraries.  Some of them are completely obsolete and have been already replaced
 by better functionality (we simply haven't had the time to carefully weed them
 out so they are kept here for now). Others simply require fixes to code that
 the current core team may not be familiar with.  If a tool you were used to is
 included here, we encourage you to contact the dev list and we can discuss
 whether it makes sense to keep it in IPython (if it can be maintained).
 
 Currently, the deathrow directory contains::
 
     astyle.py              ipy_defaults.py          ipy_vimserver.py
     dtutils.py             ipy_kitcfg.py            numeric_formats.py
     Gnuplot2.py            ipy_legacy.py            numutils.py
     GnuplotInteractive.py  ipy_p4.py                outputtrap.py
     GnuplotRuntime.py      ipy_profile_none.py      PhysicalQInput.py
     ibrowse.py             ipy_profile_numpy.py     PhysicalQInteractive.py
     igrid.py               ipy_profile_scipy.py     quitter.py*
     ipipe.py               ipy_profile_sh.py        scitedirector.py
     iplib.py               ipy_profile_zope.py      Shell.py
     ipy_constants.py       ipy_traits_completer.py  twshell.py
 
 
 Other regressions
 ~~~~~~~~~~~~~~~~~
 
 * The machinery that adds functionality to the 'sh' profile for using IPython
   as your system shell has not been updated to use the new APIs.  As a result,
   only the aesthetic (prompt) changes are still implemented. We intend to fix
   this by 0.12.  Tracked as issue 547_.
 
 .. _547: https://github.com/ipython/ipython/issues/547
 
 * The installation of scripts on Windows was broken without setuptools, so we
   now depend on setuptools on Windows.  We hope to fix setuptools-less
   installation, and then remove the setuptools dependency.  Issue 539_.
 
 .. _539: https://github.com/ipython/ipython/issues/539
 
 * The directory history `_dh` is not saved between sessions.  Issue 634_.
 
 .. _634: https://github.com/ipython/ipython/issues/634
 
 
 Removed Features
 ----------------
 
 As part of the updating of IPython, we have removed a few features for the
 purposes of cleaning up the codebase and interfaces.  These removals are
 permanent, but for any item listed below, equivalent functionality is
 available.
 
 * The magics Exit and Quit have been dropped as ways to exit IPython. Instead,
   the lowercase forms of both work either as a bare name (``exit``) or a
   function call (``exit()``).  You can assign these to other names using
   exec_lines in the config file.
 
 
 .. _credits_011:
 
 Credits
 -------
 
 Many users and developers contributed code, features, bug reports and ideas to
 this release.  Please do not hesitate in contacting us if we've failed to
 acknowledge your contribution here.  In particular, for this release we have
 contribution from the following people, a mix of new and regular names (in
 alphabetical order by first name):
 
 * Aenugu Sai Kiran Reddy <saikrn08-at-gmail.com>
 * andy wilson <wilson.andrew.j+github-at-gmail.com>
 * Antonio Cuni <antocuni>
 * Barry Wark <barrywark-at-gmail.com>
 * Beetoju Anuradha <anu.beethoju-at-gmail.com>
 * Benjamin Ragan-Kelley <minrk-at-Mercury.local>
 * Brad Reisfeld
 * Brian E. Granger <ellisonbg-at-gmail.com>
 * Christoph Gohlke <cgohlke-at-uci.edu>
 * Cody Precord
 * dan.milstein
 * Darren Dale <dsdale24-at-gmail.com>
 * Dav Clark <davclark-at-berkeley.edu>
 * David Warde-Farley <wardefar-at-iro.umontreal.ca>
 * epatters <ejpatters-at-gmail.com>
 * epatters <epatters-at-caltech.edu>
 * epatters <epatters-at-enthought.com>
 * Eric Firing <efiring-at-hawaii.edu>
 * Erik Tollerud <erik.tollerud-at-gmail.com>
 * Evan Patterson <epatters-at-enthought.com>
 * Fernando Perez <Fernando.Perez-at-berkeley.edu>
 * Gael Varoquaux <gael.varoquaux-at-normalesup.org>
 * Gerardo <muzgash-at-Muzpelheim>
 * Jason Grout <jason.grout-at-drake.edu>
 * John Hunter <jdh2358-at-gmail.com>
 * Jens Hedegaard Nielsen <jenshnielsen-at-gmail.com>
 * Johann Cohen-Tanugi <johann.cohentanugi-at-gmail.com>
 * Jörgen Stenarson <jorgen.stenarson-at-bostream.nu>
 * Justin Riley <justin.t.riley-at-gmail.com>
 * Kiorky
 * Laurent Dufrechou <laurent.dufrechou-at-gmail.com>
 * Luis Pedro Coelho <lpc-at-cmu.edu>
 * Mani chandra <mchandra-at-iitk.ac.in>
 * Mark E. Smith
 * Mark Voorhies <mark.voorhies-at-ucsf.edu>
 * Martin Spacek <git-at-mspacek.mm.st>
 * Michael Droettboom <mdroe-at-stsci.edu>
 * MinRK <benjaminrk-at-gmail.com>
 * muzuiget <muzuiget-at-gmail.com>
 * Nick Tarleton <nick-at-quixey.com>
 * Nicolas Rougier <Nicolas.rougier-at-inria.fr>
 * Omar Andres Zapata Mesa <andresete.chaos-at-gmail.com>
 * Paul Ivanov <pivanov314-at-gmail.com>
 * Pauli Virtanen <pauli.virtanen-at-iki.fi>
 * Prabhu Ramachandran
 * Ramana <sramana9-at-gmail.com>
 * Robert Kern <robert.kern-at-gmail.com>
 * Sathesh Chandra <satheshchandra88-at-gmail.com>
 * Satrajit Ghosh <satra-at-mit.edu>
 * Sebastian Busch
 * Skipper Seabold <jsseabold-at-gmail.com>
 * Stefan van der Walt <bzr-at-mentat.za.net>
 * Stephan Peijnik <debian-at-sp.or.at>
 * Steven Bethard
 * Thomas Kluyver <takowl-at-gmail.com>
 * Thomas Spura <tomspur-at-fedoraproject.org>
 * Tom Fetherston <tfetherston-at-aol.com>
 * Tom MacWright
 * tzanko
 * vankayala sowjanya <hai.sowjanya-at-gmail.com>
 * Vivian De Smedt <vds2212-at-VIVIAN>
 * Ville M. Vainio <vivainio-at-gmail.com>
 * Vishal Vatsa <vishal.vatsa-at-gmail.com>
 * Vishnu S G <sgvishnu777-at-gmail.com>
 * Walter Doerwald <walter-at-livinglogic.de>
 
 .. note::
 
     This list was generated with the output of
     ``git log dev-0.11 HEAD --format='* %aN <%aE>' | sed 's/@/\-at\-/' | sed 's/<>//' | sort -u``
     after some cleanup.  If you should be on this list, please add yourself.

docs/source/whatsnew/version0.13.rst

@@ -1,673 +1,670 b''
 =============
  0.13 Series
 =============
 
 Release 0.13
 ============
 
 IPython 0.13 contains several major new features, as well as a large amount of
 bug and regression fixes.  The previous version (0.12) was released on December
 19 2011, and in this development cycle we had:
 
 - ~6 months of work.
 - 373 pull requests merged.
 - 742 issues closed (non-pull requests).
 - contributions from 62 authors.
 - 1760 commits.
 - a diff of 114226 lines.
 
 The amount of work included in this release is so large, that we can only cover
 here the main highlights; please see our :ref:`detailed release statistics
 <issues_list_013>` for links to every issue and pull request closed on GitHub
 as well as a full list of individual contributors.
 
 
 Major Notebook improvements: new user interface and more
 --------------------------------------------------------
 
 The IPython Notebook, which has proven since its release to be wildly popular,
 has seen a massive amount of work in this release cycle, leading to a
 significantly improved user experience as well as many new features.
 
 The first user-visible change is a reorganization of the user interface; the
 left panel has been removed and was replaced by a real menu system and a
 toolbar with icons.  Both the toolbar and the header above the menu can be
 collapsed to leave an unobstructed working area:
 
 .. image:: ../_images/ipy_013_notebook_spectrogram.png
     :width: 460px
     :alt: New user interface for Notebook
     :align: center
     :target: ../_images/ipy_013_notebook_spectrogram.png
 
 The notebook handles very long outputs much better than before (this was a
 serious usability issue when running processes that generated massive amounts
 of output).  Now, in the presence of outputs longer than ~100 lines, the
 notebook will automatically collapse to a scrollable area and the entire left
 part of this area controls the display: one click in this area will expand the
 output region completely, and a double-click will hide it completely.  This
 figure shows both the scrolled and hidden modes:
 
 .. image:: ../_images/ipy_013_notebook_long_out.png
     :width: 460px
     :alt: Scrolling and hiding of long output in the notebook.
     :align: center
     :target: ../_images/ipy_013_notebook_long_out.png
 
 .. note::
 
    The auto-folding of long outputs is disabled in Firefox due to bugs in its
    scrolling behavior.  See :ghpull:`2047` for details.
 
 Uploading notebooks to the dashboard is now easier: in addition to drag and
 drop (which can be finicky sometimes), you can now click on the upload text and
 use a regular file dialog box to select notebooks to upload. Furthermore, the
 notebook dashboard now auto-refreshes its contents and offers buttons to shut
 down any running kernels (:ghpull:`1739`):
 
 .. image:: ../_images/ipy_013_dashboard.png
     :width: 460px
     :alt: Improved dashboard
     :align: center
     :target: ../_images/ipy_013_dashboard.png
 
 
 Cluster management
 ~~~~~~~~~~~~~~~~~~
 
 The notebook dashboard can now also start and stop clusters, thanks to a new
 tab in the dashboard user interface:
 
 .. image:: ../_images/ipy_013_dashboard_cluster.png
     :width: 460px
     :alt: Cluster management from the notebook dashboard
     :align: center
     :target: ../_images/ipy_013_dashboard_cluster.png
 
 This interface allows, for each profile you have configured, to start and stop
 a cluster (and optionally override the default number of engines corresponding
 to that configuration).  While this hides all error reporting, once you have a
 configuration that you know works smoothly, it is a very convenient interface
 for controlling your parallel resources.
 
 
 New notebook format
 ~~~~~~~~~~~~~~~~~~~
 
 The notebooks saved now use version 3 of our format, which supports heading
 levels as well as the concept of 'raw' text cells that are not rendered as
 Markdown.  These will be useful with converters_ we are developing, to pass raw
 markup (say LaTeX).  That conversion code is still under heavy development and
 not quite ready for prime time, but we welcome help on this front so that we
 can merge it for full production use as soon as possible.
 
 .. _converters: https://github.com/ipython/nbconvert
 
 .. note::
 
    v3 notebooks can *not* be read by older versions of IPython, but we provide
    a `simple script`_ that you can use in case you need to export a v3
    notebook to share with a v2 user.
 
 .. _simple script: https://gist.github.com/1935808
 
 
 JavaScript refactoring
 ~~~~~~~~~~~~~~~~~~~~~~
   
 All the client-side JavaScript has been decoupled to ease reuse of parts of the
 machinery without having to build a full-blown notebook. This will make it much
 easier to communicate with an IPython kernel from existing web pages and to
 integrate single cells into other sites, without loading the full notebook
 document-like UI. :ghpull:`1711`.
     
 This refactoring also enables the possibility of writing dynamic javascript
 widgets that are returned from Python code and that present an interactive view
 to the user, with callbacks in Javascript executing calls to the Kernel.  This
 will enable many interactive elements to be added by users in notebooks.
 
 An example of this capability has been provided as a proof of concept in
 :file:`examples/widgets` that lets you directly communicate with one or more
 parallel engines, acting as a mini-console for parallel debugging and
 introspection.
 
     
 Improved tooltips
 ~~~~~~~~~~~~~~~~~
 
 The object tooltips have gained some new functionality. By pressing tab several
 times, you can expand them to see more of a docstring, keep them visible as you
 fill in a function's parameters, or transfer the information to the pager at the
 bottom of the screen. For the details, look at the example notebook
 :file:`01_notebook_introduction.ipynb`.
 
 .. figure:: ../_images/ipy_013_notebook_tooltip.png
     :width: 460px
     :alt: Improved tooltips in the notebook.
     :align: center
     :target: ../_images/ipy_013_notebook_tooltip.png
 
     The new notebook tooltips.
 
 Other improvements to the Notebook
 ----------------------------------
 
 These are some other notable small improvements to the notebook, in addition to
 many bug fixes and minor changes to add polish and robustness throughout:
 
 * The notebook pager (the area at the bottom) is now resizeable by dragging its
   divider handle, a feature that had been requested many times by just about
   anyone who had used the notebook system.  :ghpull:`1705`.
 
 * It is now possible to open notebooks directly from the command line; for
   example: ``ipython notebook path/`` will automatically set ``path/`` as the
   notebook directory, and ``ipython notebook path/foo.ipynb`` will further
   start with the ``foo.ipynb`` notebook opened.  :ghpull:`1686`.
   
 * If a notebook directory is specified with ``--notebook-dir`` (or with the
   corresponding configuration flag ``NotebookManager.notebook_dir``), all
   kernels start in this directory.
 
 * Fix codemirror clearing of cells with ``Ctrl-Z``; :ghpull:`1965`.
   
 * Text (markdown) cells now line wrap correctly in the notebook, making them
   much easier to edit :ghpull:`1330`.
   
 * PNG and JPEG figures returned from plots can be interactively resized in the
   notebook, by dragging them from their lower left corner. :ghpull:`1832`.
 
 * Clear ``In []`` prompt numbers on "Clear All Output".  For more
   version-control-friendly ``.ipynb`` files, we now strip all prompt numbers
   when doing a "Clear all output".  This reduces the amount of noise in
   commit-to-commit diffs that would otherwise show the (highly variable) prompt
   number changes. :ghpull:`1621`.
 
 * The notebook server now requires *two* consecutive ``Ctrl-C`` within 5
   seconds (or an interactive confirmation) to terminate operation.  This makes
   it less likely that you will accidentally kill a long-running server by
   typing ``Ctrl-C`` in the wrong terminal.  :ghpull:`1609`.
 
 * Using ``Ctrl-S`` (or ``Cmd-S`` on a Mac) actually saves the notebook rather
   than providing the fairly useless browser html save dialog.  :ghpull:`1334`.
   
 * Allow accessing local files from the notebook (in urls), by serving any local
   file as the url ``files/<relativepath>``.  This makes it possible to, for
   example, embed local images in a notebook.  :ghpull:`1211`.
 
       
 Cell magics
 -----------
 
 We have completely refactored the magic system, finally moving the magic
 objects to standalone, independent objects instead of being the mixin class
 we'd had since the beginning of IPython (:ghpull:`1732`).  Now, a separate base
 class is provided in :class:`IPython.core.magic.Magics` that users can subclass
 to create their own magics.  Decorators are also provided to create magics from
 simple functions without the need for object orientation.  Please see the
 :ref:`magic` docs for further details.
 
 All builtin magics now exist in a few subclasses that group together related
 functionality, and the new :mod:`IPython.core.magics` package has been created
 to organize this into smaller files.
     
 This cleanup was the last major piece of deep refactoring needed from the
 original 2001 codebase.
     
 We have also introduced a new type of magic function, prefixed with `%%`
 instead of `%`, which operates at the whole-cell level.  A cell magic receives
 two arguments: the line it is called on (like a line magic) and the body of the
 cell below it.
     
 Cell magics are most natural in the notebook, but they also work in the
 terminal and qt console, with the usual approach of using a blank line to
 signal cell termination.
     
 For example, to time the execution of several statements::
 
     %%timeit x = 0   # setup
     for i in range(100000):
         x += i**2
 
 This is particularly useful to integrate code in another language, and cell
 magics already exist for shell scripts, Cython, R and Octave. Using ``%%script
 /usr/bin/foo``, you can run a cell in any interpreter that accepts code via
 stdin.
 
 Another handy cell magic makes it easy to write short text files: ``%%file
 ~/save/to/here.txt``.
 
 The following cell magics are now included by default; all those that use
 special interpreters (Perl, Ruby, bash, etc.) assume you have the requisite
 interpreter installed:
 
 * ``%%!``: run cell body with the underlying OS shell; this is similar to
   prefixing every line in the cell with ``!``.
   
 * ``%%bash``: run cell body under bash.
   
 * ``%%capture``: capture the output of the code in the cell (and stderr as
   well).  Useful to run codes that produce too much output that you don't even
   want scrolled.
   
 * ``%%file``: save cell body as a file.
   
 * ``%%perl``: run cell body using Perl.
   
 * ``%%prun``: run cell body with profiler (cell extension of ``%prun``).
   
 * ``%%python3``: run cell body using Python 3.
   
 * ``%%ruby``: run cell body using Ruby.
   
 * ``%%script``: run cell body with the script specified in the first line.
   
 * ``%%sh``: run cell body using sh.
   
 * ``%%sx``: run cell with system shell and capture process output (cell
   extension of ``%sx``).
   
 * ``%%system``: run cell with system shell (``%%!`` is an alias to this).
   
 * ``%%timeit``: time the execution of the cell (extension of ``%timeit``).
 
 This is what some of the script-related magics look like in action:
 
 .. image:: ../_images/ipy_013_notebook_script_cells.png
     :width: 460px
     :alt: Cluster management from the notebook dashboard
     :align: center
     :target: ../_images/ipy_013_notebook_script_cells.png
   
 In addition, we have also a number of :ref:`extensions <extensions_overview>`
 that provide specialized magics.  These typically require additional software
 to run and must be manually loaded via ``%load_ext <extension name>``, but are
 extremely useful.  The following extensions are provided:
 
-**Cython magics** (extension :ref:`cythonmagic <extensions_cythonmagic>`)
+**Cython magics** (extension ``cythonmagic``)
     This extension provides magics to automatically build and compile Python
     extension modules using the Cython_ language. You must install Cython
     separately, as well as a C compiler, for this to work.  The examples
     directory in the source distribution ships with a full notebook
     demonstrating these capabilities:
 
 .. image:: ../_images/ipy_013_notebook_cythonmagic.png
     :width: 460px
     :alt: Cython magic
     :align: center
     :target: ../_images/ipy_013_notebook_cythonmagic.png
 
 .. _cython: http://cython.org
 
 **Octave magics** (extension ``octavemagic``)
     This extension provides several magics that support calling code written in
     the Octave_ language for numerical computing.  You can execute single-lines
     or whole blocks of Octave code, capture both output and figures inline
     (just like matplotlib plots), and have variables automatically converted
     between the two languages.  To use this extension, you must have Octave
     installed as well as the oct2py_ package.  The examples
     directory in the source distribution ships with a full notebook
     demonstrating these capabilities:
 
 .. image:: ../_images/ipy_013_notebook_octavemagic.png
     :width: 460px
     :alt: Octave magic
     :align: center
     :target: ../_images/ipy_013_notebook_octavemagic.png
 
 .. _octave: http://www.gnu.org/software/octave
 .. _oct2py: http://pypi.python.org/pypi/oct2py
 
 **R magics** (extension ``rmagic``)
     This extension provides several magics that support calling code written in
     the R_ language for statistical data analysis.  You can execute
     single-lines or whole blocks of R code, capture both output and figures
     inline (just like matplotlib plots), and have variables automatically
     converted between the two languages.  To use this extension, you must have
     R installed as well as the rpy2_ package that bridges Python and R.  The
     examples directory in the source distribution ships with a full notebook
     demonstrating these capabilities:
 
 .. image:: ../_images/ipy_013_notebook_rmagic.png
     :width: 460px
     :alt: R magic
     :align: center
     :target: ../_images/ipy_013_notebook_rmagic.png
 
 .. _R: http://www.r-project.org
 .. _rpy2: http://rpy.sourceforge.net/rpy2.html
 
 
 Tab completer improvements
 --------------------------
 
 Useful tab-completion based on live inspection of objects is one of the most
 popular features of IPython. To make this process even more user-friendly, the
 completers of both the Qt console and the Notebook have been reworked.
 
 The Qt console comes with a new ncurses-like tab completer, activated by
 default, which lets you cycle through the available completions by pressing tab,
 or select a completion with the arrow keys (:ghpull:`1851`).
 
 .. figure:: ../_images/ipy_013_qtconsole_completer.png
     :width: 460px
     :alt: ncurses-like completer, with highlighted selection.
     :align: center
     :target: ../_images/ipy_013_qtconsole_completer.png
 
     The new improved Qt console's ncurses-like completer allows to easily
     navigate thought long list of completions.
 
 In the notebook, completions are now sourced both from object introspection and
 analysis of surrounding code, so limited completions can be offered for
 variables defined in the current cell, or while the kernel is busy 
 (:ghpull:`1711`).
 
 
 We have implemented a new configurable flag to control tab completion on
 modules that provide the ``__all__`` attribute::
 
   IPCompleter.limit_to__all__= Boolean
 
 This instructs the completer to honor ``__all__`` for the completion.
 Specifically, when completing on ``object.<tab>``, if True: only those names
 in ``obj.__all__`` will be included.  When False [default]: the ``__all__``
 attribute is ignored. :ghpull:`1529`.
 
 
 Improvements to the Qt console
 ------------------------------
 
 The Qt console continues to receive improvements and refinements, despite the
 fact that it is by now a fairly mature and robust component.  Lots of small
 polish has gone into it, here are a few highlights:
 
 * A number of changes were made to the underlying code for easier integration
   into other projects such as Spyder_ (:ghpull:`2007`, :ghpull:`2024`).
 
 * Improved menus with a new Magic menu that is organized by magic groups (this
   was made possible by the reorganization of the magic system
   internals). :ghpull:`1782`.
 
 * Allow for restarting kernels without clearing the qtconsole, while leaving a
   visible indication that the kernel has restarted. :ghpull:`1681`.
   
 * Allow the native display of jpeg images in the qtconsole. :ghpull:`1643`.
 
 .. _spyder: https://code.google.com/p/spyderlib
 
 
   
 Parallel
 --------
 
 The parallel tools have been improved and fine-tuned on multiple fronts.  Now,
 the creation of an :class:`IPython.parallel.Client` object automatically
 activates a line and cell magic function ``px`` that sends its code to all the
 engines. Further magics can be easily created with the :meth:`.Client.activate`
 method, to conveniently execute code on any subset of engines. :ghpull:`1893`.
 
 The ``%%px`` cell magic can also be given an optional targets argument, as well
 as a ``--out`` argument for storing its output.
 
 A new magic has also been added, ``%pxconfig``, that lets you configure various
 defaults of the parallel magics.  As usual, type  ``%pxconfig?`` for details.
 
 The exception reporting in parallel contexts has been improved to be easier to
 read.  Now, IPython directly reports the remote exceptions without showing any
 of the internal execution parts:
 
 .. image::  ../_images/ipy_013_par_tb.png
     :width: 460px
     :alt: Improved parallel exceptions.
     :align: center
     :target: ../_images/ipy_013_par_tb.png
 
 The parallel tools now default to using ``NoDB`` as the storage backend for
 intermediate results.  This means that the default usage case will have a
 significantly reduced memory footprint, though certain advanced features are
-not available with this backend.  For more details, see :ref:`parallel_db`.
+not available with this backend.
 
 The parallel magics now display all output, so you can do parallel plotting or
 other actions with complex display.  The ``px`` magic has now both line and cell
 modes, and in cell mode finer control has been added about how to collate
 output from multiple engines. :ghpull:`1768`.
 
 There have also been incremental improvements to the SSH launchers:
     
 * add to_send/fetch steps for moving connection files around.
   
 * add SSHProxyEngineSetLauncher, for invoking to `ipcluster engines` on a
   remote host. This can be used to start a set of engines via PBS/SGE/MPI
   *remotely*.
     
 This makes the SSHLauncher usable on machines without shared filesystems.
 
 A number of 'sugar' methods/properties were added to AsyncResult that are
 quite useful (:ghpull:`1548`) for everday work:
     
     * ``ar.wall_time`` = received - submitted
     * ``ar.serial_time`` = sum of serial computation time
     * ``ar.elapsed`` = time since submission (wall_time if done)
     * ``ar.progress`` = (int) number of sub-tasks that have completed
     * ``len(ar)`` = # of tasks
     * ``ar.wait_interactive()``: prints progress
     
 Added :meth:`.Client.spin_thread` / :meth:`~.Client.stop_spin_thread` for
 running spin in a background thread, to keep zmq queue clear.  This can be used
 to ensure that timing information is as accurate as possible (at the cost of
 having a background thread active).
 
 Set TaskScheduler.hwm default to 1 instead of 0.  1 has more
 predictable/intuitive behavior, if often slower, and thus a more logical
 default.  Users whose workloads require maximum throughput and are largely
 homogeneous in time per task can make the optimization themselves, but now the
 behavior will be less surprising to new users. :ghpull:`1294`.
 
 
 Kernel/Engine unification
 -------------------------
 
 This is mostly work 'under the hood', but it is actually a *major* achievement
 for the project that has deep implications in the long term: at last, we have
 unified the main object that executes as the user's interactive shell (which we
 refer to as the *IPython kernel*) with the objects that run in all the worker
 nodes of the parallel computing facilities (the *IPython engines*).  Ever since
 the first implementation of IPython's parallel code back in 2006, we had wanted
 to have these two roles be played by the same machinery, but a number of
 technical reasons had prevented that from being true.
 
 In this release we have now merged them, and this has a number of important
 consequences:
 
 * It is now possible to connect any of our clients (qtconsole or terminal
   console) to any individual parallel engine, with the *exact* behavior of
   working at a 'regular' IPython console/qtconsole.  This makes debugging,
   plotting, etc. in parallel scenarios vastly easier.
 
 * Parallel engines can always execute arbitrary 'IPython code', that is, code
   that has magics, shell extensions, etc.  In combination with the ``%%px``
   magics, it is thus extremely natural for example to send to all engines a
   block of Cython or R code to be executed via the new Cython and R magics. For
   example, this snippet would send the R block to all active engines in a
   cluster::
 
     %%px
     %%R
     ... R code goes here
   
 * It is possible to embed not only an interactive shell with the
   :func:`IPython.embed` call as always, but now you can also embed a *kernel*
   with :func:`IPython.embed_kernel()`.  Embedding an IPython kernel in an
   application is useful when you want to use :func:`IPython.embed` but don't
   have a terminal attached on stdin and stdout.
 
 * The new :func:`IPython.parallel.bind_kernel` allows you to promote Engines to
   listening Kernels, and connect QtConsoles to an Engine and debug it
   directly.
 
 In addition, having a single core object through our entire architecture also
 makes the project conceptually cleaner, easier to maintain and more robust.
 This took a lot of work to get in place, but we are thrilled to have this major
 piece of architecture finally where we'd always wanted it to be.
   
 
 Official Public API
 -------------------
 
 We have begun organizing our API for easier public use, with an eye towards an
 official IPython 1.0 release which will firmly maintain this API compatible for
 its entire lifecycle.  There is now an :mod:`IPython.display` module that
 aggregates all display routines, and the :mod:`traitlets.config` namespace has
 all public configuration tools.  We will continue improving our public API
 layout so that users only need to import names one level deeper than the main
 ``IPython`` package to access all public namespaces.
 
 
 IPython notebook file icons
 ---------------------------
 
 The directory ``docs/resources`` in the source distribution contains SVG and
 PNG versions of our file icons, as well as an ``Info.plist.example`` file with
 instructions to install them on Mac OSX.  This is a first draft of our icons,
 and we encourage contributions from users with graphic talent to improve them
-in the future:
-
-.. image:: ../../resources/ipynb_icon_128x128.png
-   :alt:  IPython notebook file icon.
+in the future.
 
 	  
 New top-level `locate` command
 ------------------------------
 
 Add `locate` entry points; these would be useful for quickly locating IPython
 directories and profiles from other (non-Python) applications. :ghpull:`1762`.
     
 Examples::
     
     $> ipython locate
     /Users/me/.ipython
   
     $> ipython locate profile foo
     /Users/me/.ipython/profile_foo
   
     $> ipython locate profile
     /Users/me/.ipython/profile_default
   
     $> ipython locate profile dne
     [ProfileLocate] Profile u'dne' not found.
 
 	
 Other new features and improvements
 -----------------------------------
 
 * **%install_ext**: A new magic function to install an IPython extension from
   a URL. E.g. ``%install_ext
   https://bitbucket.org/birkenfeld/ipython-physics/raw/default/physics.py``.
 
 * The ``%loadpy`` magic is no longer restricted to Python files, and has been
   renamed ``%load``. The old name remains as an alias.
 
 * New command line arguments will help external programs find IPython folders:
   ``ipython locate`` finds the user's IPython directory, and ``ipython locate
   profile foo`` finds the folder for the 'foo' profile (if it exists).
 
 * The :envvar:`IPYTHON_DIR` environment variable, introduced in the Great
   Reorganization of 0.11 and existing only in versions 0.11-0.13, has been
   deprecated. As described in :ghpull:`1167`, the complexity and confusion of
   migrating to this variable is not worth the aesthetic improvement. Please use
   the historical :envvar:`IPYTHONDIR` environment variable instead.
 
 * The default value of *interactivity* passed from
   :meth:`~IPython.core.interactiveshell.InteractiveShell.run_cell` to
   :meth:`~IPython.core.interactiveshell.InteractiveShell.run_ast_nodes`
   is now configurable.
 
 * New ``%alias_magic`` function to conveniently create aliases of existing
   magics, if you prefer to have shorter names for personal use.
 
 * We ship unminified versions of the JavaScript libraries we use, to better
   comply with Debian's packaging policies.
 
 * Simplify the information presented by ``obj?/obj??`` to eliminate a few
   redundant fields when possible.  :ghpull:`2038`.
 
 * Improved continuous integration for IPython.  We now have automated test runs
   on `Shining Panda <https://jenkins.shiningpanda.com/ipython>`_ and `Travis-CI
   <http://travis-ci.org/#!/ipython/ipython>`_, as well as `Tox support
   <http://tox.testrun.org>`_.
 
 * The `vim-ipython`_ functionality (externally developed) has been updated to
   the latest version.
 
 .. _vim-ipython: https://github.com/ivanov/vim-ipython
 
 * The ``%save`` magic now has a ``-f`` flag to force overwriting, which makes
   it much more usable in the notebook where it is not possible to reply to
   interactive questions from the kernel. :ghpull:`1937`.
 
 * Use dvipng to format sympy.Matrix, enabling display of matrices in the Qt
   console with the sympy printing extension. :ghpull:`1861`.
 
 * Our messaging protocol now has a reasonable test suite, helping ensure that
   we don't accidentally deviate from the spec and possibly break third-party
   applications that may have been using it.  We encourage users to contribute
   more stringent tests to this part of the test suite.  :ghpull:`1627`.
 
 * Use LaTeX to display, on output, various built-in types with the SymPy
   printing extension. :ghpull:`1399`.
 
 * Add Gtk3 event loop integration and example. :ghpull:`1588`.
 
 * ``clear_output`` improvements, which allow things like progress bars and other
   simple animations to work well in the notebook (:ghpull:`1563`):
     
     * `clear_output()` clears the line, even in terminal IPython, the QtConsole
       and plain Python as well, by printing `\r` to streams.
     
     * `clear_output()` avoids the flicker in the notebook by adding a delay,
       and firing immediately upon the next actual display message.
     
     * `display_javascript` hides its `output_area` element, so using display to
       run a bunch of javascript doesn't result in ever-growing vertical space.
 
 * Add simple support for running inside a virtualenv.  While this doesn't
   supplant proper installation (as users should do), it helps ad-hoc calling of
   IPython from inside a virtualenv. :ghpull:`1388`.
 
   
 Major Bugs fixed
 ----------------
 
 In this cycle, we have :ref:`closed over 740 issues <issues_list_013>`, but a
 few major ones merit special mention:
 
 * The ``%pastebin`` magic has been updated to point to gist.github.com, since
   unfortunately http://paste.pocoo.org has closed down. We also added a -d flag
   for the user to provide a gist description string. :ghpull:`1670`.
 
 * Fix ``%paste`` that would reject certain valid inputs. :ghpull:`1258`.
 
 * Fix sending and receiving of Numpy structured arrays (those with composite
   dtypes, often used as recarrays). :ghpull:`2034`.
 
 * Reconnect when the websocket connection closes unexpectedly. :ghpull:`1577`.
 
 * Fix truncated representation of objects in the debugger by showing at least
   80 characters' worth of information.  :ghpull:`1793`.
 
 * Fix logger to be Unicode-aware: logging could crash ipython if there was
   unicode in the input. :ghpull:`1792`.
 
 * Fix images missing from XML/SVG export in the Qt console. :ghpull:`1449`.
 
 * Fix deepreload on Python 3. :ghpull:`1625`, as well as having a much cleaner
   and more robust implementation of deepreload in general. :ghpull:`1457`.
 
 
 Backwards incompatible changes
 ------------------------------
 
 * The exception :exc:`IPython.core.error.TryNext` previously accepted
   arguments and keyword arguments to be passed to the next implementation
   of the hook. This feature was removed as it made error message propagation
   difficult and violated the principle of loose coupling.

tools/github_stats.py

@@ -1,232 +1,232 b''
 #!/usr/bin/env python
 """Simple tools to query github.com and gather stats about issues.
 
 To generate a report for IPython 2.0, run:
 
     python github_stats.py --milestone 2.0 --since-tag rel-1.0.0
 """
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import print_function
 
 import codecs
 import sys
 
 from argparse import ArgumentParser
 from datetime import datetime, timedelta
 from subprocess import check_output
 
 from gh_api import (
     get_paged_request, make_auth_header, get_pull_request, is_pull_request,
     get_milestone_id, get_issues_list, get_authors,
 )
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 ISO8601 = "%Y-%m-%dT%H:%M:%SZ"
 PER_PAGE = 100
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 def round_hour(dt):
     return dt.replace(minute=0,second=0,microsecond=0)
 
 def _parse_datetime(s):
     """Parse dates in the format returned by the Github API."""
     if s:
         return datetime.strptime(s, ISO8601)
     else:
         return datetime.fromtimestamp(0)
 
 def issues2dict(issues):
     """Convert a list of issues to a dict, keyed by issue number."""
     idict = {}
     for i in issues:
         idict[i['number']] = i
     return idict
 
 def split_pulls(all_issues, project="ipython/ipython"):
     """split a list of closed issues into non-PR Issues and Pull Requests"""
     pulls = []
     issues = []
     for i in all_issues:
         if is_pull_request(i):
             pull = get_pull_request(project, i['number'], auth=True)
             pulls.append(pull)
         else:
             issues.append(i)
     return issues, pulls
 
 
 def issues_closed_since(period=timedelta(days=365), project="ipython/ipython", pulls=False):
     """Get all issues closed since a particular point in time. period
     can either be a datetime object, or a timedelta object. In the
     latter case, it is used as a time before the present.
     """
 
     which = 'pulls' if pulls else 'issues'
 
     if isinstance(period, timedelta):
         since = round_hour(datetime.utcnow() - period)
     else:
         since = period
     url = "https://api.github.com/repos/%s/%s?state=closed&sort=updated&since=%s&per_page=%i" % (project, which, since.strftime(ISO8601), PER_PAGE)
     allclosed = get_paged_request(url, headers=make_auth_header())
     
     filtered = [ i for i in allclosed if _parse_datetime(i['closed_at']) > since ]
     if pulls:
         filtered = [ i for i in filtered if _parse_datetime(i['merged_at']) > since ]
         # filter out PRs not against master (backports)
         filtered = [ i for i in filtered if i['base']['ref'] == 'master' ]
     else:
         filtered = [ i for i in filtered if not is_pull_request(i) ]
     
     return filtered
 
 
 def sorted_by_field(issues, field='closed_at', reverse=False):
     """Return a list of issues sorted by closing date date."""
     return sorted(issues, key = lambda i:i[field], reverse=reverse)
 
 
 def report(issues, show_urls=False):
     """Summary report about a list of issues, printing number and title."""
     if show_urls:
         for i in issues:
             role = 'ghpull' if 'merged_at' in i else 'ghissue'
             print(u'* :%s:`%d`: %s' % (role, i['number'],
                                         i['title'].replace(u'`', u'``')))
     else:
         for i in issues:
             print(u'* %d: %s' % (i['number'], i['title'].replace(u'`', u'``')))
 
 #-----------------------------------------------------------------------------
 # Main script
 #-----------------------------------------------------------------------------
 
 if __name__ == "__main__":
     # deal with unicode
     if sys.version_info < (3,):
         sys.stdout = codecs.getwriter('utf8')(sys.stdout)
     
     # Whether to add reST urls for all issues in printout.
     show_urls = True
     
     parser = ArgumentParser()
     parser.add_argument('--since-tag', type=str,
         help="The git tag to use for the starting point (typically the last major release)."
     )
     parser.add_argument('--milestone', type=str,
         help="The GitHub milestone to use for filtering issues [optional]."
     )
     parser.add_argument('--days', type=int,
         help="The number of days of data to summarize (use this or --since-tag)."
     )
     parser.add_argument('--project', type=str, default="ipython/ipython",
         help="The project to summarize."
     )
     parser.add_argument('--links', action='store_true', default=False,
         help="Include links to all closed Issues and PRs in the output."
     )
     
     opts = parser.parse_args()
     tag = opts.since_tag
     
     # set `since` from days or git tag
     if opts.days:
         since = datetime.utcnow() - timedelta(days=opts.days)
     else:
         if not tag:
             tag = check_output(['git', 'describe', '--abbrev=0']).strip().decode('utf8')
         cmd = ['git', 'log', '-1', '--format=%ai', tag]
         tagday, tz = check_output(cmd).strip().decode('utf8').rsplit(' ', 1)
         since = datetime.strptime(tagday, "%Y-%m-%d %H:%M:%S")
         h = int(tz[1:3])
         m = int(tz[3:])
         td = timedelta(hours=h, minutes=m)
         if tz[0] == '-':
             since += td
         else:
             since -= td
     
     since = round_hour(since)
     
     milestone = opts.milestone
     project = opts.project
 
     print("fetching GitHub stats since %s (tag: %s, milestone: %s)" % (since, tag, milestone), file=sys.stderr)
     if milestone:
         milestone_id = get_milestone_id(project=project, milestone=milestone,
                 auth=True)
         issues_and_pulls = get_issues_list(project=project,
                 milestone=milestone_id,
                 state='closed',
                 auth=True,
         )
         issues, pulls = split_pulls(issues_and_pulls)
     else:
         issues = issues_closed_since(since, project=project, pulls=False)
         pulls = issues_closed_since(since, project=project, pulls=True)
     
     # For regular reports, it's nice to show them in reverse chronological order
     issues = sorted_by_field(issues, reverse=True)
     pulls = sorted_by_field(pulls, reverse=True)
     
     n_issues, n_pulls = map(len, (issues, pulls))
     n_total = n_issues + n_pulls
     
     # Print summary report we can directly include into release notes.
     
     print()
     since_day = since.strftime("%Y/%m/%d")
     today = datetime.today().strftime("%Y/%m/%d")
     print("GitHub stats for %s - %s (tag: %s)" % (since_day, today, tag))
     print()
     print("These lists are automatically generated, and may be incomplete or contain duplicates.")
     print()
     
     ncommits = 0
     all_authors = []
     if tag:
         # print git info, in addition to GitHub info:
         since_tag = tag+'..'
         cmd = ['git', 'log', '--oneline', since_tag]
         ncommits += len(check_output(cmd).splitlines())
         
         author_cmd = ['git', 'log', '--use-mailmap', "--format=* %aN", since_tag]
         all_authors.extend(check_output(author_cmd).decode('utf-8', 'replace').splitlines())
     
     pr_authors = []
     for pr in pulls:
         pr_authors.extend(get_authors(pr))
     ncommits = len(pr_authors) + ncommits - len(pulls)
     author_cmd = ['git', 'check-mailmap'] + pr_authors
     with_email = check_output(author_cmd).decode('utf-8', 'replace').splitlines()
     all_authors.extend([ u'* ' + a.split(' <')[0] for a in with_email ])
     unique_authors = sorted(set(all_authors), key=lambda s: s.lower())
 
     print("We closed %d issues and merged %d pull requests." % (n_issues, n_pulls))
     if milestone:
-        print("The full list can be seen `on GitHub <https://github.com/%s/milestone/%s>`"
+        print("The full list can be seen `on GitHub <https://github.com/%s/milestone/%s>`__"
             % (project, milestone)
         )
     
     print()
     print("The following %i authors contributed %i commits." % (len(unique_authors), ncommits))
     print()
     print('\n'.join(unique_authors))
     
     if opts.links:
         print()
         print("GitHub issues and pull requests:")
         print()
         print('Pull Requests (%d):\n' % n_pulls)
         report(pulls, show_urls)
         print()
         print('Issues (%d):\n' % n_issues)
         report(issues, show_urls)