Fix documentation typos

Found via `codespell`

IPython/lib/guisupport.py

@@ -1,155 +1,155 b''
 # coding: utf-8
 """
 Support for creating GUI apps and starting event loops.
 
-IPython's GUI integration allows interative plotting and GUI usage in IPython
+IPython's GUI integration allows interactive plotting and GUI usage in IPython
 session. IPython has two different types of GUI integration:
 
 1. The terminal based IPython supports GUI event loops through Python's
    PyOS_InputHook. PyOS_InputHook is a hook that Python calls periodically
    whenever raw_input is waiting for a user to type code. We implement GUI
    support in the terminal by setting PyOS_InputHook to a function that
    iterates the event loop for a short while. It is important to note that
    in this situation, the real GUI event loop is NOT run in the normal
    manner, so you can't use the normal means to detect that it is running.
 2. In the two process IPython kernel/frontend, the GUI event loop is run in
    the kernel. In this case, the event loop is run in the normal manner by
    calling the function or method of the GUI toolkit that starts the event
    loop.
 
 In addition to starting the GUI event loops in one of these two ways, IPython
 will *always* create an appropriate GUI application object when GUi
 integration is enabled.
 
 If you want your GUI apps to run in IPython you need to do two things:
 
 1. Test to see if there is already an existing main application object. If
    there is, you should use it. If there is not an existing application object
    you should create one.
 2. Test to see if the GUI event loop is running. If it is, you should not
    start it. If the event loop is not running you may start it.
 
 This module contains functions for each toolkit that perform these things
 in a consistent manner. Because of how PyOS_InputHook runs the event loop
 you cannot detect if the event loop is running using the traditional calls
 (such as ``wx.GetApp.IsMainLoopRunning()`` in wxPython). If PyOS_InputHook is
 set These methods will return a false negative. That is, they will say the
 event loop is not running, when is actually is. To work around this limitation
 we proposed the following informal protocol:
 
 * Whenever someone starts the event loop, they *must* set the ``_in_event_loop``
   attribute of the main application object to ``True``. This should be done
   regardless of how the event loop is actually run.
 * Whenever someone stops the event loop, they *must* set the ``_in_event_loop``
   attribute of the main application object to ``False``.
 * If you want to see if the event loop is running, you *must* use ``hasattr``
   to see if ``_in_event_loop`` attribute has been set. If it is set, you
   *must* use its value. If it has not been set, you can query the toolkit
   in the normal manner.
 * If you want GUI support and no one else has created an application or
   started the event loop you *must* do this. We don't want projects to
   attempt to defer these things to someone else if they themselves need it.
 
 The functions below implement this logic for each GUI toolkit. If you need
 to create custom application subclasses, you will likely have to modify this
 code for your own purposes. This code can be copied into your own project
 so you don't have to depend on IPython.
 
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from IPython.core.getipython import get_ipython
 
 #-----------------------------------------------------------------------------
 # wx
 #-----------------------------------------------------------------------------
 
 def get_app_wx(*args, **kwargs):
     """Create a new wx app or return an exiting one."""
     import wx
     app = wx.GetApp()
     if app is None:
         if 'redirect' not in kwargs:
             kwargs['redirect'] = False
         app = wx.PySimpleApp(*args, **kwargs)
     return app
 
 def is_event_loop_running_wx(app=None):
     """Is the wx event loop running."""
     # New way: check attribute on shell instance
     ip = get_ipython()
     if ip is not None:
         if ip.active_eventloop and ip.active_eventloop == 'wx':
             return True
         # Fall through to checking the application, because Wx has a native way
         # to check if the event loop is running, unlike Qt.
 
     # Old way: check Wx application
     if app is None:
         app = get_app_wx()
     if hasattr(app, '_in_event_loop'):
         return app._in_event_loop
     else:
         return app.IsMainLoopRunning()
 
 def start_event_loop_wx(app=None):
     """Start the wx event loop in a consistent manner."""
     if app is None:
         app = get_app_wx()
     if not is_event_loop_running_wx(app):
         app._in_event_loop = True
         app.MainLoop()
         app._in_event_loop = False
     else:
         app._in_event_loop = True
 
 #-----------------------------------------------------------------------------
 # qt4
 #-----------------------------------------------------------------------------
 
 def get_app_qt4(*args, **kwargs):
     """Create a new qt4 app or return an existing one."""
     from IPython.external.qt_for_kernel import QtGui
     app = QtGui.QApplication.instance()
     if app is None:
         if not args:
             args = ([''],)
         app = QtGui.QApplication(*args, **kwargs)
     return app
 
 def is_event_loop_running_qt4(app=None):
     """Is the qt4 event loop running."""
     # New way: check attribute on shell instance
     ip = get_ipython()
     if ip is not None:
         return ip.active_eventloop and ip.active_eventloop.startswith('qt')
 
     # Old way: check attribute on QApplication singleton
     if app is None:
         app = get_app_qt4([''])
     if hasattr(app, '_in_event_loop'):
         return app._in_event_loop
     else:
         # Does qt4 provide a other way to detect this?
         return False
 
 def start_event_loop_qt4(app=None):
     """Start the qt4 event loop in a consistent manner."""
     if app is None:
         app = get_app_qt4([''])
     if not is_event_loop_running_qt4(app):
         app._in_event_loop = True
         app.exec_()
         app._in_event_loop = False
     else:
         app._in_event_loop = True
 
 #-----------------------------------------------------------------------------
 # Tk
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # gtk
 #-----------------------------------------------------------------------------

IPython/utils/text.py

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

docs/README.rst

@@ -1,64 +1,64 b''
 IPython Documentation
 ---------------------
 
 This directory contains the majority of the documentation for IPython.
 
 
 Deploy docs
 -----------
 
 Documentation is automatically deployed on ReadTheDocs on every push or merged
 Pull requests.
 
 
 Requirements
 ------------
 
 The documentation must be built using Python 3.
 
 In additions to :ref:`devinstall`,
 the following tools are needed to build the documentation:
 
  - sphinx
  - sphinx_rtd_theme
  - docrepr
 
 In a conda environment, or a Python 3 ``venv``, you should be able to run::
 
   cd ipython
   pip install -U -r docs/requirements.txt
 
 
 Build Commands
 --------------
 
 The documentation gets built using ``make``, and comes in several flavors.
 
 ``make html`` - build the API and narrative documentation web pages, this is
 the default ``make`` target, so running just ``make`` is equivalent to ``make
 html``.
 
 ``make html_noapi`` - same as above, but without running the auto-generated API
 docs. When you are working on the narrative documentation, the most time
 consuming portion  of the build process is the processing and rending of the
 API documentation. This build target skips that.
 
 ``make pdf`` will compile a pdf from the documentation.
 
 You can run ``make help`` to see information on all possible make targets.
 
 To save time,
-the make targets above only proceess the files that have been changed since the
+the make targets above only process the files that have been changed since the
 previous docs build.
 To remove the previous docs build you can use ``make clean``.
 You can also combine ``clean`` with other `make` commands;
 for example,
 ``make clean html`` will do a complete rebuild of the docs or `make clean pdf` will do a complete build of the pdf.
 
 
 Continuous Integration
 ----------------------
 
 Documentation builds are included in the Travis-CI continuous integration process,
 so you can see the results of the docs build for any pull request at
 https://travis-ci.org/ipython/ipython/pull_requests.

examples/IPython Kernel/Script Magics.ipynb

@@ -1,466 +1,466 b''
 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Running Scripts from IPython"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "IPython has a `%%script` cell magic, which lets you run a cell in\n",
     "a subprocess of any interpreter on your system, such as: bash, ruby, perl, zsh, R, etc.\n",
     "\n",
     "It can even be a script of your own, which expects input on stdin."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "import sys"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Basic usage"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To use it, simply pass a path or shell command to the program you want to run on the `%%script` line,\n",
     "and the rest of the cell will be run by that script, and stdout/err from the subprocess are captured and displayed."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "hello from Python 2.7.9 (default, Jan 29 2015, 06:27:40) \n",
       "[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.56)]\n"
      ]
     }
    ],
    "source": [
     "%%script python2\n",
     "import sys\n",
     "print 'hello from Python %s' % sys.version"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "hello from Python: 3.4.2 |Continuum Analytics, Inc.| (default, Oct 21 2014, 17:42:20) \n",
       "[GCC 4.2.1 (Apple Inc. build 5577)]\n"
      ]
     }
    ],
    "source": [
     "%%script python3\n",
     "import sys\n",
     "print('hello from Python: %s' % sys.version)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "IPython also creates aliases for a few common interpreters, such as bash, ruby, perl, etc.\n",
     "\n",
     "These are all equivalent to `%%script <name>`"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Hello from Ruby 2.0.0\n"
      ]
     }
    ],
    "source": [
     "%%ruby\n",
     "puts \"Hello from Ruby #{RUBY_VERSION}\""
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "hello from /usr/local/bin/bash\n"
      ]
     }
    ],
    "source": [
     "%%bash\n",
     "echo \"hello from $BASH\""
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Capturing output"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can also capture stdout/err from these subprocesses into Python variables, instead of letting them go directly to stdout/err"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "hi, stdout\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
       "hello, stderr\n"
      ]
     }
    ],
    "source": [
     "%%bash\n",
     "echo \"hi, stdout\"\n",
     "echo \"hello, stderr\" >&2\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
     "%%bash --out output --err error\n",
     "echo \"hi, stdout\"\n",
     "echo \"hello, stderr\" >&2"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "hello, stderr\n",
       "\n",
       "hi, stdout\n",
       "\n"
      ]
     }
    ],
    "source": [
     "print(error)\n",
     "print(output)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Background Scripts"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "These scripts can be run in the background, by adding the `--bg` flag.\n",
     "\n",
     "When you do this, output is discarded unless you use the `--out/err`\n",
     "flags to store output as above."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 9,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Starting job # 0 in a separate thread.\n"
      ]
     }
    ],
    "source": [
     "%%ruby --bg --out ruby_lines\n",
     "for n in 1...10\n",
     "    sleep 1\n",
     "    puts \"line #{n}\"\n",
     "    STDOUT.flush\n",
     "end"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "When you do store output of a background thread, these are the stdout/err *pipes*,\n",
     "rather than the text of the output."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 10,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "data": {
       "text/plain": [
        "<open file '<fdopen>', mode 'rb' at 0x10a4be660>"
       ]
      },
      "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "ruby_lines"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 11,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "line 1\n",
       "line 2\n",
       "line 3\n",
       "line 4\n",
       "line 5\n",
       "line 6\n",
       "line 7\n",
       "line 8\n",
       "line 9\n",
       "\n"
      ]
     }
    ],
    "source": [
     "print(ruby_lines.read())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Arguments to subcommand"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can pass arguments the subcommand as well,\n",
     "such as  this example instructing Python to use integer division from Python 3:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "0.333333333333\n"
      ]
     }
    ],
    "source": [
     "%%script python2 -Qnew\n",
     "print 1/3"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "You can really specify *any* program for `%%script`,\n",
     "for instance here is a 'program' that echos the lines of stdin, with delays between each line."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 13,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Starting job # 2 in a separate thread.\n"
      ]
     }
    ],
    "source": [
     "%%script --bg --out bashout bash -c \"while read line; do echo $line; sleep 1; done\"\n",
     "line 1\n",
     "line 2\n",
     "line 3\n",
     "line 4\n",
     "line 5\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Remember, since the output of a background script is just the stdout pipe,\n",
     "you can read it as lines become available:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 14,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "0.0s: line 1\n",
       "1.0s: line 2\n",
       "2.0s: line 3\n",
       "3.0s: line 4\n",
       "4.0s: line 5\n"
      ]
     }
    ],
    "source": [
     "import time\n",
     "tic = time.time()\n",
     "line = True\n",
     "while True:\n",
     "    line = bashout.readline()\n",
     "    if not line:\n",
     "        break\n",
     "    sys.stdout.write(\"%.1fs: %s\" %(time.time()-tic, line))\n",
     "    sys.stdout.flush()\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Configuring the default ScriptMagics"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The list of aliased script magics is configurable.\n",
     "\n",
     "The default is to pick from a few common interpreters, and use them if found, but you can specify your own in ipython_config.py:\n",
     "\n",
     "    c.ScriptMagics.scripts = ['R', 'pypy', 'myprogram']\n",
     "\n",
-    "And if any of these programs do not apear on your default PATH, then you would also need to specify their location with:\n",
+    "And if any of these programs do not appear on your default PATH, then you would also need to specify their location with:\n",
     "\n",
     "    c.ScriptMagics.script_paths = {'myprogram': '/opt/path/to/myprogram'}"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.4.2"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 0
 }

tools/git-mpr.py

@@ -1,127 +1,127 b''
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """
 Usage:
     git-mpr [-h] [-l | -a] [pr-number [pr-number ...]]
 
 Type `git mpr -h` for details.
 """
 
 
 import io, os
 import argparse
 from subprocess import check_call, CalledProcessError
 
 import gh_api
 
 ipy_repository = 'git://github.com/ipython/ipython.git'
 gh_project = "ipython/ipython"
 not_merged = {}
 
 def merge_branch(repo, branch ):
     """try to merge the givent branch into the current one
     
     If something does not goes smoothly, merge is aborted
     
     Returns True if merge successful, False otherwise
     """
     # Delete the branch first
     try :
         check_call(['git', 'pull', repo, branch], stdin=io.open(os.devnull))
     except CalledProcessError :
         check_call(['git', 'merge', '--abort'])
         return False
     return True
 
     
 def git_new_branch(name):
     """Create a new branch with the given name and check it out.
     """
     check_call(['git', 'checkout', '-b', name])
 
     
 def merge_pr(num):
     """ try to merge the branch of PR `num` into current branch
     """
     # Get Github authorisation first, so that the user is prompted straight away
     # if their login is needed.
     
     pr = gh_api.get_pull_request(gh_project, num)
     repo = pr['head']['repo']['clone_url']
 
 
     branch = pr['head']['ref']
     mergeable = merge_branch(repo=repo, 
                  branch=branch,
               )
     if not mergeable :
         cmd = "git pull "+repo+" "+branch
         not_merged[str(num)] = cmd
         print("==============================================================================")
         print("Something went wrong merging this branch, you can try it manually by runngin :")
         print(cmd)
         print("==============================================================================")
         
     
 def main(*args):
     parser = argparse.ArgumentParser(
             description="""
                 Merge one or more github pull requests by their number. If any
                 one pull request can't be merged as is, its merge is ignored
                 and the process continues with the next ones (if any).
                 """
             )
 
     grp = parser.add_mutually_exclusive_group()
     grp.add_argument(
             '-l',
             '--list',
             action='store_const',
             const=True,
             help='list PR, their number and their mergeability')
     grp.add_argument('-a',
             '--merge-all',
             action='store_const',
             const=True ,
             help='try to merge as many PR as possible, one by one')
     parser.add_argument('merge',
             type=int,
             help="The pull request numbers",
             nargs='*',
             metavar='pr-number')
     args = parser.parse_args()
 
     if(args.list):
         pr_list = gh_api.get_pulls_list(gh_project)
         for pr in pr_list :
             mergeable = gh_api.get_pull_request(gh_project, pr['number'])['mergeable']
 
             ismgb = u"√" if mergeable else " "
             print(u"* #{number} [{ismgb}]:  {title}".format(
                 number=pr['number'],
                 title=pr['title'],
                 ismgb=ismgb))
 
     if(args.merge_all):
         branch_name = 'merge-' + '-'.join(str(pr['number']) for pr in pr_list)
         git_new_branch(branch_name)
         pr_list = gh_api.get_pulls_list(gh_project)
         for pr in pr_list :
             merge_pr(pr['number'])
 
 
     elif args.merge:
         branch_name = 'merge-' + '-'.join(map(str, args.merge))
         git_new_branch(branch_name)
         for num in args.merge :
             merge_pr(num)
 
     if not_merged :
         print('*************************************************************************************')
-        print('the following branch have not been merged automatically, considere doing it by hand :')
+        print('The following branch has not been merged automatically, consider doing it by hand   :')
         for num, cmd in not_merged.items() :
             print( "PR {num}: {cmd}".format(num=num, cmd=cmd))
         print('*************************************************************************************')
 
 if __name__ == '__main__':
     main()