Merging latest trunk.

I got a criss-cross merge in this and did merge --weave.  Hope this is
OK.

.bzrignore

@@ -0,0 +1,4 b''
+# IPython-specific files and pattersn that bzr should ignore
+docs/dist
+docs/build/*
+docs/source/api/generated

IPython/Extensions/ipy_pretty.py

@@ -0,0 +1,132 b''
+""" Use pretty.py for configurable pretty-printing.
+
+Register pretty-printers for types using ipy_pretty.for_type() or
+ipy_pretty.for_type_by_name(). For example, to use the example pretty-printer
+for numpy dtype objects, add the following to your ipy_user_conf.py::
+
+    from IPython.Extensions import ipy_pretty
+
+    ipy_pretty.activate()
+
+    # If you want to have numpy always imported anyways:
+    import numpy
+    ipy_pretty.for_type(numpy.dtype, ipy_pretty.dtype_pprinter)
+
+    # If you don't want to have numpy imported until it needs to be:
+    ipy_pretty.for_type_by_name('numpy', 'dtype', ipy_pretty.dtype_pprinter)
+"""
+
+import IPython.ipapi
+from IPython.genutils import Term
+
+from IPython.external import pretty
+
+ip = IPython.ipapi.get()
+
+
+#### Implementation ############################################################
+
+def pretty_result_display(self, arg):
+    """ Uber-pretty-printing display hook.
+
+    Called for displaying the result to the user.
+    """
+    
+    if ip.options.pprint:
+        verbose = getattr(ip.options, 'pretty_verbose', False)
+        out = pretty.pretty(arg, verbose=verbose)
+        if '\n' in out:
+            # So that multi-line strings line up with the left column of
+            # the screen, instead of having the output prompt mess up
+            # their first line.                
+            Term.cout.write('\n')
+        print >>Term.cout, out
+    else:
+        raise TryNext
+
+
+#### API #######################################################################
+
+# Expose the for_type and for_type_by_name functions for easier use.
+for_type = pretty.for_type
+for_type_by_name = pretty.for_type_by_name
+
+
+# FIXME: write deactivate(). We need a way to remove a hook.
+def activate():
+    """ Activate this extension.
+    """
+    ip.set_hook('result_display', pretty_result_display, priority=99)
+
+
+#### Example pretty-printers ###################################################
+
+def dtype_pprinter(obj, p, cycle):
+    """ A pretty-printer for numpy dtype objects.
+    """
+    if cycle:
+        return p.text('dtype(...)')
+    if obj.fields is None:
+        p.text(repr(obj))
+    else:
+        p.begin_group(7, 'dtype([')
+        for i, field in enumerate(obj.descr):
+            if i > 0:
+                p.text(',')
+                p.breakable()
+            p.pretty(field)
+        p.end_group(7, '])')
+
+
+#### Tests #####################################################################
+
+def test_pretty():
+    """
+    In [1]: from IPython.Extensions import ipy_pretty
+
+    In [2]: ipy_pretty.activate()
+
+    In [3]: class A(object):
+       ...:     def __repr__(self):
+       ...:         return 'A()'
+       ...:     
+       ...:     
+
+    In [4]: a = A()
+
+    In [5]: a
+    Out[5]: A()
+
+    In [6]: def a_pretty_printer(obj, p, cycle):
+       ...:     p.text('<A>')
+       ...:     
+       ...:     
+
+    In [7]: ipy_pretty.for_type(A, a_pretty_printer)
+
+    In [8]: a
+    Out[8]: <A>
+
+    In [9]: class B(object):
+       ...:     def __repr__(self):
+       ...:         return 'B()'
+       ...:     
+       ...:     
+
+    In [10]: B.__module__, B.__name__
+    Out[10]: ('__main__', 'B')
+
+    In [11]: def b_pretty_printer(obj, p, cycle):
+       ....:     p.text('<B>')
+       ....:     
+       ....:     
+
+    In [12]: ipy_pretty.for_type_by_name('__main__', 'B', b_pretty_printer)
+
+    In [13]: b = B()
+
+    In [14]: b
+    Out[14]: <B>
+    """
+    assert False, "This should only be doctested, not run."
+

IPython/external/pretty.py

@@ -0,0 +1,705 b''
+# -*- coding: utf-8 -*-
+"""
+    pretty
+    ~~
+
+    Python advanced pretty printer.  This pretty printer is intended to
+    replace the old `pprint` python module which does not allow developers
+    to provide their own pretty print callbacks.
+
+    This module is based on ruby's `prettyprint.rb` library by `Tanaka Akira`.
+
+
+    Example Usage
+    =============
+
+    To directly print the representation of an object use `pprint`::
+
+        from pretty import pprint
+        pprint(complex_object)
+
+    To get a string of the output use `pretty`::
+
+        from pretty import pretty
+        string = pretty(complex_object)
+
+
+    Extending
+    =========
+
+    The pretty library allows developers to add pretty printing rules for their
+    own objects.  This process is straightforward.  All you have to do is to
+    add a `__pretty__` method to your object and call the methods on the
+    pretty printer passed::
+
+        class MyObject(object):
+
+            def __pretty__(self, p, cycle):
+                ...
+
+    Depending on the python version you want to support you have two
+    possibilities.  The following list shows the python 2.5 version and the
+    compatibility one.
+
+
+    Here the example implementation of a `__pretty__` method for a list
+    subclass for python 2.5 and higher (python 2.5 requires the with statement
+    __future__ import)::
+
+        class MyList(list):
+
+            def __pretty__(self, p, cycle):
+                if cycle:
+                    p.text('MyList(...)')
+                else:
+                    with p.group(8, 'MyList([', '])'):
+                        for idx, item in enumerate(self):
+                            if idx:
+                                p.text(',')
+                                p.breakable()
+                            p.pretty(item)
+
+    The `cycle` parameter is `True` if pretty detected a cycle.  You *have* to
+    react to that or the result is an infinite loop.  `p.text()` just adds
+    non breaking text to the output, `p.breakable()` either adds a whitespace
+    or breaks here.  If you pass it an argument it's used instead of the
+    default space.  `p.pretty` prettyprints another object using the pretty print
+    method.
+
+    The first parameter to the `group` function specifies the extra indentation
+    of the next line.  In this example the next item will either be not
+    breaked (if the items are short enough) or aligned with the right edge of
+    the opening bracked of `MyList`.
+
+    If you want to support python 2.4 and lower you can use this code::
+
+        class MyList(list):
+
+            def __pretty__(self, p, cycle):
+                if cycle:
+                    p.text('MyList(...)')
+                else:
+                    p.begin_group(8, 'MyList([')
+                    for idx, item in enumerate(self):
+                        if idx:
+                            p.text(',')
+                            p.breakable()
+                        p.pretty(item)
+                    p.end_group(8, '])')
+
+    If you just want to indent something you can use the group function
+    without open / close parameters.  Under python 2.5 you can also use this
+    code::
+
+        with p.indent(2):
+            ...
+
+    Or under python2.4 you might want to modify ``p.indentation`` by hand but
+    this is rather ugly.
+
+    :copyright: 2007 by Armin Ronacher.
+                Portions (c) 2009 by Robert Kern.
+    :license: BSD License.
+"""
+import __future__
+import sys
+import types
+import re
+import datetime
+from StringIO import StringIO
+from collections import deque
+
+
+__all__ = ['pretty', 'pprint', 'PrettyPrinter', 'RepresentationPrinter',
+    'for_type', 'for_type_by_name']
+
+
+_re_pattern_type = type(re.compile(''))
+
+
+def pretty(obj, verbose=False, max_width=79, newline='\n'):
+    """
+    Pretty print the object's representation.
+    """
+    stream = StringIO()
+    printer = RepresentationPrinter(stream, verbose, max_width, newline)
+    printer.pretty(obj)
+    printer.flush()
+    return stream.getvalue()
+
+
+def pprint(obj, verbose=False, max_width=79, newline='\n'):
+    """
+    Like `pretty` but print to stdout.
+    """
+    printer = RepresentationPrinter(sys.stdout, verbose, max_width, newline)
+    printer.pretty(obj)
+    printer.flush()
+    sys.stdout.write(newline)
+    sys.stdout.flush()
+
+
+# add python2.5 context managers if we have the with statement feature
+if hasattr(__future__, 'with_statement'): exec '''
+from __future__ import with_statement
+from contextlib import contextmanager
+
+class _PrettyPrinterBase(object):
+
+    @contextmanager
+    def indent(self, indent):
+        """with statement support for indenting/dedenting."""
+        self.indentation += indent
+        try:
+            yield
+        finally:
+            self.indentation -= indent
+
+    @contextmanager
+    def group(self, indent=0, open='', close=''):
+        """like begin_group / end_group but for the with statement."""
+        self.begin_group(indent, open)
+        try:
+            with self.indent(indent):
+                yield
+        finally:
+            self.end_group(indent, close)
+'''
+else:
+    class _PrettyPrinterBase(object):
+
+        def _unsupported(self, *a, **kw):
+            """unsupported operation"""
+            raise RuntimeError('not available in this python version')
+        group = indent = _unsupported
+        del _unsupported
+
+
+class PrettyPrinter(_PrettyPrinterBase):
+    """
+    Baseclass for the `RepresentationPrinter` prettyprinter that is used to
+    generate pretty reprs of objects.  Contrary to the `RepresentationPrinter`
+    this printer knows nothing about the default pprinters or the `__pretty__`
+    callback method.
+    """
+
+    def __init__(self, output, max_width=79, newline='\n'):
+        self.output = output
+        self.max_width = max_width
+        self.newline = newline
+        self.output_width = 0
+        self.buffer_width = 0
+        self.buffer = deque()
+
+        root_group = Group(0)
+        self.group_stack = [root_group]
+        self.group_queue = GroupQueue(root_group)
+        self.indentation = 0
+
+    def _break_outer_groups(self):
+        while self.max_width < self.output_width + self.buffer_width:
+            group = self.group_queue.deq()
+            if not group:
+                return
+            while group.breakables:
+                x = self.buffer.popleft()
+                self.output_width = x.output(self.output, self.output_width)
+                self.buffer_width -= x.width
+            while self.buffer and isinstance(self.buffer[0], Text):
+                x = self.buffer.popleft()
+                self.output_width = x.output(self.output, self.output_width)
+                self.buffer_width -= x.width
+
+    def text(self, obj):
+        """Add literal text to the output."""
+        width = len(obj)
+        if self.buffer:
+            text = self.buffer[-1]
+            if not isinstance(text, Text):
+                text = Text()
+                self.buffer.append(text)
+            text.add(obj, width)
+            self.buffer_width += width
+            self._break_outer_groups()
+        else:
+            self.output.write(obj)
+            self.output_width += width
+
+    def breakable(self, sep=' '):
+        """
+        Add a breakable separator to the output.  This does not mean that it
+        will automatically break here.  If no breaking on this position takes
+        place the `sep` is inserted which default to one space.
+        """
+        width = len(sep)
+        group = self.group_stack[-1]
+        if group.want_break:
+            self.flush()
+            self.output.write(self.newline)
+            self.output.write(' ' * self.indentation)
+            self.output_width = self.indentation
+            self.buffer_width = 0
+        else:
+            self.buffer.append(Breakable(sep, width, self))
+            self.buffer_width += width
+            self._break_outer_groups()
+
+
+    def begin_group(self, indent=0, open=''):
+        """
+        Begin a group.  If you want support for python < 2.5 which doesn't has
+        the with statement this is the preferred way:
+
+            p.begin_group(1, '{')
+            ...
+            p.end_group(1, '}')
+
+        The python 2.5 expression would be this:
+
+            with p.group(1, '{', '}'):
+                ...
+
+        The first parameter specifies the indentation for the next line (usually
+        the width of the opening text), the second the opening text.  All
+        parameters are optional.
+        """
+        if open:
+            self.text(open)
+        group = Group(self.group_stack[-1].depth + 1)
+        self.group_stack.append(group)
+        self.group_queue.enq(group)
+        self.indentation += indent
+
+    def end_group(self, dedent=0, close=''):
+        """End a group. See `begin_group` for more details."""
+        self.indentation -= dedent
+        group = self.group_stack.pop()
+        if not group.breakables:
+            self.group_queue.remove(group)
+        if close:
+            self.text(close)
+
+    def flush(self):
+        """Flush data that is left in the buffer."""
+        for data in self.buffer:
+            self.output_width += data.output(self.output, self.output_width)
+        self.buffer.clear()
+        self.buffer_width = 0
+
+
+def _get_mro(obj_class):
+    """ Get a reasonable method resolution order of a class and its superclasses
+    for both old-style and new-style classes.
+    """
+    if not hasattr(obj_class, '__mro__'):
+        # Old-style class. Mix in object to make a fake new-style class.
+        try:
+            obj_class = type(obj_class.__name__, (obj_class, object), {})
+        except TypeError:
+            # Old-style extension type that does not descend from object.
+            # FIXME: try to construct a more thorough MRO.
+            mro = [obj_class]
+        else:
+            mro = obj_class.__mro__[1:-1]
+    else:
+        mro = obj_class.__mro__
+    return mro
+
+
+class RepresentationPrinter(PrettyPrinter):
+    """
+    Special pretty printer that has a `pretty` method that calls the pretty
+    printer for a python object.
+
+    This class stores processing data on `self` so you must *never* use
+    this class in a threaded environment.  Always lock it or reinstanciate
+    it.
+
+    Instances also have a verbose flag callbacks can access to control their
+    output.  For example the default instance repr prints all attributes and
+    methods that are not prefixed by an underscore if the printer is in
+    verbose mode.
+    """
+
+    def __init__(self, output, verbose=False, max_width=79, newline='\n'):
+        PrettyPrinter.__init__(self, output, max_width, newline)
+        self.verbose = verbose
+        self.stack = []
+
+    def pretty(self, obj):
+        """Pretty print the given object."""
+        obj_id = id(obj)
+        cycle = obj_id in self.stack
+        self.stack.append(obj_id)
+        self.begin_group()
+        try:
+            obj_class = getattr(obj, '__class__', None) or type(obj)
+            if hasattr(obj_class, '__pretty__'):
+                return obj_class.__pretty__(obj, self, cycle)
+            try:
+                printer = _singleton_pprinters[obj_id]
+            except (TypeError, KeyError):
+                pass
+            else:
+                return printer(obj, self, cycle)
+            for cls in _get_mro(obj_class):
+                if cls in _type_pprinters:
+                    return _type_pprinters[cls](obj, self, cycle)
+                else:
+                    printer = self._in_deferred_types(cls)
+                    if printer is not None:
+                        return printer(obj, self, cycle)
+            return _default_pprint(obj, self, cycle)
+        finally:
+            self.end_group()
+            self.stack.pop()
+
+    def _in_deferred_types(self, cls):
+        """
+        Check if the given class is specified in the deferred type registry.
+
+        Returns the printer from the registry if it exists, and None if the
+        class is not in the registry. Successful matches will be moved to the
+        regular type registry for future use.
+        """
+        mod = getattr(cls, '__module__', None)
+        name = getattr(cls, '__name__', None)
+        key = (mod, name)
+        printer = None
+        if key in _deferred_type_pprinters:
+            # Move the printer over to the regular registry.
+            printer = _deferred_type_pprinters.pop(key)
+            _type_pprinters[cls] = printer
+        return printer
+
+
+
+class Printable(object):
+
+    def output(self, stream, output_width):
+        return output_width
+
+
+class Text(Printable):
+
+    def __init__(self):
+        self.objs = []
+        self.width = 0
+
+    def output(self, stream, output_width):
+        for obj in self.objs:
+            stream.write(obj)
+        return output_width + self.width
+
+    def add(self, obj, width):
+        self.objs.append(obj)
+        self.width += width
+
+
+class Breakable(Printable):
+
+    def __init__(self, seq, width, pretty):
+        self.obj = seq
+        self.width = width
+        self.pretty = pretty
+        self.indentation = pretty.indentation
+        self.group = pretty.group_stack[-1]
+        self.group.breakables.append(self)
+
+    def output(self, stream, output_width):
+        self.group.breakables.popleft()
+        if self.group.want_break:
+            stream.write(self.pretty.newline)
+            stream.write(' ' * self.indentation)
+            return self.indentation
+        if not self.group.breakables:
+            self.pretty.group_queue.remove(self.group)
+        stream.write(self.obj)
+        return output_width + self.width
+
+
+class Group(Printable):
+
+    def __init__(self, depth):
+        self.depth = depth
+        self.breakables = deque()
+        self.want_break = False
+
+
+class GroupQueue(object):
+
+    def __init__(self, *groups):
+        self.queue = []
+        for group in groups:
+            self.enq(group)
+
+    def enq(self, group):
+        depth = group.depth
+        while depth > len(self.queue) - 1:
+            self.queue.append([])
+        self.queue[depth].append(group)
+
+    def deq(self):
+        for stack in self.queue:
+            for idx, group in enumerate(reversed(stack)):
+                if group.breakables:
+                    del stack[idx]
+                    group.want_break = True
+                    return group
+            for group in stack:
+                group.want_break = True
+            del stack[:]
+
+    def remove(self, group):
+        try:
+            self.queue[group.depth].remove(group)
+        except ValueError:
+            pass
+
+
+_baseclass_reprs = (object.__repr__, types.InstanceType.__repr__)
+
+
+def _default_pprint(obj, p, cycle):
+    """
+    The default print function.  Used if an object does not provide one and
+    it's none of the builtin objects.
+    """
+    klass = getattr(obj, '__class__', None) or type(obj)
+    if getattr(klass, '__repr__', None) not in _baseclass_reprs:
+        # A user-provided repr.
+        p.text(repr(obj))
+        return
+    p.begin_group(1, '<')
+    p.pretty(klass)
+    p.text(' at 0x%x' % id(obj))
+    if cycle:
+        p.text(' ...')
+    elif p.verbose:
+        first = True
+        for key in dir(obj):
+            if not key.startswith('_'):
+                try:
+                    value = getattr(obj, key)
+                except AttributeError:
+                    continue
+                if isinstance(value, types.MethodType):
+                    continue
+                if not first:
+                    p.text(',')
+                p.breakable()
+                p.text(key)
+                p.text('=')
+                step = len(key) + 1
+                p.indentation += step
+                p.pretty(value)
+                p.indentation -= step
+                first = False
+    p.end_group(1, '>')
+
+
+def _seq_pprinter_factory(start, end):
+    """
+    Factory that returns a pprint function useful for sequences.  Used by
+    the default pprint for tuples, dicts, lists, sets and frozensets.
+    """
+    def inner(obj, p, cycle):
+        if cycle:
+            return p.text(start + '...' + end)
+        step = len(start)
+        p.begin_group(step, start)
+        for idx, x in enumerate(obj):
+            if idx:
+                p.text(',')
+                p.breakable()
+            p.pretty(x)
+        if len(obj) == 1 and type(obj) is tuple:
+            # Special case for 1-item tuples.
+            p.text(',')
+        p.end_group(step, end)
+    return inner
+
+
+def _dict_pprinter_factory(start, end):
+    """
+    Factory that returns a pprint function used by the default pprint of
+    dicts and dict proxies.
+    """
+    def inner(obj, p, cycle):
+        if cycle:
+            return p.text('{...}')
+        p.begin_group(1, start)
+        keys = obj.keys()
+        try:
+            keys.sort()
+        except Exception, e:
+            # Sometimes the keys don't sort.
+            pass
+        for idx, key in enumerate(keys):
+            if idx:
+                p.text(',')
+                p.breakable()
+            p.pretty(key)
+            p.text(': ')
+            p.pretty(obj[key])
+        p.end_group(1, end)
+    return inner
+
+
+def _super_pprint(obj, p, cycle):
+    """The pprint for the super type."""
+    p.begin_group(8, '<super: ')
+    p.pretty(obj.__self_class__)
+    p.text(',')
+    p.breakable()
+    p.pretty(obj.__self__)
+    p.end_group(8, '>')
+
+
+def _re_pattern_pprint(obj, p, cycle):
+    """The pprint function for regular expression patterns."""
+    p.text('re.compile(')
+    pattern = repr(obj.pattern)
+    if pattern[:1] in 'uU':
+        pattern = pattern[1:]
+        prefix = 'ur'
+    else:
+        prefix = 'r'
+    pattern = prefix + pattern.replace('\\\\', '\\')
+    p.text(pattern)
+    if obj.flags:
+        p.text(',')
+        p.breakable()
+        done_one = False
+        for flag in ('TEMPLATE', 'IGNORECASE', 'LOCALE', 'MULTILINE', 'DOTALL',
+            'UNICODE', 'VERBOSE', 'DEBUG'):
+            if obj.flags & getattr(re, flag):
+                if done_one:
+                    p.text('|')
+                p.text('re.' + flag)
+                done_one = True
+    p.text(')')
+
+
+def _type_pprint(obj, p, cycle):
+    """The pprint for classes and types."""
+    if obj.__module__ in ('__builtin__', 'exceptions'):
+        name = obj.__name__
+    else:
+        name = obj.__module__ + '.' + obj.__name__
+    p.text(name)
+
+
+def _repr_pprint(obj, p, cycle):
+    """A pprint that just redirects to the normal repr function."""
+    p.text(repr(obj))
+
+
+def _function_pprint(obj, p, cycle):
+    """Base pprint for all functions and builtin functions."""
+    if obj.__module__ in ('__builtin__', 'exceptions') or not obj.__module__:
+        name = obj.__name__
+    else:
+        name = obj.__module__ + '.' + obj.__name__
+    p.text('<function %s>' % name)
+
+
+def _exception_pprint(obj, p, cycle):
+    """Base pprint for all exceptions."""
+    if obj.__class__.__module__ == 'exceptions':
+        name = obj.__class__.__name__
+    else:
+        name = '%s.%s' % (
+            obj.__class__.__module__,
+            obj.__class__.__name__
+        )
+    step = len(name) + 1
+    p.begin_group(step, '(')
+    for idx, arg in enumerate(getattr(obj, 'args', ())):
+        if idx:
+            p.text(',')
+            p.breakable()
+        p.pretty(arg)
+    p.end_group(step, ')')
+
+
+#: the exception base
+try:
+    _exception_base = BaseException
+except NameError:
+    _exception_base = Exception
+
+
+#: printers for builtin types
+_type_pprinters = {
+    int:                        _repr_pprint,
+    long:                       _repr_pprint,
+    float:                      _repr_pprint,
+    str:                        _repr_pprint,
+    unicode:                    _repr_pprint,
+    tuple:                      _seq_pprinter_factory('(', ')'),
+    list:                       _seq_pprinter_factory('[', ']'),
+    dict:                       _dict_pprinter_factory('{', '}'),
+    types.DictProxyType:        _dict_pprinter_factory('<dictproxy {', '}>'),
+    set:                        _seq_pprinter_factory('set([', '])'),
+    frozenset:                  _seq_pprinter_factory('frozenset([', '])'),
+    super:                      _super_pprint,
+    _re_pattern_type:           _re_pattern_pprint,
+    type:                       _type_pprint,
+    types.ClassType:            _type_pprint,
+    types.FunctionType:         _function_pprint,
+    types.BuiltinFunctionType:  _function_pprint,
+    types.SliceType:            _repr_pprint,
+    types.MethodType:           _repr_pprint,
+    xrange:                     _repr_pprint,
+    datetime.datetime:          _repr_pprint,
+    datetime.timedelta:         _repr_pprint,
+    _exception_base:            _exception_pprint
+}
+
+#: printers for types specified by name
+_deferred_type_pprinters = {
+}
+
+def for_type(typ, func):
+    """
+    Add a pretty printer for a given type.
+    """
+    oldfunc = _type_pprinters.get(typ, None)
+    if func is not None:
+        # To support easy restoration of old pprinters, we need to ignore Nones.
+        _type_pprinters[typ] = func
+    return oldfunc
+
+def for_type_by_name(type_module, type_name, func):
+    """
+    Add a pretty printer for a type specified by the module and name of a type
+    rather than the type object itself.
+    """
+    key = (type_module, type_name)
+    oldfunc = _deferred_type_pprinters.get(key, None)
+    if func is not None:
+        # To support easy restoration of old pprinters, we need to ignore Nones.
+        _deferred_type_pprinters[key] = func
+    return oldfunc
+
+
+#: printers for the default singletons
+_singleton_pprinters = dict.fromkeys(map(id, [None, True, False, Ellipsis,
+                                      NotImplemented]), _repr_pprint)
+
+
+if __name__ == '__main__':
+    from random import randrange
+    class Foo(object):
+        def __init__(self):
+            self.foo = 1
+            self.bar = re.compile(r'\s+')
+            self.blub = dict.fromkeys(range(30), randrange(1, 40))
+            self.hehe = 23424.234234
+            self.list = ["blub", "blah", self]
+
+        def get_foo(self):
+            print "foo"
+
+    pprint(Foo(), verbose=True)

IPython/tests/obj_del.py

@@ -0,0 +1,34 b''
+"""Test code for https://bugs.launchpad.net/ipython/+bug/239054
+
+WARNING: this script exits IPython!  It MUST be run in a subprocess.
+
+When you run the following script from CPython it prints:
+__init__ is here
+__del__ is here
+
+and creates the __del__.txt file
+
+When you run it from IPython it prints:
+__init__ is here
+
+When you exit() or Exit from IPython neothing is printed and no file is created
+(the file thing is to make sure __del__ is really never called and not that
+just the output is eaten).
+
+Note that if you call %reset in IPython then everything is Ok.
+
+IPython should do the equivalent of %reset and release all the references it
+holds before exit. This behavior is important when working with binding objects
+that rely on __del__. If the current behavior has some use case then I suggest
+to add a configuration option to IPython to control it.
+"""
+import sys
+
+class A(object):
+    def __del__(self):
+      print 'object A deleted'
+
+a = A()
+
+# Now, we force an exit, the caller will check that the del printout was given
+_ip.IP.ask_exit()

IPython/tests/tclass.py

@@ -0,0 +1,26 b''
+"""Simple script to instantiate a class for testing %run"""
+
+import sys
+
+# An external test will check that calls to f() work after %run
+class foo: pass
+
+def f():
+    return foo()
+
+# We also want to ensure that while objects remain available for immediate
+# access, objects from *previous* runs of the same script get collected, to
+# avoid accumulating massive amounts of old references.
+class C(object):
+    def __init__(self,name):
+        self.name = name
+        
+    def __del__(self):
+        print 'Deleting object:',self.name
+
+try:
+    name = sys.argv[1]
+except IndexError:
+    pass
+else:
+    c = C(name)

IPython/tests/test_iplib.py

@@ -0,0 +1,17 b''
+"""Tests for the key iplib module, where the main ipython class is defined.
+"""
+
+import nose.tools as nt
+
+
+def test_reset():
+    """reset must clear most namespaces."""
+    ip = _ip.IP
+    ip.reset()  # first, it should run without error
+    # Then, check that most namespaces end up empty
+    for ns in ip.ns_refs_table:
+        if ns is ip.user_ns:
+            # The user namespace is reset with some data, so we can't check for
+            # it being empty
+            continue
+        nt.assert_equals(len(ns),0)

docs/autogen_api.py

@@ -0,0 +1,33 b''
+#!/usr/bin/env python
+"""Script to auto-generate our API docs.
+"""
+# stdlib imports
+import os
+import sys
+
+# local imports
+sys.path.append(os.path.abspath('sphinxext'))
+from apigen import ApiDocWriter
+
+#*****************************************************************************
+if __name__ == '__main__':
+    pjoin = os.path.join
+    package = 'IPython'
+    outdir = pjoin('source','api','generated')
+    docwriter = ApiDocWriter(package,rst_extension='.txt')
+    docwriter.package_skip_patterns += [r'\.fixes$',
+                                        r'\.externals$',
+                                        r'\.Extensions',
+                                        r'\.kernel.config',
+                                        r'\.attic',
+                                        ]
+    docwriter.module_skip_patterns += [ r'\.FakeModule',
+                                        r'\.cocoa',
+                                        r'\.ipdoctest',
+                                        r'\.Gnuplot',
+                                        ]
+    docwriter.write_api_docs(outdir)
+    docwriter.write_index(outdir, 'gen',
+                          relative_to = pjoin('source','api')
+                          )
+    print '%d files written' % len(docwriter.written_modules)

docs/source/api/index.txt

@@ -0,0 +1,12 b''
+.. _api-index:
+
+###################
+  The IPython API
+###################
+
+.. htmlonly::
+
+   :Release: |version|
+   :Date: |today|
+
+.. include:: generated/gen.txt

docs/source/development/coding_guide.txt

@@ -0,0 +1,141 b''
+==============
+ Coding guide
+==============
+
+
+Coding conventions
+==================
+
+In general, we'll try to follow the standard Python style conventions as
+described in Python's `PEP 8`_, the official Python Style Guide.
+
+.. _PEP 8: http://www.python.org/peps/pep-0008.html
+
+Other comments:
+
+- In a large file, top level classes and functions should be separated by 2-3
+  lines to make it easier to separate them visually.
+
+- Use 4 spaces for indentation, *never* use hard tabs.
+
+- Keep the ordering of methods the same in classes that have the same methods.
+  This is particularly true for classes that implement similar interfaces and
+  for interfaces that are similar.
+
+Naming conventions
+------------------
+
+In terms of naming conventions, we'll follow the guidelines of PEP 8.  Some of
+the existing code doesn't honor this perfectly, but for all new IPython code
+(and much existing code is being refactored), we'll use:
+
+- All ``lowercase`` module names.
+
+- ``CamelCase`` for class names.
+
+- ``lowercase_with_underscores`` for methods, functions, variables and
+  attributes.
+
+This may be confusing as some of the existing codebase uses a different
+convention (``lowerCamelCase`` for methods and attributes).  Slowly, we will
+move IPython over to the new convention, providing shadow names for backward
+compatibility in public interfaces.
+
+There are, however, some important exceptions to these rules.  In some cases,
+IPython code will interface with packages (Twisted, Wx, Qt) that use other
+conventions.  At some level this makes it impossible to adhere to our own
+standards at all times.  In particular, when subclassing classes that use other
+naming conventions, you must follow their naming conventions.  To deal with
+cases like this, we propose the following policy:
+
+- If you are subclassing a class that uses different conventions, use its
+  naming conventions throughout your subclass.  Thus, if you are creating a
+  Twisted Protocol class, used Twisted's
+  ``namingSchemeForMethodsAndAttributes.``
+
+- All IPython's official interfaces should use our conventions.  In some cases
+  this will mean that you need to provide shadow names (first implement
+  ``fooBar`` and then ``foo_bar = fooBar``).  We want to avoid this at all
+  costs, but it will probably be necessary at times.  But, please use this
+  sparingly!
+
+Implementation-specific *private* methods will use
+``_single_underscore_prefix``.  Names with a leading double underscore will
+*only* be used in special cases, as they makes subclassing difficult (such
+names are not easily seen by child classes).
+
+Occasionally some run-in lowercase names are used, but mostly for very short
+names or where we are implementing methods very similar to existing ones in a
+base class (like ``runlines()`` where ``runsource()`` and ``runcode()`` had
+established precedent).
+
+The old IPython codebase has a big mix of classes and modules prefixed with an
+explicit ``IP``. In Python this is mostly unnecessary, redundant and frowned
+upon, as namespaces offer cleaner prefixing. The only case where this approach
+is justified is for classes which are expected to be imported into external
+namespaces and a very generic name (like Shell) is too likely to clash with
+something else.  We'll need to revisit this issue as we clean up and refactor
+the code, but in general we should remove as many unnecessary ``IP``/``ip``
+prefixes as possible. However, if a prefix seems absolutely necessary the more
+specific ``IPY`` or ``ipy`` are preferred.
+
+
+.. _devel-testing:
+
+Testing system
+==============
+
+It is extremely important that all code contributed to IPython has tests. Tests
+should be written as unittests, doctests or as entities that the `Nose`_
+testing package will find. Regardless of how the tests are written, we will use
+`Nose`_ for discovering and running the tests. `Nose`_ will be required to run
+the IPython test suite, but will not be required to simply use IPython.
+
+.. _Nose: http://code.google.com/p/python-nose/
+
+Tests of `Twisted`__ using code should be written by subclassing the
+``TestCase`` class that comes with ``twisted.trial.unittest``. When this is
+done, `Nose`_ will be able to run the tests and the twisted reactor will be
+handled correctly.
+
+.. __: http://www.twistedmatrix.com
+
+Each subpackage in IPython should have its own ``tests`` directory that
+contains all of the tests for that subpackage. This allows each subpackage to
+be self-contained. If a subpackage has any dependencies beyond the Python
+standard library, the tests for that subpackage should be skipped if the
+dependencies are not found. This is very important so users don't get tests
+failing simply because they don't have dependencies.
+
+We also need to look into use Noses ability to tag tests to allow a more
+modular approach of running tests.
+
+.. _devel-config:
+
+Configuration system
+====================
+
+IPython uses `.ini`_ files for configuration purposes. This represents a huge
+improvement over the configuration system used in IPython. IPython works with
+these files using the `ConfigObj`_ package, which IPython includes as
+``ipython1/external/configobj.py``.
+
+Currently, we are using raw `ConfigObj`_ objects themselves. Each subpackage of
+IPython should contain a ``config`` subdirectory that contains all of the
+configuration information for the subpackage. To see how configuration
+information is defined (along with defaults) see at the examples in
+``ipython1/kernel/config`` and ``ipython1/core/config``. Likewise, to see how
+the configuration information is used, see examples in
+``ipython1/kernel/scripts/ipengine.py``.
+
+Eventually, we will add a new layer on top of the raw `ConfigObj`_ objects. We
+are calling this new layer, ``tconfig``, as it will use a `Traits`_-like
+validation model.  We won't actually use `Traits`_, but will implement
+something similar in pure Python.  But, even in this new system, we will still
+use `ConfigObj`_ and `.ini`_ files underneath the hood. Talk to Fernando if you
+are interested in working on this part of IPython. The current prototype of
+``tconfig`` is located in the IPython sandbox.
+
+.. _.ini: http://docs.python.org/lib/module-ConfigParser.html
+.. _ConfigObj: http://www.voidspace.org.uk/python/configobj.html
+.. _Traits: http://code.enthought.com/traits/

docs/source/development/doc_guide.txt

@@ -0,0 +1,103 b''
+.. _documenting-ipython:
+
+=====================
+ Documenting IPython
+=====================
+
+Standalone documentation
+========================
+
+All standalone documentation should be written in plain text (``.txt``) files
+using `reStructuredText`_ for markup and formatting. All such documentation
+should be placed in the top level directory ``docs`` of the IPython source
+tree. Or, when appropriate, a suitably named subdirectory should be used. The
+documentation in this location will serve as the main source for IPython
+documentation and all existing documentation should be converted to this
+format.
+
+The actual HTML and PDF docs are built using the Sphinx_ documentation
+generation tool.  Sphinx has been adopted as the default documentation tool for
+Python itself as of version 2.6, as well as by a number of projects that
+IPython is related with, such as numpy, scipy, matplotlib, sage and nipy.
+
+.. _reStructuredText: http://docutils.sourceforge.net/rst.html
+.. _Sphinx: http://sphinx.pocoo.org/
+
+
+The rest of this document is mostly taken from the `matploblib
+documentation`__; we are using a number of Sphinx tools and extensions written
+by the matplotlib team and will mostly follow their conventions, which are
+nicely spelled out in their guide.  What follows is thus a lightly adapted
+version of the matplotlib documentation guide, taken with permission from the
+MPL team.
+
+.. __: http://matplotlib.sourceforge.net/devel/documenting_mpl.html
+
+
+A bit of Python code::
+
+    for i in range(10):
+        print i,
+    print "A big number:",2**34
+
+An interactive Python session::
+
+    >>> from IPython import genutils
+    >>> genutils.get_ipython_dir()
+    '/home/fperez/.ipython'
+
+
+An IPython session:
+
+.. code-block:: ipython
+
+  In [7]: import IPython
+
+  In [8]: print "This IPython is version:",IPython.__version__
+  This IPython is version: 0.9.1
+
+  In [9]: 2+4
+  Out[9]: 6
+
+
+A bit of shell code:
+
+.. code-block:: bash
+
+    cd /tmp
+    echo "My home directory is: $HOME"
+    ls
+
+  
+Docstring format
+================
+
+Good docstrings are very important.  Unfortunately, Python itself only provides
+a rather loose standard for docstrings (`PEP 257`_), and there is no universally
+accepted convention for all the different parts of a complete docstring.
+However, the NumPy project has established a very reasonable standard, and has
+developed some tools to support the smooth inclusion of such docstrings in
+Sphinx-generated manuals.  Rather than inventing yet another pseudo-standard,
+IPython will be henceforth documented using the NumPy conventions; we carry
+copies of some of the NumPy support tools to remain self-contained, but share
+back upstream with NumPy any improvements or fixes we may make to the tools.
+
+The `NumPy documentation guidelines`_ contain detailed information on this
+standard, and for a quick overview, the NumPy `example docstring`_ is a useful
+read. 
+
+As in the past IPython used epydoc, currently many docstrings still use epydoc
+conventions.  We will update them as we go, but all new code should be fully
+documented using the NumPy standard.
+
+.. _PEP 257: http://www.python.org/peps/pep-0257.html
+.. _NumPy documentation guidelines: http://projects.scipy.org/numpy/wiki/CodingStyleGuidelines
+
+.. _example docstring: http://projects.scipy.org/numpy/browser/trunk/doc/EXAMPLE_DOCSTRING.txt
+
+Additional PEPs of interest regarding documentation of code.  While both of
+these were rejected, the ideas therein form much of the basis of docutils (the
+machinery to process reStructuredText):
+
+- `Docstring Processing System Framework <http://www.python.org/peps/pep-0256.html>`_
+- `Docutils Design Specification <http://www.python.org/peps/pep-0258.html>`_

docs/source/parallel/visionhpc.txt

@@ -0,0 +1,246 b''
+==================================
+ IPython/Vision Beam Pattern Demo
+==================================
+
+
+Installing and testing IPython at OSC systems
+=============================================
+
+All components were installed from source and I have my environment set up to
+include ~/usr/local in my various necessary paths ($PATH, $PYTHONPATH, etc).
+Other than a slow filesystem for unpacking tarballs, the install went without a
+hitch.  For each needed component, I just downloaded the source tarball,
+unpacked it via::
+
+  tar xzf (or xjf if it's bz2) filename.tar.{gz,bz2}
+
+and then installed them (including IPython itself) with::
+
+  cd dirname/  # path to unpacked tarball
+  python setup.py install --prefix=~/usr/local/
+
+The components I installed are listed below.  For each one I give the main
+project link as well as a direct one to the file I actually dowloaded and used.
+
+- nose, used for testing:
+http://somethingaboutorange.com/mrl/projects/nose/
+http://somethingaboutorange.com/mrl/projects/nose/nose-0.10.3.tar.gz
+
+- Zope interface, used to declare interfaces in twisted and ipython.  Note:
+you must get this from the page linked below and not fro the defaul
+one(http://www.zope.org/Products/ZopeInterface) because the latter has an
+older version, it hasn't been updated in a long time.  This pypi link has
+the current release (3.4.1 as of this writing):
+http://pypi.python.org/pypi/zope.interface
+http://pypi.python.org/packages/source/z/zope.interface/zope.interface-3.4.1.tar.gz
+
+- pyopenssl, security layer used by foolscap.  Note: version 0.7 *must* be
+used: 
+http://sourceforge.net/projects/pyopenssl/
+http://downloads.sourceforge.net/pyopenssl/pyOpenSSL-0.6.tar.gz?modtime=1212595285&big_mirror=0
+
+
+- Twisted, used for all networking:
+http://twistedmatrix.com/trac/wiki/Downloads
+http://tmrc.mit.edu/mirror/twisted/Twisted/8.1/Twisted-8.1.0.tar.bz2
+
+- Foolscap, used for managing connections securely:
+http://foolscap.lothar.com/trac
+http://foolscap.lothar.com/releases/foolscap-0.3.1.tar.gz
+
+
+- IPython itself:
+http://ipython.scipy.org/
+http://ipython.scipy.org/dist/ipython-0.9.1.tar.gz
+
+
+I then ran the ipython test suite via::
+
+  iptest -vv
+
+and it passed with only::
+
+    ======================================================================
+    ERROR: testGetResult_2
+    ----------------------------------------------------------------------
+    DirtyReactorAggregateError: Reactor was unclean.
+    Selectables:
+    <Negotiation #0 on 10105>
+
+    ----------------------------------------------------------------------
+    Ran 419 tests in 33.971s
+
+    FAILED (SKIP=4, errors=1)
+
+In three more runs of the test suite I was able to reproduce this error
+sometimes but not always; for now I think we can move on but we need to
+investigate further.  Especially if we start seeing problems in real use (the
+test suite stresses the networking layer in particular ways that aren't
+necessarily typical of normal use).
+
+Next, I started an 8-engine cluster via::
+
+    perez@opt-login01[~]> ipcluster -n 8
+    Starting controller: Controller PID: 30845
+    ^X      Starting engines:    Engines PIDs:   [30846, 30847, 30848, 30849,
+    30850, 30851, 30852, 30853]
+    Log files: /home/perez/.ipython/log/ipcluster-30845-*
+
+    Your cluster is up and running.
+
+    [... etc]
+
+and in a separate ipython session checked that the cluster is running and I can
+access all the engines::
+
+    In [1]: from IPython.kernel import client
+
+    In [2]: mec = client.MultiEngineClient()
+
+    In [3]: mec.get_ids()
+    Out[3]: [0, 1, 2, 3, 4, 5, 6, 7]
+
+and run trivial code in them (after importing the ``random`` module in all
+engines)::
+
+    In [11]: mec.execute("x=random.randint(0,10)")
+    Out[11]:
+    <Results List>
+    [0] In [3]: x=random.randint(0,10)
+    [1] In [3]: x=random.randint(0,10)
+    [2] In [3]: x=random.randint(0,10)
+    [3] In [3]: x=random.randint(0,10)
+    [4] In [3]: x=random.randint(0,10)
+    [5] In [3]: x=random.randint(0,10)
+    [6] In [3]: x=random.randint(0,10)
+    [7] In [3]: x=random.randint(0,10)
+
+    In [12]: mec.pull('x')
+    Out[12]: [10, 0, 8, 10, 2, 9, 10, 7]
+
+
+We'll continue conducting more complex tests later, including instaling Vision
+locally and running the beam demo.
+
+
+Michel's original instructions
+==============================
+
+I got a Vision network that reproduces the beam pattern demo working:
+
+.. image:: vision_beam_pattern.png
+   :width: 400
+   :target: vision_beam_pattern.png
+   :align: center
+
+
+I created a package called beamPattern that provides the function run() in its
+__init__.py file.
+
+A subpackage beamPattern/VisionInterface provides Vision nodes for:
+
+- computing Elevation and Azimuth from a 3D vector
+
+- Reading .mat files
+
+- taking the results gathered from the engines and creating the output that a
+  single engine would have had produced
+
+The Mec node connect to a controller. In my network it was local but an furl
+can be specified to connect to a remote controller.
+
+The PRun Func node is from the IPython library of nodes. the import statement
+is used to get the run function from the beamPattern package and bu puting
+"run" in the function entry of this node we push this function to the engines.
+In addition to the node will create input ports for all arguments of the
+function being pushed (i.e. the run function)
+
+The second input port on PRun Fun take an integer specifying the rank of the
+argument we want to scatter. All other arguments will be pushed to the engines.
+
+The ElevAzim node has a 3D vector widget and computes the El And Az values
+which are passed into the PRun Fun node through the ports created
+automatically. The Mat node allows to select the .mat file, reads it and passed
+the data to the locdata port created automatically on PRun Func
+
+The calculation is executed in parallel, and the results are gathered and
+output.  Instead of having a list of 3 vectors we nd up with a list of n*3
+vectors where n is the number of engines. unpackDectorResults will turn it into
+a list of 3. We then plot x, y, and 10*log10(z)
+
+
+Installation
+------------
+
+- inflate beamPattern into the site-packages directory for the MGL tools.
+
+- place the appended IPythonNodes.py and StandardNodes.py into the Vision
+  package of the MGL tools.
+
+- place the appended items.py in the NetworkEditor package of the MGL tools
+
+- run vision for the network beamPat5_net.py::
+
+    vision beamPat5_net.py
+
+Once the network is running, you can:
+
+- double click on the MEC node and either use an emptty string for the furl to
+  connect to a local engine or cut and paste the furl to the engine you want to
+  use
+
+- click on the yellow lighting bold to run the network.
+
+- Try modifying the MAT file or change the Vector used top compute elevation
+  and Azimut.
+  
+
+Fernando's notes
+================
+
+- I had to install IPython and all its dependencies for the python used by the
+  MGL tools.
+
+- Then I had to install scipy 0.6.0 for it, since the nodes needed Scipy.  To
+  do this I sourced the mglenv.sh script and then ran::
+
+    python setup.py install --prefix=~/usr/opt/mgl
+
+
+Using PBS
+=========
+
+The following PBS script can be used to start the engines::
+
+    #PBS -N bgranger-ipython
+    #PBS -j oe
+    #PBS -l walltime=00:10:00
+    #PBS -l nodes=4:ppn=4
+
+    cd $PBS_O_WORKDIR
+    export PATH=$HOME/usr/local/bin
+    export PYTHONPATH=$HOME/usr/local/lib/python2.4/site-packages
+    /usr/local/bin/mpiexec -n 16 ipengine
+
+
+If this file is called ``ipython_pbs.sh``, then the in one login windows
+(i.e. on the head-node -- ``opt-login01.osc.edu``), run ``ipcontroller``. In
+another login window on the same node, run the above script::
+
+    qsub ipython_pbs.sh
+
+If you look at the first window, you will see some diagnostic output
+from ipcontroller. You can then get the furl from your own
+``~/.ipython/security`` directory and then connect to it remotely.
+
+You might need to set up an SSH tunnel, however; if this doesn't work as
+advertised::
+
+    ssh -L 10115:localhost:10105 bic
+
+
+Links to other resources
+========================
+
+- http://www.osc.edu/~unpingco/glenn_NewLynx2_Demo.avi
+

docs/sphinxext/apigen.py

@@ -0,0 +1,426 b''
+"""Attempt to generate templates for module reference with Sphinx
+
+XXX - we exclude extension modules
+
+To include extension modules, first identify them as valid in the
+``_uri2path`` method, then handle them in the ``_parse_module`` script.
+
+We get functions and classes by parsing the text of .py files.
+Alternatively we could import the modules for discovery, and we'd have
+to do that for extension modules.  This would involve changing the
+``_parse_module`` method to work via import and introspection, and
+might involve changing ``discover_modules`` (which determines which
+files are modules, and therefore which module URIs will be passed to
+``_parse_module``).
+
+NOTE: this is a modified version of a script originally shipped with the
+PyMVPA project, which we've adapted for NIPY use.  PyMVPA is an MIT-licensed
+project."""
+
+# Stdlib imports
+import os
+import re
+
+# Functions and classes
+class ApiDocWriter(object):
+    ''' Class for automatic detection and parsing of API docs
+    to Sphinx-parsable reST format'''
+
+    # only separating first two levels
+    rst_section_levels = ['*', '=', '-', '~', '^']
+
+    def __init__(self,
+                 package_name,
+                 rst_extension='.rst',
+                 package_skip_patterns=None,
+                 module_skip_patterns=None,
+                 ):
+        ''' Initialize package for parsing
+
+        Parameters
+        ----------
+        package_name : string
+            Name of the top-level package.  *package_name* must be the
+            name of an importable package
+        rst_extension : string, optional
+            Extension for reST files, default '.rst'
+        package_skip_patterns : None or sequence of {strings, regexps}
+            Sequence of strings giving URIs of packages to be excluded
+            Operates on the package path, starting at (including) the
+            first dot in the package path, after *package_name* - so,
+            if *package_name* is ``sphinx``, then ``sphinx.util`` will
+            result in ``.util`` being passed for earching by these
+            regexps.  If is None, gives default. Default is:
+            ['\.tests$']
+        module_skip_patterns : None or sequence
+            Sequence of strings giving URIs of modules to be excluded
+            Operates on the module name including preceding URI path,
+            back to the first dot after *package_name*.  For example
+            ``sphinx.util.console`` results in the string to search of
+            ``.util.console``
+            If is None, gives default. Default is:
+            ['\.setup$', '\._']
+        '''
+        if package_skip_patterns is None:
+            package_skip_patterns = ['\\.tests$']
+        if module_skip_patterns is None:
+            module_skip_patterns = ['\\.setup$', '\\._']
+        self.package_name = package_name
+        self.rst_extension = rst_extension
+        self.package_skip_patterns = package_skip_patterns
+        self.module_skip_patterns = module_skip_patterns
+
+    def get_package_name(self):
+        return self._package_name
+
+    def set_package_name(self, package_name):
+        ''' Set package_name
+
+        >>> docwriter = ApiDocWriter('sphinx')
+        >>> import sphinx
+        >>> docwriter.root_path == sphinx.__path__[0]
+        True
+        >>> docwriter.package_name = 'docutils'
+        >>> import docutils
+        >>> docwriter.root_path == docutils.__path__[0]
+        True
+        '''
+        # It's also possible to imagine caching the module parsing here
+        self._package_name = package_name
+        self.root_module = __import__(package_name)
+        self.root_path = self.root_module.__path__[0]
+        self.written_modules = None
+
+    package_name = property(get_package_name, set_package_name, None,
+                            'get/set package_name')
+
+    def _get_object_name(self, line):
+        ''' Get second token in line
+        >>> docwriter = ApiDocWriter('sphinx')
+        >>> docwriter._get_object_name("  def func():  ")
+        'func'
+        >>> docwriter._get_object_name("  class Klass(object):  ")
+        'Klass'
+        >>> docwriter._get_object_name("  class Klass:  ")
+        'Klass'
+        '''
+        name = line.split()[1].split('(')[0].strip()
+        # in case we have classes which are not derived from object
+        # ie. old style classes
+        return name.rstrip(':')
+
+    def _uri2path(self, uri):
+        ''' Convert uri to absolute filepath
+
+        Parameters
+        ----------
+        uri : string
+            URI of python module to return path for
+
+        Returns
+        -------
+        path : None or string
+            Returns None if there is no valid path for this URI
+            Otherwise returns absolute file system path for URI
+
+        Examples
+        --------
+        >>> docwriter = ApiDocWriter('sphinx')
+        >>> import sphinx
+        >>> modpath = sphinx.__path__[0]
+        >>> res = docwriter._uri2path('sphinx.builder')
+        >>> res == os.path.join(modpath, 'builder.py')
+        True
+        >>> res = docwriter._uri2path('sphinx')
+        >>> res == os.path.join(modpath, '__init__.py')
+        True
+        >>> docwriter._uri2path('sphinx.does_not_exist')
+
+        '''
+        if uri == self.package_name:
+            return os.path.join(self.root_path, '__init__.py')
+        path = uri.replace('.', os.path.sep)
+        path = path.replace(self.package_name + os.path.sep, '')
+        path = os.path.join(self.root_path, path)
+        # XXX maybe check for extensions as well?
+        if os.path.exists(path + '.py'): # file
+            path += '.py'
+        elif os.path.exists(os.path.join(path, '__init__.py')):
+            path = os.path.join(path, '__init__.py')
+        else:
+            return None
+        return path
+
+    def _path2uri(self, dirpath):
+        ''' Convert directory path to uri '''
+        relpath = dirpath.replace(self.root_path, self.package_name)
+        if relpath.startswith(os.path.sep):
+            relpath = relpath[1:]
+        return relpath.replace(os.path.sep, '.')
+
+    def _parse_module(self, uri):
+        ''' Parse module defined in *uri* '''
+        filename = self._uri2path(uri)
+        if filename is None:
+            # nothing that we could handle here.
+            return ([],[])
+        f = open(filename, 'rt')
+        functions, classes = self._parse_lines(f)
+        f.close()
+        return functions, classes
+    
+    def _parse_lines(self, linesource):
+        ''' Parse lines of text for functions and classes '''
+        functions = []
+        classes = []
+        for line in linesource:
+            if line.startswith('def ') and line.count('('):
+                # exclude private stuff
+                name = self._get_object_name(line)
+                if not name.startswith('_'):
+                    functions.append(name)
+            elif line.startswith('class '):
+                # exclude private stuff
+                name = self._get_object_name(line)
+                if not name.startswith('_'):
+                    classes.append(name)
+            else:
+                pass
+        functions.sort()
+        classes.sort()
+        return functions, classes
+
+    def generate_api_doc(self, uri):
+        '''Make autodoc documentation template string for a module
+
+        Parameters
+        ----------
+        uri : string
+            python location of module - e.g 'sphinx.builder'
+
+        Returns
+        -------
+        S : string
+            Contents of API doc
+        '''
+        # get the names of all classes and functions
+        functions, classes = self._parse_module(uri)
+        if not len(functions) and not len(classes):
+            print 'WARNING: Empty -',uri  # dbg
+            return ''
+
+        # Make a shorter version of the uri that omits the package name for
+        # titles 
+        uri_short = re.sub(r'^%s\.' % self.package_name,'',uri)
+        
+        ad = '.. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n'
+
+        chap_title = uri_short
+        ad += (chap_title+'\n'+ self.rst_section_levels[1] * len(chap_title)
+               + '\n\n')
+
+        # Set the chapter title to read 'module' for all modules except for the
+        # main packages
+        if '.' in uri:
+            title = 'Module: :mod:`' + uri_short + '`'
+        else:
+            title = ':mod:`' + uri_short + '`'
+        ad += title + '\n' + self.rst_section_levels[2] * len(title)
+
+        if len(classes):
+            ad += '\nInheritance diagram for ``%s``:\n\n' % uri
+            ad += '.. inheritance-diagram:: %s \n' % uri
+            ad += '   :parts: 3\n'
+
+        ad += '\n.. automodule:: ' + uri + '\n'
+        ad += '\n.. currentmodule:: ' + uri + '\n'
+        multi_class = len(classes) > 1
+        multi_fx = len(functions) > 1
+        if multi_class:
+            ad += '\n' + 'Classes' + '\n' + \
+                  self.rst_section_levels[2] * 7 + '\n'
+        elif len(classes) and multi_fx:
+            ad += '\n' + 'Class' + '\n' + \
+                  self.rst_section_levels[2] * 5 + '\n'
+        for c in classes:
+            ad += '\n:class:`' + c + '`\n' \
+                  + self.rst_section_levels[multi_class + 2 ] * \
+                  (len(c)+9) + '\n\n'
+            ad += '\n.. autoclass:: ' + c + '\n'
+            # must NOT exclude from index to keep cross-refs working
+            ad += '  :members:\n' \
+                  '  :undoc-members:\n' \
+                  '  :show-inheritance:\n' \
+                  '\n' \
+                  '  .. automethod:: __init__\n'
+        if multi_fx:
+            ad += '\n' + 'Functions' + '\n' + \
+                  self.rst_section_levels[2] * 9 + '\n\n'
+        elif len(functions) and multi_class:
+            ad += '\n' + 'Function' + '\n' + \
+                  self.rst_section_levels[2] * 8 + '\n\n'
+        for f in functions:
+            # must NOT exclude from index to keep cross-refs working
+            ad += '\n.. autofunction:: ' + uri + '.' + f + '\n\n'
+        return ad
+
+    def _survives_exclude(self, matchstr, match_type):
+        ''' Returns True if *matchstr* does not match patterns
+
+        ``self.package_name`` removed from front of string if present
+
+        Examples
+        --------
+        >>> dw = ApiDocWriter('sphinx')
+        >>> dw._survives_exclude('sphinx.okpkg', 'package')
+        True
+        >>> dw.package_skip_patterns.append('^\\.badpkg$')
+        >>> dw._survives_exclude('sphinx.badpkg', 'package')
+        False
+        >>> dw._survives_exclude('sphinx.badpkg', 'module')
+        True
+        >>> dw._survives_exclude('sphinx.badmod', 'module')
+        True
+        >>> dw.module_skip_patterns.append('^\\.badmod$')
+        >>> dw._survives_exclude('sphinx.badmod', 'module')
+        False
+        '''
+        if match_type == 'module':
+            patterns = self.module_skip_patterns
+        elif match_type == 'package':
+            patterns = self.package_skip_patterns
+        else:
+            raise ValueError('Cannot interpret match type "%s"' 
+                             % match_type)
+        # Match to URI without package name
+        L = len(self.package_name)
+        if matchstr[:L] == self.package_name:
+            matchstr = matchstr[L:]
+        for pat in patterns:
+            try:
+                pat.search
+            except AttributeError:
+                pat = re.compile(pat)
+            if pat.search(matchstr):
+                return False
+        return True
+
+    def discover_modules(self):
+        ''' Return module sequence discovered from ``self.package_name`` 
+
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        mods : sequence
+            Sequence of module names within ``self.package_name``
+
+        Examples
+        --------
+        >>> dw = ApiDocWriter('sphinx')
+        >>> mods = dw.discover_modules()
+        >>> 'sphinx.util' in mods
+        True
+        >>> dw.package_skip_patterns.append('\.util$')
+        >>> 'sphinx.util' in dw.discover_modules()
+        False
+        >>> 
+        '''
+        modules = [self.package_name]
+        # raw directory parsing
+        for dirpath, dirnames, filenames in os.walk(self.root_path):
+            # Check directory names for packages
+            root_uri = self._path2uri(os.path.join(self.root_path,
+                                                   dirpath))
+            for dirname in dirnames[:]: # copy list - we modify inplace
+                package_uri = '.'.join((root_uri, dirname))
+                if (self._uri2path(package_uri) and
+                    self._survives_exclude(package_uri, 'package')):
+                    modules.append(package_uri)
+                else:
+                    dirnames.remove(dirname)
+            # Check filenames for modules
+            for filename in filenames:
+                module_name = filename[:-3]
+                module_uri = '.'.join((root_uri, module_name))
+                if (self._uri2path(module_uri) and
+                    self._survives_exclude(module_uri, 'module')):
+                    modules.append(module_uri)
+        return sorted(modules)
+    
+    def write_modules_api(self, modules,outdir):
+        # write the list
+        written_modules = []
+        for m in modules:
+            api_str = self.generate_api_doc(m)
+            if not api_str:
+                continue
+            # write out to file
+            outfile = os.path.join(outdir,
+                                   m + self.rst_extension)
+            fileobj = open(outfile, 'wt')
+            fileobj.write(api_str)
+            fileobj.close()
+            written_modules.append(m)
+        self.written_modules = written_modules
+
+    def write_api_docs(self, outdir):
+        """Generate API reST files.
+
+        Parameters
+        ----------
+        outdir : string
+            Directory name in which to store files
+            We create automatic filenames for each module
+            
+        Returns
+        -------
+        None
+
+        Notes
+        -----
+        Sets self.written_modules to list of written modules
+        """
+        if not os.path.exists(outdir):
+            os.mkdir(outdir)
+        # compose list of modules
+        modules = self.discover_modules()
+        self.write_modules_api(modules,outdir)
+        
+    def write_index(self, outdir, froot='gen', relative_to=None):
+        """Make a reST API index file from written files
+
+        Parameters
+        ----------
+        path : string
+            Filename to write index to
+        outdir : string
+            Directory to which to write generated index file
+        froot : string, optional
+            root (filename without extension) of filename to write to
+            Defaults to 'gen'.  We add ``self.rst_extension``.
+        relative_to : string
+            path to which written filenames are relative.  This
+            component of the written file path will be removed from
+            outdir, in the generated index.  Default is None, meaning,
+            leave path as it is.
+        """
+        if self.written_modules is None:
+            raise ValueError('No modules written')
+        # Get full filename path
+        path = os.path.join(outdir, froot+self.rst_extension)
+        # Path written into index is relative to rootpath
+        if relative_to is not None:
+            relpath = outdir.replace(relative_to + os.path.sep, '')
+        else:
+            relpath = outdir
+        idx = open(path,'wt')
+        w = idx.write
+        w('.. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n')
+        w('.. toctree::\n\n')
+        for f in self.written_modules:
+            w('   %s\n' % os.path.join(relpath,f))
+        idx.close()

docs/sphinxext/docscrape.py

@@ -0,0 +1,497 b''
+"""Extract reference documentation from the NumPy source tree.
+
+"""
+
+import inspect
+import textwrap
+import re
+import pydoc
+from StringIO import StringIO
+from warnings import warn
+4
+class Reader(object):
+    """A line-based string reader.
+
+    """
+    def __init__(self, data):
+        """
+        Parameters
+        ----------
+        data : str
+           String with lines separated by '\n'.
+
+        """
+        if isinstance(data,list):
+            self._str = data
+        else:
+            self._str = data.split('\n') # store string as list of lines
+
+        self.reset()
+
+    def __getitem__(self, n):
+        return self._str[n]
+
+    def reset(self):
+        self._l = 0 # current line nr
+
+    def read(self):
+        if not self.eof():
+            out = self[self._l]
+            self._l += 1
+            return out
+        else:
+            return ''
+
+    def seek_next_non_empty_line(self):
+        for l in self[self._l:]:
+            if l.strip():
+                break
+            else:
+                self._l += 1
+
+    def eof(self):
+        return self._l >= len(self._str)
+
+    def read_to_condition(self, condition_func):
+        start = self._l
+        for line in self[start:]:
+            if condition_func(line):
+                return self[start:self._l]
+            self._l += 1
+            if self.eof():
+                return self[start:self._l+1]
+        return []
+
+    def read_to_next_empty_line(self):
+        self.seek_next_non_empty_line()
+        def is_empty(line):
+            return not line.strip()
+        return self.read_to_condition(is_empty)
+
+    def read_to_next_unindented_line(self):
+        def is_unindented(line):
+            return (line.strip() and (len(line.lstrip()) == len(line)))
+        return self.read_to_condition(is_unindented)
+
+    def peek(self,n=0):
+        if self._l + n < len(self._str):
+            return self[self._l + n]
+        else:
+            return ''
+
+    def is_empty(self):
+        return not ''.join(self._str).strip()
+
+
+class NumpyDocString(object):
+    def __init__(self,docstring):
+        docstring = textwrap.dedent(docstring).split('\n')
+
+        self._doc = Reader(docstring)
+        self._parsed_data = {
+            'Signature': '',
+            'Summary': [''],
+            'Extended Summary': [],
+            'Parameters': [],
+            'Returns': [],
+            'Raises': [],
+            'Warns': [],
+            'Other Parameters': [],
+            'Attributes': [],
+            'Methods': [],
+            'See Also': [],
+            'Notes': [],
+            'Warnings': [],
+            'References': '',
+            'Examples': '',
+            'index': {}
+            }
+
+        self._parse()
+
+    def __getitem__(self,key):
+        return self._parsed_data[key]
+
+    def __setitem__(self,key,val):
+        if not self._parsed_data.has_key(key):
+            warn("Unknown section %s" % key)
+        else:
+            self._parsed_data[key] = val
+
+    def _is_at_section(self):
+        self._doc.seek_next_non_empty_line()
+
+        if self._doc.eof():
+            return False
+
+        l1 = self._doc.peek().strip()  # e.g. Parameters
+
+        if l1.startswith('.. index::'):
+            return True
+
+        l2 = self._doc.peek(1).strip() #    ---------- or ==========
+        return l2.startswith('-'*len(l1)) or l2.startswith('='*len(l1))
+
+    def _strip(self,doc):
+        i = 0
+        j = 0
+        for i,line in enumerate(doc):
+            if line.strip(): break
+
+        for j,line in enumerate(doc[::-1]):
+            if line.strip(): break
+
+        return doc[i:len(doc)-j]
+
+    def _read_to_next_section(self):
+        section = self._doc.read_to_next_empty_line()
+
+        while not self._is_at_section() and not self._doc.eof():
+            if not self._doc.peek(-1).strip(): # previous line was empty
+                section += ['']
+
+            section += self._doc.read_to_next_empty_line()
+
+        return section
+
+    def _read_sections(self):
+        while not self._doc.eof():
+            data = self._read_to_next_section()
+            name = data[0].strip()
+
+            if name.startswith('..'): # index section
+                yield name, data[1:]
+            elif len(data) < 2:
+                yield StopIteration
+            else:
+                yield name, self._strip(data[2:])
+
+    def _parse_param_list(self,content):
+        r = Reader(content)
+        params = []
+        while not r.eof():
+            header = r.read().strip()
+            if ' : ' in header:
+                arg_name, arg_type = header.split(' : ')[:2]
+            else:
+                arg_name, arg_type = header, ''
+
+            desc = r.read_to_next_unindented_line()
+            desc = dedent_lines(desc)
+
+            params.append((arg_name,arg_type,desc))
+
+        return params
+
+    
+    _name_rgx = re.compile(r"^\s*(:(?P<role>\w+):`(?P<name>[a-zA-Z0-9_.-]+)`|"
+                           r" (?P<name2>[a-zA-Z0-9_.-]+))\s*", re.X)
+    def _parse_see_also(self, content):
+        """
+        func_name : Descriptive text
+            continued text
+        another_func_name : Descriptive text
+        func_name1, func_name2, :meth:`func_name`, func_name3
+
+        """
+        items = []
+
+        def parse_item_name(text):
+            """Match ':role:`name`' or 'name'"""
+            m = self._name_rgx.match(text)
+            if m:
+                g = m.groups()
+                if g[1] is None:
+                    return g[3], None
+                else:
+                    return g[2], g[1]
+            raise ValueError("%s is not a item name" % text)
+
+        def push_item(name, rest):
+            if not name:
+                return
+            name, role = parse_item_name(name)
+            items.append((name, list(rest), role))
+            del rest[:]
+
+        current_func = None
+        rest = []
+        
+        for line in content:
+            if not line.strip(): continue
+
+            m = self._name_rgx.match(line)
+            if m and line[m.end():].strip().startswith(':'):
+                push_item(current_func, rest)
+                current_func, line = line[:m.end()], line[m.end():]
+                rest = [line.split(':', 1)[1].strip()]
+                if not rest[0]:
+                    rest = []
+            elif not line.startswith(' '):
+                push_item(current_func, rest)
+                current_func = None
+                if ',' in line:
+                    for func in line.split(','):
+                        push_item(func, [])
+                elif line.strip():
+                    current_func = line
+            elif current_func is not None:
+                rest.append(line.strip())
+        push_item(current_func, rest)
+        return items
+
+    def _parse_index(self, section, content):
+        """
+        .. index: default
+           :refguide: something, else, and more
+
+        """
+        def strip_each_in(lst):
+            return [s.strip() for s in lst]
+
+        out = {}
+        section = section.split('::')
+        if len(section) > 1:
+            out['default'] = strip_each_in(section[1].split(','))[0]
+        for line in content:
+            line = line.split(':')
+            if len(line) > 2:
+                out[line[1]] = strip_each_in(line[2].split(','))
+        return out
+    
+    def _parse_summary(self):
+        """Grab signature (if given) and summary"""
+        if self._is_at_section():
+            return
+
+        summary = self._doc.read_to_next_empty_line()
+        summary_str = " ".join([s.strip() for s in summary]).strip()
+        if re.compile('^([\w., ]+=)?\s*[\w\.]+\(.*\)$').match(summary_str):
+            self['Signature'] = summary_str
+            if not self._is_at_section():
+                self['Summary'] = self._doc.read_to_next_empty_line()
+        else:
+            self['Summary'] = summary
+
+        if not self._is_at_section():
+            self['Extended Summary'] = self._read_to_next_section()
+    
+    def _parse(self):
+        self._doc.reset()
+        self._parse_summary()
+
+        for (section,content) in self._read_sections():
+            if not section.startswith('..'):
+                section = ' '.join([s.capitalize() for s in section.split(' ')])
+            if section in ('Parameters', 'Attributes', 'Methods',
+                           'Returns', 'Raises', 'Warns'):
+                self[section] = self._parse_param_list(content)
+            elif section.startswith('.. index::'):
+                self['index'] = self._parse_index(section, content)
+            elif section == 'See Also':
+                self['See Also'] = self._parse_see_also(content)
+            else:
+                self[section] = content
+
+    # string conversion routines
+
+    def _str_header(self, name, symbol='-'):
+        return [name, len(name)*symbol]
+
+    def _str_indent(self, doc, indent=4):
+        out = []
+        for line in doc:
+            out += [' '*indent + line]
+        return out
+
+    def _str_signature(self):
+        if self['Signature']:
+            return [self['Signature'].replace('*','\*')] + ['']
+        else:
+            return ['']
+
+    def _str_summary(self):
+        if self['Summary']:
+            return self['Summary'] + ['']
+        else:
+            return []
+
+    def _str_extended_summary(self):
+        if self['Extended Summary']:
+            return self['Extended Summary'] + ['']
+        else:
+            return []
+
+    def _str_param_list(self, name):
+        out = []
+        if self[name]:
+            out += self._str_header(name)
+            for param,param_type,desc in self[name]:
+                out += ['%s : %s' % (param, param_type)]
+                out += self._str_indent(desc)
+            out += ['']
+        return out
+
+    def _str_section(self, name):
+        out = []
+        if self[name]:
+            out += self._str_header(name)
+            out += self[name]
+            out += ['']
+        return out
+
+    def _str_see_also(self, func_role):
+        if not self['See Also']: return []
+        out = []
+        out += self._str_header("See Also")
+        last_had_desc = True
+        for func, desc, role in self['See Also']:
+            if role:
+                link = ':%s:`%s`' % (role, func)
+            elif func_role:
+                link = ':%s:`%s`' % (func_role, func)
+            else:
+                link = "`%s`_" % func
+            if desc or last_had_desc:
+                out += ['']
+                out += [link]
+            else:
+                out[-1] += ", %s" % link
+            if desc:
+                out += self._str_indent([' '.join(desc)])
+                last_had_desc = True
+            else:
+                last_had_desc = False
+        out += ['']
+        return out
+
+    def _str_index(self):
+        idx = self['index']
+        out = []
+        out += ['.. index:: %s' % idx.get('default','')]
+        for section, references in idx.iteritems():
+            if section == 'default':
+                continue
+            out += ['   :%s: %s' % (section, ', '.join(references))]
+        return out
+
+    def __str__(self, func_role=''):
+        out = []
+        out += self._str_signature()
+        out += self._str_summary()
+        out += self._str_extended_summary()
+        for param_list in ('Parameters','Returns','Raises'):
+            out += self._str_param_list(param_list)
+        out += self._str_section('Warnings')
+        out += self._str_see_also(func_role)
+        for s in ('Notes','References','Examples'):
+            out += self._str_section(s)
+        out += self._str_index()
+        return '\n'.join(out)
+
+
+def indent(str,indent=4):
+    indent_str = ' '*indent
+    if str is None:
+        return indent_str
+    lines = str.split('\n')
+    return '\n'.join(indent_str + l for l in lines)
+
+def dedent_lines(lines):
+    """Deindent a list of lines maximally"""
+    return textwrap.dedent("\n".join(lines)).split("\n")
+
+def header(text, style='-'):
+    return text + '\n' + style*len(text) + '\n'
+
+
+class FunctionDoc(NumpyDocString):
+    def __init__(self, func, role='func', doc=None):
+        self._f = func
+        self._role = role # e.g. "func" or "meth"
+        if doc is None:
+            doc = inspect.getdoc(func) or ''
+        try:
+            NumpyDocString.__init__(self, doc)
+        except ValueError, e:
+            print '*'*78
+            print "ERROR: '%s' while parsing `%s`" % (e, self._f)
+            print '*'*78
+            #print "Docstring follows:"
+            #print doclines
+            #print '='*78
+
+        if not self['Signature']:
+            func, func_name = self.get_func()
+            try:
+                # try to read signature
+                argspec = inspect.getargspec(func)
+                argspec = inspect.formatargspec(*argspec)
+                argspec = argspec.replace('*','\*')
+                signature = '%s%s' % (func_name, argspec)
+            except TypeError, e:
+                signature = '%s()' % func_name
+            self['Signature'] = signature
+
+    def get_func(self):
+        func_name = getattr(self._f, '__name__', self.__class__.__name__)
+        if inspect.isclass(self._f):
+            func = getattr(self._f, '__call__', self._f.__init__)
+        else:
+            func = self._f
+        return func, func_name
+            
+    def __str__(self):
+        out = ''
+
+        func, func_name = self.get_func()
+        signature = self['Signature'].replace('*', '\*')
+
+        roles = {'func': 'function',
+                 'meth': 'method'}
+
+        if self._role:
+            if not roles.has_key(self._role):
+                print "Warning: invalid role %s" % self._role
+            out += '.. %s:: %s\n    \n\n' % (roles.get(self._role,''),
+                                             func_name)
+
+        out += super(FunctionDoc, self).__str__(func_role=self._role)
+        return out
+
+
+class ClassDoc(NumpyDocString):
+    def __init__(self,cls,modulename='',func_doc=FunctionDoc,doc=None):
+        if not inspect.isclass(cls):
+            raise ValueError("Initialise using a class. Got %r" % cls)
+        self._cls = cls
+
+        if modulename and not modulename.endswith('.'):
+            modulename += '.'
+        self._mod = modulename
+        self._name = cls.__name__
+        self._func_doc = func_doc
+
+        if doc is None:
+            doc = pydoc.getdoc(cls)
+
+        NumpyDocString.__init__(self, doc)
+
+    @property
+    def methods(self):
+        return [name for name,func in inspect.getmembers(self._cls)
+                if not name.startswith('_') and callable(func)]
+
+    def __str__(self):
+        out = ''
+        out += super(ClassDoc, self).__str__()
+        out += "\n\n"
+
+        #for m in self.methods:
+        #    print "Parsing `%s`" % m
+        #    out += str(self._func_doc(getattr(self._cls,m), 'meth')) + '\n\n'
+        #    out += '.. index::\n   single: %s; %s\n\n' % (self._name, m)
+
+        return out
+
+

docs/sphinxext/docscrape_sphinx.py

@@ -0,0 +1,136 b''
+import re, inspect, textwrap, pydoc
+from docscrape import NumpyDocString, FunctionDoc, ClassDoc
+
+class SphinxDocString(NumpyDocString):
+    # string conversion routines
+    def _str_header(self, name, symbol='`'):
+        return ['.. rubric:: ' + name, '']
+
+    def _str_field_list(self, name):
+        return [':' + name + ':']
+
+    def _str_indent(self, doc, indent=4):
+        out = []
+        for line in doc:
+            out += [' '*indent + line]
+        return out
+
+    def _str_signature(self):
+        return ['']
+        if self['Signature']:
+            return ['``%s``' % self['Signature']] + ['']
+        else:
+            return ['']
+
+    def _str_summary(self):
+        return self['Summary'] + ['']
+
+    def _str_extended_summary(self):
+        return self['Extended Summary'] + ['']
+
+    def _str_param_list(self, name):
+        out = []
+        if self[name]:
+            out += self._str_field_list(name)
+            out += ['']
+            for param,param_type,desc in self[name]:
+                out += self._str_indent(['**%s** : %s' % (param.strip(),
+                                                          param_type)])
+                out += ['']
+                out += self._str_indent(desc,8)
+                out += ['']
+        return out
+
+    def _str_section(self, name):
+        out = []
+        if self[name]:
+            out += self._str_header(name)
+            out += ['']
+            content = textwrap.dedent("\n".join(self[name])).split("\n")
+            out += content
+            out += ['']
+        return out
+
+    def _str_see_also(self, func_role):
+        out = []
+        if self['See Also']:
+            see_also = super(SphinxDocString, self)._str_see_also(func_role)
+            out = ['.. seealso::', '']
+            out += self._str_indent(see_also[2:])
+        return out
+
+    def _str_warnings(self):
+        out = []
+        if self['Warnings']:
+            out = ['.. warning::', '']
+            out += self._str_indent(self['Warnings'])
+        return out
+
+    def _str_index(self):
+        idx = self['index']
+        out = []
+        if len(idx) == 0:
+            return out
+
+        out += ['.. index:: %s' % idx.get('default','')]
+        for section, references in idx.iteritems():
+            if section == 'default':
+                continue
+            elif section == 'refguide':
+                out += ['   single: %s' % (', '.join(references))]
+            else:
+                out += ['   %s: %s' % (section, ','.join(references))]
+        return out
+
+    def _str_references(self):
+        out = []
+        if self['References']:
+            out += self._str_header('References')
+            if isinstance(self['References'], str):
+                self['References'] = [self['References']]
+            out.extend(self['References'])
+            out += ['']
+        return out
+
+    def __str__(self, indent=0, func_role="obj"):
+        out = []
+        out += self._str_signature()
+        out += self._str_index() + ['']
+        out += self._str_summary()
+        out += self._str_extended_summary()
+        for param_list in ('Parameters', 'Attributes', 'Methods',
+                           'Returns','Raises'):
+            out += self._str_param_list(param_list)
+        out += self._str_warnings()
+        out += self._str_see_also(func_role)
+        out += self._str_section('Notes')
+        out += self._str_references()
+        out += self._str_section('Examples')
+        out = self._str_indent(out,indent)
+        return '\n'.join(out)
+
+class SphinxFunctionDoc(SphinxDocString, FunctionDoc):
+    pass
+
+class SphinxClassDoc(SphinxDocString, ClassDoc):
+    pass
+
+def get_doc_object(obj, what=None, doc=None):
+    if what is None:
+        if inspect.isclass(obj):
+            what = 'class'
+        elif inspect.ismodule(obj):
+            what = 'module'
+        elif callable(obj):
+            what = 'function'
+        else:
+            what = 'object'
+    if what == 'class':
+        return SphinxClassDoc(obj, '', func_doc=SphinxFunctionDoc, doc=doc)
+    elif what in ('function', 'method'):
+        return SphinxFunctionDoc(obj, '', doc=doc)
+    else:
+        if doc is None:
+            doc = pydoc.getdoc(obj)
+        return SphinxDocString(doc)
+

docs/sphinxext/numpydoc.py

@@ -0,0 +1,116 b''
+"""
+========
+numpydoc
+========
+
+Sphinx extension that handles docstrings in the Numpy standard format. [1]
+
+It will:
+
+- Convert Parameters etc. sections to field lists.
+- Convert See Also section to a See also entry.
+- Renumber references.
+- Extract the signature from the docstring, if it can't be determined otherwise.
+
+.. [1] http://projects.scipy.org/scipy/numpy/wiki/CodingStyleGuidelines#docstring-standard
+
+"""
+
+import os, re, pydoc
+from docscrape_sphinx import get_doc_object, SphinxDocString
+import inspect
+
+def mangle_docstrings(app, what, name, obj, options, lines,
+                      reference_offset=[0]):
+    if what == 'module':
+        # Strip top title
+        title_re = re.compile(r'^\s*[#*=]{4,}\n[a-z0-9 -]+\n[#*=]{4,}\s*',
+                              re.I|re.S)
+        lines[:] = title_re.sub('', "\n".join(lines)).split("\n")
+    else:
+        doc = get_doc_object(obj, what, "\n".join(lines))
+        lines[:] = str(doc).split("\n")
+
+    if app.config.numpydoc_edit_link and hasattr(obj, '__name__') and \
+           obj.__name__:
+        if hasattr(obj, '__module__'):
+            v = dict(full_name="%s.%s" % (obj.__module__, obj.__name__))
+        else:
+            v = dict(full_name=obj.__name__)
+        lines += ['', '.. htmlonly::', '']
+        lines += ['    %s' % x for x in
+                  (app.config.numpydoc_edit_link % v).split("\n")]
+
+    # replace reference numbers so that there are no duplicates
+    references = []
+    for l in lines:
+        l = l.strip()
+        if l.startswith('.. ['):
+            try:
+                references.append(int(l[len('.. ['):l.index(']')]))
+            except ValueError:
+                print "WARNING: invalid reference in %s docstring" % name
+
+    # Start renaming from the biggest number, otherwise we may
+    # overwrite references.
+    references.sort()
+    if references:
+        for i, line in enumerate(lines):
+            for r in references:
+                new_r = reference_offset[0] + r
+                lines[i] = lines[i].replace('[%d]_' % r,
+                                            '[%d]_' % new_r)
+                lines[i] = lines[i].replace('.. [%d]' % r,
+                                            '.. [%d]' % new_r)
+
+    reference_offset[0] += len(references)
+
+def mangle_signature(app, what, name, obj, options, sig, retann):
+    # Do not try to inspect classes that don't define `__init__`
+    if (inspect.isclass(obj) and
+        'initializes x; see ' in pydoc.getdoc(obj.__init__)):
+        return '', ''
+
+    if not (callable(obj) or hasattr(obj, '__argspec_is_invalid_')): return
+    if not hasattr(obj, '__doc__'): return
+
+    doc = SphinxDocString(pydoc.getdoc(obj))
+    if doc['Signature']:
+        sig = re.sub("^[^(]*", "", doc['Signature'])
+        return sig, ''
+
+def initialize(app):
+    try:
+        app.connect('autodoc-process-signature', mangle_signature)
+    except:
+        monkeypatch_sphinx_ext_autodoc()
+
+def setup(app, get_doc_object_=get_doc_object):
+    global get_doc_object
+    get_doc_object = get_doc_object_
+    
+    app.connect('autodoc-process-docstring', mangle_docstrings)
+    app.connect('builder-inited', initialize)
+    app.add_config_value('numpydoc_edit_link', None, True)
+
+#------------------------------------------------------------------------------
+# Monkeypatch sphinx.ext.autodoc to accept argspecless autodocs (Sphinx < 0.5)
+#------------------------------------------------------------------------------
+
+def monkeypatch_sphinx_ext_autodoc():
+    global _original_format_signature
+    import sphinx.ext.autodoc
+
+    if sphinx.ext.autodoc.format_signature is our_format_signature:
+        return
+
+    print "[numpydoc] Monkeypatching sphinx.ext.autodoc ..."
+    _original_format_signature = sphinx.ext.autodoc.format_signature
+    sphinx.ext.autodoc.format_signature = our_format_signature
+
+def our_format_signature(what, obj):
+    r = mangle_signature(None, what, None, obj, None, None, None)
+    if r is not None:
+        return r[0]
+    else:
+        return _original_format_signature(what, obj)

tools/alldeps/Makefile

@@ -0,0 +1,130 b''
+# Simple makefile to rapidly deploy IPython with all its dependencies.
+
+# Configuration section.  The version numbers and paths declared here may
+# change with each release.
+
+# IPython version
+IPYTHON_VER=0.9.1
+
+# Declare here version numbers of all the dependencies
+PYOPENSSL_VER=0.6
+ZOPE_INTERFACE_VER=3.4.1
+TWISTED_VER=8.1.0
+FOOLSCAP_VER=0.3.1
+NOSE_VER=0.10.3
+
+# Repository URLs for all packages.  Make sure these are correct for each
+# release, since projects may change paths!
+IPYTHON_REPO=http://ipython.scipy.org/dist
+PYOPENSSL_REPO=http://downloads.sourceforge.net/pyopenssl
+ZOPE_INTERFACE_REPO=http://pypi.python.org/packages/source/z/zope.interface
+TWISTED_REPO=http://tmrc.mit.edu/mirror/twisted/Twisted/8.1
+FOOLSCAP_REPO=http://foolscap.lothar.com/releases
+NOSE_REPO=http://somethingaboutorange.com/mrl/projects/nose
+
+#-----------------------------------------------------------------------------
+# Main code begins.  There shouldn't be much to change here with each release.
+#
+
+# Hand-written files to ship in self-contained tarball
+SOURCES=pkginstall pkginstall.cfg Makefile README.txt README.html
+
+# Versions of tarballs we ship
+IPYTHON=ipython-$(IPYTHON_VER).tar.gz
+IP_ALLDEPS=ipython-alldeps-$(IPYTHON_VER)
+
+PYOPENSSL=pyOpenSSL-$(PYOPENSSL_VER).tar.gz
+ZOPE_INTERFACE=zope.interface-$(ZOPE_INTERFACE_VER).tar.gz
+NOSE=nose-$(NOSE_VER).tar.gz
+TWISTED=Twisted-$(TWISTED_VER).tar.bz2
+FOOLSCAP=foolscap-$(FOOLSCAP_VER).tar.gz
+
+TARBALLS=$(PYOPENSSL) $(ZOPE_INTERFACE) $(TWISTED) $(FOOLSCAP) \
+$(NOSE) $(IPYTHON)
+
+# URLs for downloads
+
+#-----------------------------------------------------------------------------
+# Target declaration
+#
+
+# Targets to install, in correct dependency order
+install: pyopenssl zope.interface twisted foolscap nose ipython
+	echo
+	echo "IPython Installation finished."
+	echo "You can now run the ipython test suite by running:"
+	echo "iptest"
+	echo "If all tests pass, you can delete this entire directory."
+	echo
+
+# Download targets
+download: $(TARBALLS)
+
+$(IPYTHON):
+	wget $(IPYTHON_REPO)/$(IPYTHON)
+
+$(PYOPENSSL):
+	wget $(PYOPENSSL_REPO)/$(PYOPENSSL)
+
+$(ZOPE_INTERFACE):
+	wget $(ZOPE_INTERFACE_REPO)/$(ZOPE_INTERFACE)
+
+$(TWISTED):
+	wget $(TWISTED_REPO)/$(TWISTED)
+
+$(FOOLSCAP):
+	wget $(FOOLSCAP_REPO)/$(FOOLSCAP)
+
+$(NOSE):
+	wget $(NOSE_REPO)/$(NOSE)
+
+
+# The calls to pkginstall must use the actual Python package name
+nose: $(NOSE)
+	./pkginstall nose
+
+zope.interface: $(ZOPE_INTERFACE)
+	./pkginstall zope.interface zope
+
+pyopenssl: $(PYOPENSSL)
+	./pkginstall pyOpenSSL OpenSSL
+
+twisted: $(TWISTED)
+	./pkginstall Twisted
+
+foolscap: $(FOOLSCAP)
+	./pkginstall foolscap
+
+ipython: $(IPYTHON)
+	./pkginstall ipython IPython
+
+# Distribution targets
+dist: $(IP_ALLDEPS).tar
+
+$(IP_ALLDEPS).tar: download readme
+	-mkdir $(IP_ALLDEPS)
+	-ln $(SOURCES) $(TARBALLS) $(IP_ALLDEPS)/
+	tar cf $(IP_ALLDEPS).tar $(IP_ALLDEPS)
+	rm -rf $(IP_ALLDEPS)
+
+readme: README.html
+
+README.html: README.txt
+	rst2html README.txt > README.html
+
+# Auxiliary targets
+upload: dist
+	rsync -e ssh -av README.html $(IP_ALLDEPS).tar \
+	[e-mail]:www/dist/alldeps
+
+clean:
+	ls -p | grep /$ | xargs rm -rf
+	rm -f $(IP_ALLDEPS)* *~
+
+distclean: clean
+	rm -f $(TARBALLS)
+	rm README.html
+
+info:
+	echo "TARBALLS"
+	echo $(TARBALLS)

tools/alldeps/README.txt

@@ -0,0 +1,109 b''
+===========================================================
+ Self-contained IPython installation with all dependencies
+===========================================================
+
+This is a self-contained source distribution of IPython with all its
+*non-graphical* dependencies, that installs in a single ``make`` call to your
+home directory (by default) or any location of your choice.
+
+This distribution is meant for developer-type usage in Unix environments, it is
+*not* an easy way to get IPython working on Windows, since it assumes the
+presence of a working compiler and development tools.
+
+Currently, the distribution contains::
+
+  ipython-0.9.1.tar.gz
+  pyOpenSSL-0.6.tar.gz
+  zope.interface-3.4.1.tar.gz
+  Twisted-8.1.0.tar.bz2
+  foolscap-0.3.1.tar.gz
+  nose-0.10.3.tar.gz
+
+
+Usage
+=====
+
+Download the single tarball where this README file lives and unpack it.  If
+your system is already configured as described below, these lines will do the
+whole job::
+
+    wget http://ipython.scipy.org/dist/alldeps/ipython-alldeps-0.9.1.tar
+    tar xf ipython-alldeps-0.9.1.tar
+    cd ipython-alldeps-0.9.1
+    make
+
+If all goes well, then just type::
+
+    iptest
+
+to run IPython's test suite.
+
+    
+It is meant to be used in an environment where you have your ``$PATH``,
+``$PYTHONPATH``, etc variables properly configured, so that the installation of
+packages can be made with (using ``~/usr/local`` as an example)::
+
+    python setup.py install --prefix=~/usr/local
+
+For an explanation of how to do this, see below.
+
+You can configure the default prefix used by editing the file
+``pkginstall.cfg``, where you can also override the python version used for the
+process.  If your system is configured in this manner, you can simply type::
+
+    make
+
+and this will build and install all of IPython's non-graphical dependencies on
+your system, assuming you have Python, a compiler, the Python headers and the
+SSL headers available.
+
+
+.. _environment_configuration:
+
+Environment configuration
+=========================
+
+Below is an example of what to put in your ``~/.bashrc`` file to configure your
+environment as described in this document, in a reasonably portable manner that
+takes 64-bit operating systems into account::
+
+  # For processor dependent config
+  MACHINE=$(uname -m)
+
+  # Python version information
+  PYVER=$(python -ESV 2>&1)
+  PYVER_MINOR=${PYVER#Python }
+  PYVER_MAJOR=${PYVER_MINOR:0:3}
+
+  function export_paths {
+      # Export useful paths based on a common prefix
+
+      # Input: a path prefix
+
+      local prefix=$1
+      local pp
+      local lp
+      local pypath=python${PYVER_MAJOR}/site-packages
+
+      # Compute paths with 64-bit specifics
+      if [[ $MACHINE == "x86_64" ]]; then
+	  lp=$prefix/lib64:$prefix/lib
+	  pp=$prefix/lib64/$pypath:$prefix/lib/$pypath
+      else	
+	  lp=$prefix/lib
+	  pp=$prefix/lib/$pypath
+      fi
+
+      # Set paths based on given prefix
+      export PATH=$prefix/bin:$PATH
+      export CPATH=$prefix/include:$CPATH
+      export LD_LIBRARY_PATH=$lp:$LD_LIBRARY_PATH
+      export LIBRARY_PATH=$lp:$LIBRARY_PATH
+      export PYTHONPATH=$pp:$PYTHONPATH
+  }
+
+  # Actually call the export function to set the paths.  If you want more than
+  # one such prefix, note that the call *prepends* the new prefix to the
+  # existing paths, so later calls take priority.
+
+  export_paths $HOME/usr/local

tools/alldeps/pkginstall

@@ -0,0 +1,119 b''
+#!/bin/bash
+#
+# Simple installation shell script for Python packages.
+#
+# Usage:
+#   pkginstall PAKPREFIX [PYPACKAGE]
+#
+# PAKPREFIX: prefix of the package as distributed in the tarball.
+#
+# PYPACKAGE: name of the Python package as it will end up installed.  If not
+# given, it defaults to PAKPREFIX.
+#
+
+#-----------------------------------------------------------------------------
+# Process command-line args
+#
+PAKPREFIX=$1
+PYPACKAGE=${2:-$PAKPREFIX}
+
+#-----------------------------------------------------------------------------
+# Configure main variables
+#
+# Defaults for variables that the .cfg file may override.
+PYTHON_DEFAULT=python
+PREFIX_DEFAULT=$HOME/usr/local
+
+# Read config file which may declare user values for these variables.
+source ./pkginstall.cfg
+
+# Set the variables we'll actually use, either from the config file or from our
+# defaults.
+PYTHON=${PYTHON-${PYTHON_DEFAULT}}
+PREFIX=${PREFIX-${PREFIX_DEFAULT}}
+
+#-----------------------------------------------------------------------------
+# 'Main' code begins
+#
+
+# Find the actual python executable path
+PYTHONX=$(which $PYTHON)
+if [[ ! -x $PYTHONX ]]; then
+    echo "ERROR: no python executable found at given path: $PYTHON"
+    echo "Aborting."
+    exit 1
+fi    
+
+# Python version information.  PYTHONV holds a versioned string used to build
+# the site-packages path for the actual Python version we'll use.
+PYVER=$($PYTHONX -ESV 2>&1)
+PYVER_MINOR=${PYVER#Python }
+PYVER_MAJOR=${PYVER_MINOR:0:3}
+PYTHONV=python${PYVER_MAJOR}
+
+# Set prefixes and other variables for the installation path.
+SITEPKG=${PREFIX}/lib/${PYTHONV}/site-packages
+SITEPKG64=${PREFIX}/lib64/${PYTHONV}/site-packages
+
+# User diagnostics of current config
+echo "Configuration:"
+echo "  PYTHON   : $PYTHON"
+echo "  PYTHONX  : $PYTHONX"
+echo "  PREFIX   : $PREFIX"
+echo "  SITEPKG  : $SITEPKG"
+echo "  SITEPKG64: $SITEPKG64"
+
+# Find tarball
+tarball=$(ls *$PAKPREFIX*.tar.*)
+
+if [[ -z $tarball ]]; then
+    echo "ERROR: tarball not found for $PYPACKAGE"
+    exit 1
+fi
+
+# Figure out the name of the directory and compression format to use to unpack
+pakdir=$(echo $tarball | awk -F '.tar.' '{print $1}')
+tarfmt=$(echo $tarball | awk -F '.tar.' '{print $2}')
+
+if [[ $tarfmt == "gz" ]]; then
+    tarflag="z"
+else
+    tarflag="j"
+fi
+
+# Unpack the tarball if needed
+if [[ ! -d $pakdir ]]; then
+    echo "Unpacking tarball: $tarball"
+    tar -x -${tarflag} -f $tarball
+
+        if [[ ! -d $pakdir ]]; then
+	echo "Tarball $tarball unpacked to unexpected path, aborting"
+	exit 1
+    fi
+fi
+
+# Remove existing ${PYPACKAGE} to make sure the build doesn't pick up spurious
+# things.  We don't touch the bin/ dir or anything else because it's hard to
+# know what goes there in advance.  But this should prevent most serious
+# problems.
+rm -rf $SITEPKG/${PYPACKAGE}
+rm -rf $SITEPKG/${PYPACKAGE}*.egg
+rm -rf $SITEPKG/${PYPACKAGE}*.egg-info
+
+rm -rf $SITEPKG64/${PYPACKAGE}
+rm -rf $SITEPKG64/${PYPACKAGE}*.egg
+rm -rf $SITEPKG64/${PYPACKAGE}*.egg-info
+
+# Make/install phase
+
+# Set python search path correctly
+export PYTHONPATH=$SITEPKG:$SITEPKG64:$PYTHONPATH
+
+# Ensure install dirs exist
+mkdir -p $SITEPKG
+mkdir -p $SITEPKG64
+
+cd ${pakdir}
+rm -rf build dist
+$PYTHONX setup.py clean
+time $PYTHONX setup.py install --prefix=$PREFIX

tools/alldeps/pkginstall.cfg

@@ -0,0 +1,27 b''
+# -*- sh -*-
+#
+# Configuration for the pkginstall script.
+# This script uses bash syntax, as it will be sourced by a bash script.
+
+# Uncomment and set the variables you want, otherwise pkginstall has sensible
+# defaults predefined.  These can also be declared either as environment
+# variables (which can be done by the makefile calling this script).
+
+#-----------------------------------------------------------------------------
+#
+# Executable for Python.
+#
+# You can set this to an explicit full path if you don't want the default
+# (simply 'python') to be the version used to install this package.
+
+#PYTHON=python
+
+#-----------------------------------------------------------------------------
+#
+# Default prefix.
+#
+# This should be a valid input the setup.py script as the --prefix argument.
+# That is, your $PYTHONPATH should contain $PREFIX/lib/pythonX.Y/site-packages,
+# your $PATH should contain $PREFIX/bin, etc.
+
+#PREFIX=$HOME/usr/local

IPython/ColorANSI.py

@@ -1,7 +1,6 b''
 # -*- coding: utf-8 -*-
 """Tools for coloring text in ANSI terminals.
-
-$Id: ColorANSI.py 2167 2007-03-21 06:57:50Z fperez $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2002-2006 Fernando Perez. <[e-mail]>
@@ -10,10 +9,6 b' $Id: ColorANSI.py 2167 2007-03-21 06:57:50Z fperez $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 __all__ = ['TermColors','InputTermColors','ColorScheme','ColorSchemeTable']
 
 import os

IPython/ConfigLoader.py

@@ -1,7 +1,6 b''
 # -*- coding: utf-8 -*-
 """Configuration loader
-
-$Id: ConfigLoader.py 1005 2006-01-12 08:39:26Z fperez $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
@@ -10,10 +9,6 b' $Id: ConfigLoader.py 1005 2006-01-12 08:39:26Z fperez $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 import exceptions
 import os
 from pprint import pprint
@@ -73,14 +68,14 b' class ConfigLoader:'
         # avoid including the same file more than once
         if fname in self.included:
             return data
-        Xinfo = ultraTB.AutoFormattedTB()
+        Xinfo = ultraTB.AutoFormattedTB(color_scheme='NoColor')
         if convert==None and recurse_key : convert = {qwflat:recurse_key}
         # for production, change warn to 0:
         data.merge(read_dict(fname,convert,fs=self.field_sep,strip=1,
                              warn=0,no_empty=0,**kw))
         # keep track of successfully loaded files
         self.included.append(fname)
-        if recurse_key in data.keys():
+        if recurse_key in data:
             for incfilename in data[recurse_key]:
                 found=0
                 try:

IPython/CrashHandler.py

@@ -1,20 +1,20 b''
 # -*- coding: utf-8 -*-
 """sys.excepthook for IPython itself, leaves a detailed report on disk.
 
-$Id: CrashHandler.py 2908 2007-12-30 21:07:46Z vivainio $"""
+
+Authors
+-------
+- Fernando Perez <[e-mail]>
+"""
 
 #*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
+#       Copyright (C) 2008-2009 The IPython Development Team
+#       Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__   = '%s <%s>' % Release.authors['Fernando']
-__license__  = Release.license
-__version__  = Release.version
-
 #****************************************************************************
 # Required modules
 
@@ -23,10 +23,12 b' import os'
 import sys
 from pprint import pprint,pformat
 
-# Homebrewed
-from IPython.Itpl import Itpl,itpl,printpl
-from IPython.ColorANSI import ColorScheme,ColorSchemeTable  # too long names
+# Our own
+from IPython import Release
 from IPython import ultraTB
+from IPython.ColorANSI import ColorScheme,ColorSchemeTable  # too long names
+from IPython.Itpl import Itpl,itpl,printpl
+
 from IPython.genutils import *
 
 #****************************************************************************
@@ -166,7 +168,7 b' $self.bug_tracker'
         
         rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
         rpt_add('IPython version: %s \n\n' % Release.version)
-        rpt_add('SVN revision   : %s \n\n' % Release.revision)
+        rpt_add('BZR revision   : %s \n\n' % Release.revision)
         rpt_add('Platform info  : os.name -> %s, sys.platform -> %s' %
                      (os.name,sys.platform) )
         rpt_add(sec_sep+'Current user configuration structure:\n\n')
@@ -193,7 +195,7 b' class IPythonCrashHandler(CrashHandler):'
         
         # Set argument defaults
         app_name = 'IPython'
-        bug_tracker = 'http://projects.scipy.org/ipython/ipython/report'
+        bug_tracker = 'https://bugs.launchpad.net/ipython/+filebug'
         contact_name,contact_email = Release.authors[AUTHOR_CONTACT][:2]
         crash_report_fname = 'IPython_crash_report.txt'
         # Call parent constructor
@@ -210,7 +212,7 b' class IPythonCrashHandler(CrashHandler):'
         
         rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
         rpt_add('IPython version: %s \n\n' % Release.version)
-        rpt_add('SVN revision   : %s \n\n' % Release.revision)
+        rpt_add('BZR revision   : %s \n\n' % Release.revision)
         rpt_add('Platform info  : os.name -> %s, sys.platform -> %s' %
                      (os.name,sys.platform) )
         rpt_add(sec_sep+'Current user configuration structure:\n\n')

IPython/DPyGetOpt.py

@@ -1,8 +1,6 b''
 # -*- coding: utf-8 -*-
 """DPyGetOpt -- Demiurge Python GetOptions Module
 
- $Id: DPyGetOpt.py 2872 2007-11-25 17:58:05Z fperez $
-
 This module is modeled after perl's Getopt::Long module-- which
 is, in turn, modeled after GNU's extended getopt() function.
 
@@ -32,8 +30,7 b" characters; ie-- 'foo|bar|baz=f@' specifies that all -foo, -bar,"
 and -baz options that appear on within the parsed argument list
 must have a real number argument and that the accumulated list
 of values will be available under the name 'foo'
-
-$Id: DPyGetOpt.py 2872 2007-11-25 17:58:05Z fperez $"""
+"""
 
 #*****************************************************************************
 #

IPython/Debugger.py

@@ -13,9 +13,7 b' The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor'
 changes. Licensing should therefore be under the standard Python terms.  For
 details on the PSF (Python Software Foundation) standard license, see:
 
-http://www.python.org/2.2.3/license.html
-
-$Id: Debugger.py 2913 2007-12-31 12:42:14Z vivainio $"""
+http://www.python.org/2.2.3/license.html"""
 
 #*****************************************************************************
 #
@@ -27,10 +25,6 b' $Id: Debugger.py 2913 2007-12-31 12:42:14Z vivainio $"""'
 #
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = 'Python'
-
 import bdb
 import cmd
 import linecache
@@ -39,7 +33,7 b' import sys'
 
 from IPython import PyColorize, ColorANSI, ipapi
 from IPython.genutils import Term
-from IPython.excolors import ExceptionColors
+from IPython.excolors import exception_colors
 
 # See if we can use pydb.
 has_pydb = False
@@ -210,7 +204,7 b' class Pdb(OldPdb):'
 
             # Create color table: we copy the default one from the traceback
             # module and add a few attributes needed for debugging
-            self.color_scheme_table = ExceptionColors.copy()
+            self.color_scheme_table = exception_colors()
 
             # shorthands 
             C = ColorANSI.TermColors
@@ -257,8 +251,7 b' class Pdb(OldPdb):'
 
             # Create color table: we copy the default one from the traceback
             # module and add a few attributes needed for debugging
-            ExceptionColors.set_active_scheme(color_scheme)
-            self.color_scheme_table = ExceptionColors.copy()
+            self.color_scheme_table = exception_colors()
 
             # shorthands 
             C = ColorANSI.TermColors

IPython/Extensions/InterpreterExec.py

@@ -4,8 +4,7 b''
 We define a special input line filter to allow typing lines which begin with
 '~', '/' or '.'. If one of those strings is encountered, it is automatically
 executed.
-
-$Id: InterpreterExec.py 2724 2007-09-07 08:05:38Z fperez $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2004 W.J. van der Laan <[e-mail]>
@@ -15,11 +14,6 b' $Id: InterpreterExec.py 2724 2007-09-07 08:05:38Z fperez $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__ = 'W.J. van der Laan <[e-mail]>, '\
-             '%s <%s>' %  Release.authors['Fernando']
-__license__ = Release.license
-
 # TODO: deprecated
 def prefilter_shell(self,line,continuation):
     """Alternate prefilter, modified for shell-like functionality.

IPython/Extensions/InterpreterPasteInput.py

@@ -48,19 +48,21 b' In [4]: >>> for i in range(len(a)):'
 2 a
 3 little
 4 lamb
+
+
+Authors
+-------
+- Fernando Perez <[e-mail]>
 """
 
 #*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
+#       Copyright (C) 2008-2009 The IPython Development Team
+#       Copyright (C) 2001-2007 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 # This file is an example of how to modify IPython's line-processing behavior
 # without touching the internal code. We'll define an alternate pre-processing
 # stage which allows a special form of input (which is invalid Python syntax)

IPython/Extensions/PhysicalQInput.py

@@ -12,18 +12,19 b' g = 9.8 m/s**2'
 a = 2.3 m/s^2   # ^ -> ** automatically
 
 All other input is processed normally.
+
+Authors
+-------
+- Fernando Perez <[e-mail]>
 """
 #*****************************************************************************
-#       Copyright (C) 2001-2004 Fernando Perez <[e-mail]>
+#       Copyright (C) 2008-2009 The IPython Development Team
+#       Copyright (C) 2001-2007 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 # This file is an example of how to modify IPython's line-processing behavior
 # without touching the internal code. We'll define an alternate pre-processing
 # stage which allows a special form of input (which is invalid Python syntax)

IPython/Extensions/PhysicalQInteractive.py

@@ -6,19 +6,21 b' special method syntax. This just means moving them out to the global'
 namespace.
 
 This module should always be loaded *after* math or Numeric, so it can
-overwrite math functions with the versions that handle units."""
+overwrite math functions with the versions that handle units.
+
+Authors
+-------
+- Fernando Perez <[e-mail]>
+"""
 
 #*****************************************************************************
-#       Copyright (C) 2001-2004 Fernando Perez <[e-mail]>
+#       Copyright (C) 2008-2009 The IPython Development Team
+#       Copyright (C) 2001-2007 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 from Scientific.Physics.PhysicalQuantities import PhysicalQuantity
 
 # This code can be set up to work with Numeric or with math for providing the

IPython/Extensions/clearcmd.py

@@ -5,43 +5,65 b' import IPython.ipapi'
 import gc
 ip = IPython.ipapi.get()
 
-
 def clear_f(self,arg):
     """ Clear various data (e.g. stored history data)
     
-    %clear out - clear output history
     %clear in  - clear input history
+    %clear out - clear output history
     %clear shadow_compress - Compresses shadow history (to speed up ipython)
     %clear shadow_nuke - permanently erase all entries in shadow history
     %clear dhist - clear dir history
+    %clear array - clear only variables that are NumPy arrays
+    
+    Examples:
+
+    In [1]: clear in
+    Flushing input history
+
+    In [2]: clear shadow_compress
+    Compressing shadow history
+
+    In [3]: clear shadow_nuke
+    Erased all keys from shadow history
+
+    In [4]: clear dhist
+    Clearing directory history
     """
     
     api = self.getapi()
+    user_ns = self.user_ns  # local lookup, heavily used
+        
+    
     for target in arg.split():
+
         if target == 'out':
-            print "Flushing output cache (%d entries)" % len(api.user_ns['_oh'])
+            print "Flushing output cache (%d entries)" % len(user_ns['_oh'])
             self.outputcache.flush()
+
         elif target == 'in':
             print "Flushing input history"
-            from IPython import iplib
             pc = self.outputcache.prompt_count + 1
             for n in range(1, pc):
                 key = '_i'+`n`
+                user_ns.pop(key,None)
                 try:
-                    del self.user_ns[key]
+                    del user_ns[key]
                 except: pass
             # must be done in-place
             self.input_hist[:] = ['\n'] * pc 
             self.input_hist_raw[:] = ['\n'] * pc
+
         elif target == 'array':
+            # Support cleaning up numpy arrays
             try:
-                pylab=ip.IP.pylab
-                for x in self.user_ns.keys():
-                    if isinstance(self.user_ns[x],pylab.arraytype):
-                        del self.user_ns[x]
+                from numpy import ndarray
+                # This must be done with items and not iteritems because we're
+                # going to modify the dict in-place.
+                for x,val in user_ns.items():
+                    if isinstance(val,ndarray):
+                        del user_ns[x]
             except AttributeError:
-                print "Clear array only available in -pylab mode"
-            gc.collect()                
+                print "Clear array only works if Numpy is available."
 
         elif target == 'shadow_compress':
             print "Compressing shadow history"
@@ -51,16 +73,15 b' def clear_f(self,arg):'
             print "Erased all keys from shadow history "
             for k in ip.db.keys('shadowhist/*'):
                 del ip.db[k]
+
         elif target == 'dhist':
             print "Clearing directory history"
-            del ip.user_ns['_dh'][:]
+            del user_ns['_dh'][:]
 
-            
+    gc.collect()        
+
+# Activate the extension
 ip.expose_magic("clear",clear_f)
 import ipy_completers
 ipy_completers.quick_completer(
- '%clear','in out shadow_nuke shadow_compress dhist')
-    
-
-
-
+    '%clear','in out shadow_nuke shadow_compress dhist')

IPython/Extensions/ext_rescapture.py

@@ -6,9 +6,6 b' Provides'
 var = %magic blah blah
 
 var = !ls
-
-$Id: genutils.py 1077 2006-01-24 18:15:27Z vivainio $
-
 """
 
 import IPython.ipapi

IPython/Extensions/ipy_profile_zope.py

@@ -1,19 +1,22 b''
 # -*- coding: utf-8 -*-
-#
+""" An ipython profile for zope and plone.
+
+Some ideas stolen from http://www.tomster.org.
+
+
+Authors
+-------
+- Stefan Eletzhofer <[e-mail]>
+"""
+
 # File: ipy_profile_zope.py
 #
 # Copyright (c) InQuant GmbH
 #
-# An ipython profile for zope and plone. Some ideas
-# stolen from http://www.tomster.org.
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 
-__author__ = """Stefan Eletzhofer <[e-mail]>"""
-__docformat__ = 'plaintext'
-__revision__ = "$Revision$"
-
 from IPython import ipapi
 from IPython import Release
 from types import StringType

IPython/Extensions/ipy_winpdb.py

@@ -7,6 +7,16 b' Usage:'
     
 %wdb pass
     Change the password (e.g. if you have forgotten the old one)
+
+
+Notes
+-----
+
+**WARNING**: As of March 2009 (IPython 0.10), WinPdb has a known bug, which
+causes PyTables to become impossible to import if winpdb is loaded.  Therefore,
+if you need PyTables, do *not* use this extension.
+
+For more details: https://bugs.launchpad.net/ipython/+bug/249036
 """
 
 import os

IPython/Extensions/pickleshare.py

@@ -40,8 +40,6 b' import UserDict'
 import warnings
 import glob
 
-from sets import Set as set
-
 def gethashfile(key):
     return ("%02x" % abs(hash(key) % 256))[-2:]
 

IPython/Extensions/pspersistence.py

@@ -3,8 +3,6 b''
 %store magic for lightweight persistence.
 
 Stores variables, aliases etc. in PickleShare database.
-
-$Id: iplib.py 1107 2006-01-30 19:02:20Z vivainio $
 """
 
 import IPython.ipapi

IPython/FakeModule.py

@@ -4,8 +4,7 b' Class which mimics a module.'
 
 Needed to allow pickle to correctly resolve namespaces during IPython
 sessions.
-
-$Id: FakeModule.py 2754 2007-09-09 10:16:59Z fperez $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2002-2004 Fernando Perez. <[e-mail]>

IPython/Gnuplot2.py

@@ -12,8 +12,7 b' This module is meant to be used as a drop-in replacement to the original'
 Gnuplot, so it should be safe to do:
 
 import IPython.Gnuplot2 as Gnuplot
-
-$Id: Gnuplot2.py 1210 2006-03-13 01:19:31Z fperez $"""
+"""
 
 import cStringIO
 import os

IPython/GnuplotInteractive.py

@@ -9,8 +9,7 b' http://gnuplot-py.sourceforge.net/'
 See gphelp() below for details on the services offered by this module.
 
 Inspired by a suggestion/request from Arnd Baecker.
-
-$Id: GnuplotInteractive.py 389 2004-10-09 07:59:30Z fperez $"""
+"""
 
 __all__ = ['Gnuplot','gp','gp_new','plot','plot2','splot','replot',
            'hardcopy','gpdata','gpfile','gpstring','gpfunc','gpgrid',

IPython/GnuplotRuntime.py

@@ -47,8 +47,7 b' can be downloaded from:'
 http://gnuplot-py.sourceforge.net/
 
 Inspired by a suggestion/request from Arnd Baecker.
-
-$Id: GnuplotRuntime.py 389 2004-10-09 07:59:30Z fperez $"""
+"""
 
 __all__ = ['Gnuplot','gp','gp_new','Data','File','Func','GridData',
            'pm3d_config','eps_fix_bbox']

IPython/Itpl.py

@@ -27,7 +27,7 b' how to do interpolation:'
     import Itpl
     sys.stdout = Itpl.filter()
     f = "fancy"
-    print "Isn't this $f?"
+    print "Is this not $f?"
     print "Standard output has been replaced with a $sys.stdout object."
     sys.stdout = Itpl.unfilter()
     print "Okay, back $to $normal."
@@ -43,9 +43,7 b' each time the instance is evaluated with str(instance). For example:'
     print str(s)
     foo = "bar"
     print str(s)
-
-$Id: Itpl.py 2918 2007-12-31 14:34:47Z vivainio $
-"""                   # ' -> close an open quote for stupid emacs
+"""
 
 #*****************************************************************************
 #

IPython/Logger.py

@@ -1,8 +1,6 b''
 # -*- coding: utf-8 -*-
 """
 Logger class for IPython's logging facilities.
-
-$Id: Logger.py 2875 2007-11-26 08:37:39Z fperez $
 """
 
 #*****************************************************************************
@@ -16,11 +14,6 b' $Id: Logger.py 2875 2007-11-26 08:37:39Z fperez $'
 #****************************************************************************
 # Modules and globals
 
-from IPython import Release
-__author__  = '%s <%s>\n%s <%s>' % \
-              ( Release.authors['Janko'] + Release.authors['Fernando'] )
-__license__ = Release.license
-
 # Python standard modules
 import glob
 import os

IPython/Magic.py

@@ -1,7 +1,6 b''
 # -*- coding: utf-8 -*-
 """Magic functions for InteractiveShell.
-
-$Id: Magic.py 2996 2008-01-30 06:31:39Z fperez $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2001 Janko Hauser <[e-mail]> and
@@ -14,11 +13,6 b' $Id: Magic.py 2996 2008-01-30 06:31:39Z fperez $"""'
 #****************************************************************************
 # Modules and globals
 
-from IPython import Release
-__author__  = '%s <%s>\n%s <%s>' % \
-              ( Release.authors['Janko'] + Release.authors['Fernando'] )
-__license__ = Release.license
-
 # Python standard modules
 import __builtin__
 import bdb
@@ -35,7 +29,6 b' import textwrap'
 from cStringIO import StringIO
 from getopt import getopt,GetoptError
 from pprint import pprint, pformat
-from sets import Set
 
 # cProfile was added in Python2.5
 try:
@@ -75,7 +68,7 b' def compress_dhist(dh):'
     head, tail = dh[:-10], dh[-10:]
 
     newhead = []
-    done = Set()
+    done = set()
     for h in head:
         if h in done:
             continue
@@ -149,7 +142,7 b' python-profiler package from non-free.""")'
                  filter(inst_magic,self.__dict__.keys()) + \
                  filter(inst_bound_magic,self.__class__.__dict__.keys())
         out = []
-        for fn in Set(magics):
+        for fn in set(magics):
             out.append(fn.replace('magic_','',1))
         out.sort()
         return out
@@ -1054,10 +1047,33 b' Currently the magic system has the following functions:\\n"""'
     def magic_reset(self, parameter_s=''):
         """Resets the namespace by removing all names defined by the user.
 
-        Input/Output history are left around in case you need them."""
+        Input/Output history are left around in case you need them.
+
+        Parameters
+        ----------
+          -y : force reset without asking for confirmation.
+
+        Examples
+        --------
+        In [6]: a = 1
+
+        In [7]: a
+        Out[7]: 1
+
+        In [8]: 'a' in _ip.user_ns
+        Out[8]: True
 
-        ans = self.shell.ask_yes_no(
-          "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
+        In [9]: %reset -f
+
+        In [10]: 'a' in _ip.user_ns
+        Out[10]: False
+        """
+
+        if parameter_s == '-f':
+            ans = True
+        else:
+            ans = self.shell.ask_yes_no(
+                "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
         if not ans:
             print 'Nothing done.'
             return
@@ -1067,7 +1083,7 b' Currently the magic system has the following functions:\\n"""'
             
         # Also flush the private list of module references kept for script
         # execution protection
-        self.shell._user_main_modules[:] = []
+        self.shell.clear_main_mod_cache()
 
     def magic_logstart(self,parameter_s=''):
         """Start logging anywhere in a session.
@@ -1426,7 +1442,8 b' Currently the magic system has the following functions:\\n"""'
             return None
 
     @testdec.skip_doctest
-    def magic_run(self, parameter_s ='',runner=None):
+    def magic_run(self, parameter_s ='',runner=None,
+                  file_finder=get_py_filename):
         """Run the named file inside IPython as a program.
 
         Usage:\\
@@ -1541,7 +1558,7 b' Currently the magic system has the following functions:\\n"""'
                                           mode='list',list_all=1)
 
         try:
-            filename = get_py_filename(arg_lst[0])
+            filename = file_finder(arg_lst[0])
         except IndexError:
             warn('you must provide at least a filename.')
             print '\n%run:\n',OInspect.getdoc(self.magic_run)
@@ -1577,10 +1594,13 b' Currently the magic system has the following functions:\\n"""'
             main_mod = FakeModule()
             prog_ns = main_mod.__dict__
             prog_ns['__name__'] = name
+            
             # The shell MUST hold a reference to main_mod so after %run exits,
             # the python deletion mechanism doesn't zero it out (leaving
-            # dangling references)
-            self.shell._user_main_modules.append(main_mod)
+            # dangling references).  However, we should drop old versions of
+            # main_mod.  There is now a proper API to manage this caching in
+            # the main shell object, we use that.            
+            self.shell.cache_main_mod(main_mod)
 
         # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
         # set the __file__ global in the script's namespace

IPython/OInspect.py

@@ -5,8 +5,6 b' Uses syntax highlighting for presenting the various information elements.'
 
 Similar in spirit to the inspect module, but all calls take a name argument to
 reference the name under which an object is being read.
-
-$Id: OInspect.py 2843 2007-10-15 21:22:32Z fperez $
 """
 
 #*****************************************************************************
@@ -16,10 +14,6 b' $Id: OInspect.py 2843 2007-10-15 21:22:32Z fperez $'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 __all__ = ['Inspector','InspectColors']
 
 # stdlib modules

IPython/OutputTrap.py

@@ -1,7 +1,6 b''
 # -*- coding: utf-8 -*-
 """Class to trap stdout and stderr and log them separately.
-
-$Id: OutputTrap.py 958 2005-12-27 23:17:51Z fperez $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2001-2004 Fernando Perez <[e-mail]>
@@ -10,10 +9,6 b' $Id: OutputTrap.py 958 2005-12-27 23:17:51Z fperez $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 import exceptions
 import sys
 from cStringIO import StringIO

IPython/Prompts.py

@@ -1,21 +1,16 b''
 # -*- coding: utf-8 -*-
 """
 Classes for handling input/output prompts.
-
-$Id: Prompts.py 3026 2008-02-07 16:03:16Z vivainio $"""
+"""
 
 #*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
+#       Copyright (C) 2008-2009 The IPython Development Team
+#       Copyright (C) 2001-2007 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-__version__ = Release.version
-
 #****************************************************************************
 # Required modules
 import __builtin__
@@ -26,11 +21,13 b' import time'
 
 # IPython's own
 from IPython import ColorANSI
-from IPython.Itpl import ItplNS
+from IPython import Release
+from IPython.external.Itpl import ItplNS
+from IPython.ipapi import TryNext
 from IPython.ipstruct import Struct
 from IPython.macro import Macro
+
 from IPython.genutils import *
-from IPython.ipapi import TryNext
 
 #****************************************************************************
 #Color schemes for Prompts.
@@ -168,7 +165,7 b' prompt_specials_color = {'
     # Carriage return
     r'\r': '\r',
     # Release version
-    r'\v': __version__,
+    r'\v': Release.version,
     # Root symbol ($ or #)
     r'\$': ROOT_SYMBOL,
     }

IPython/PyColorize.py

@@ -1,34 +1,33 b''
 # -*- coding: utf-8 -*-
 """
-    Class and program to colorize python source code for ANSI terminals.
+Class and program to colorize python source code for ANSI terminals.
 
-    Based on an HTML code highlighter by Jurgen Hermann found at:
-    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52298
+Based on an HTML code highlighter by Jurgen Hermann found at:
+http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52298
 
-    Modifications by Fernando Perez ([e-mail]).
+Modifications by Fernando Perez ([e-mail]).
 
-    Information on the original HTML highlighter follows:
-    
-    MoinMoin - Python Source Parser
+Information on the original HTML highlighter follows:
 
-    Title: Colorize Python source using the built-in tokenizer
-           
-    Submitter: Jurgen Hermann
-    Last Updated:2001/04/06
-           
-    Version no:1.2
+MoinMoin - Python Source Parser
 
-    Description:
+Title: Colorize Python source using the built-in tokenizer
 
-    This code is part of MoinMoin (http://moin.sourceforge.net/) and converts
-    Python source code to HTML markup, rendering comments, keywords,
-    operators, numeric and string literals in different colors.
+Submitter: Jurgen Hermann
+Last Updated:2001/04/06
 
-    It shows how to use the built-in keyword, token and tokenize modules to
-    scan Python source code and re-emit it with no changes to its original
-    formatting (which is the hard part).
+Version no:1.2
 
-    $Id: PyColorize.py 2586 2007-08-06 19:30:09Z vivainio $"""
+Description:
+
+This code is part of MoinMoin (http://moin.sourceforge.net/) and converts
+Python source code to HTML markup, rendering comments, keywords,
+operators, numeric and string literals in different colors.
+
+It shows how to use the built-in keyword, token and tokenize modules to
+scan Python source code and re-emit it with no changes to its original
+formatting (which is the hard part).
+"""
 
 __all__ = ['ANSICodeColors','Parser']
 

IPython/Shell.py

@@ -3,8 +3,7 b''
 
 All the matplotlib support code was co-developed with John Hunter,
 matplotlib's author.
-
-$Id: Shell.py 3024 2008-02-07 15:34:42Z darren.dale $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
@@ -13,10 +12,6 b' $Id: Shell.py 3024 2008-02-07 15:34:42Z darren.dale $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 # Code begins
 # Stdlib imports
 import __builtin__

IPython/UserConfig/ipythonrc

@@ -1,5 +1,4 b''
 # -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
-# $Id: ipythonrc 2156 2007-03-19 02:32:19Z fperez $
 
 #***************************************************************************
 #

IPython/__init__.py

@@ -25,12 +25,12 b' IPython tries to:'
 
   iii - serve as an embeddable, ready to go interpreter for your own programs.
 
-IPython requires Python 2.3 or newer.
-
-$Id: __init__.py 2399 2007-05-26 10:23:10Z vivainio $"""
+IPython requires Python 2.4 or newer.
+"""
 
 #*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
+#       Copyright (C) 2008-2009 The IPython Development Team
+#       Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.

IPython/background_jobs.py

@@ -17,8 +17,6 b' http://folk.uio.no/hpl/scripting'
 
 (although ultimately no code from this text was used, as IPython's system is a
 separate implementation).
-
-$Id: background_jobs.py 994 2006-01-08 08:29:44Z fperez $
 """
 
 #*****************************************************************************
@@ -28,10 +26,6 b' $Id: background_jobs.py 994 2006-01-08 08:29:44Z fperez $'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 # Code begins
 import sys
 import threading

IPython/completer.py

@@ -6,7 +6,6 b' 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

IPython/deep_reload.py

@@ -12,8 +12,7 b' Alternatively, you can add a dreload builtin alongside normal reload with:'
     >>> __builtin__.dreload = deep_reload.reload
     
 This code is almost entirely based on knee.py from the standard library.
-
-$Id: deep_reload.py 958 2005-12-27 23:17:51Z fperez $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2001 Nathaniel Gray <[e-mail]>
@@ -22,12 +21,6 b' $Id: deep_reload.py 958 2005-12-27 23:17:51Z fperez $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release # do it explicitly so pydoc can see it - pydoc bug
-__author__  = '%s <%s>' %  Release.authors['Nathan']
-__license__ = Release.license
-__version__ = "0.5"
-__date__    = "21 August 2001"
-
 import __builtin__
 import imp
 import sys

IPython/excolors.py

@@ -1,8 +1,7 b''
 # -*- coding: utf-8 -*-
 """
 Color schemes for exception handling code in IPython.
-
-$Id: Prompts.py 638 2005-07-18 03:01:41Z fperez $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2005-2006 Fernando Perez <[e-mail]>
@@ -11,99 +10,128 b' $Id: Prompts.py 638 2005-07-18 03:01:41Z fperez $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-__version__ = Release.version
-
 #****************************************************************************
 # Required modules
 from IPython.ColorANSI import ColorSchemeTable, TermColors, ColorScheme
 
-ExceptionColors = ColorSchemeTable()
-
-# Populate it with color schemes
-C = TermColors # shorthand and local lookup
-ExceptionColors.add_scheme(ColorScheme(
-    'NoColor',
-    # The color to be used for the top line
-    topline = C.NoColor,
-
-    # The colors to be used in the traceback
-    filename = C.NoColor,
-    lineno = C.NoColor,
-    name = C.NoColor,
-    vName = C.NoColor,
-    val = C.NoColor,
-    em = C.NoColor,
-    
-    # Emphasized colors for the last frame of the traceback
-    normalEm = C.NoColor,
-    filenameEm = C.NoColor,
-    linenoEm = C.NoColor,
-    nameEm = C.NoColor,
-    valEm = C.NoColor,
-    
-    # Colors for printing the exception
-    excName = C.NoColor,
-    line = C.NoColor,
-    caret = C.NoColor,
-    Normal = C.NoColor
-    ))
-
-# make some schemes as instances so we can copy them for modification easily
-ExceptionColors.add_scheme(ColorScheme(
-    'Linux',
-    # The color to be used for the top line
-    topline = C.LightRed,
-
-    # The colors to be used in the traceback
-    filename = C.Green,
-    lineno = C.Green,
-    name = C.Purple,
-    vName = C.Cyan,
-    val = C.Green,
-    em = C.LightCyan,
-
-    # Emphasized colors for the last frame of the traceback
-    normalEm = C.LightCyan,
-    filenameEm = C.LightGreen,
-    linenoEm = C.LightGreen,
-    nameEm = C.LightPurple,
-    valEm = C.LightBlue,
-
-    # Colors for printing the exception
-    excName = C.LightRed,
-    line = C.Yellow,
-    caret = C.White,
-    Normal = C.Normal
-    ))
-
-# For light backgrounds, swap dark/light colors
-ExceptionColors.add_scheme(ColorScheme(
-    'LightBG',
-    # The color to be used for the top line
-    topline = C.Red,
+def exception_colors():
+    """Return a color table with fields for exception reporting.
+
+    The table is an instance of ColorSchemeTable with schemes added for
+    'Linux', 'LightBG' and 'NoColor' and fields for exception handling filled
+    in.
+
+    Examples:
+
+    >>> ec = exception_colors()
+    >>> ec.active_scheme_name
+    ''
+    >>> print ec.active_colors
+    None
+
+    Now we activate a color scheme:    
+    >>> ec.set_active_scheme('NoColor')
+    >>> ec.active_scheme_name
+    'NoColor'
+    >>> ec.active_colors.keys()
+    ['em', 'caret', '__allownew', 'name', 'val', 'vName', 'Normal', 'normalEm',
+    'filename', 'linenoEm', 'excName', 'lineno', 'valEm', 'filenameEm',
+    'nameEm', 'line', 'topline']
+    """
     
-    # The colors to be used in the traceback
-    filename = C.LightGreen,
-    lineno = C.LightGreen,
-    name = C.LightPurple,
-    vName = C.Cyan,
-    val = C.LightGreen,
-    em = C.Cyan,
-
-    # Emphasized colors for the last frame of the traceback
-    normalEm = C.Cyan,
-    filenameEm = C.Green,
-    linenoEm = C.Green,
-    nameEm = C.Purple,
-    valEm = C.Blue,
-
-    # Colors for printing the exception
-    excName = C.Red,
-    #line = C.Brown,  # brown often is displayed as yellow
-    line = C.Red,
-    caret = C.Normal,
-    Normal = C.Normal
-    ))
+    ex_colors = ColorSchemeTable()
+
+    # Populate it with color schemes
+    C = TermColors # shorthand and local lookup
+    ex_colors.add_scheme(ColorScheme(
+        'NoColor',
+        # The color to be used for the top line
+        topline = C.NoColor,
+
+        # The colors to be used in the traceback
+        filename = C.NoColor,
+        lineno = C.NoColor,
+        name = C.NoColor,
+        vName = C.NoColor,
+        val = C.NoColor,
+        em = C.NoColor,
+
+        # Emphasized colors for the last frame of the traceback
+        normalEm = C.NoColor,
+        filenameEm = C.NoColor,
+        linenoEm = C.NoColor,
+        nameEm = C.NoColor,
+        valEm = C.NoColor,
+
+        # Colors for printing the exception
+        excName = C.NoColor,
+        line = C.NoColor,
+        caret = C.NoColor,
+        Normal = C.NoColor
+        ))
+
+    # make some schemes as instances so we can copy them for modification easily
+    ex_colors.add_scheme(ColorScheme(
+        'Linux',
+        # The color to be used for the top line
+        topline = C.LightRed,
+
+        # The colors to be used in the traceback
+        filename = C.Green,
+        lineno = C.Green,
+        name = C.Purple,
+        vName = C.Cyan,
+        val = C.Green,
+        em = C.LightCyan,
+
+        # Emphasized colors for the last frame of the traceback
+        normalEm = C.LightCyan,
+        filenameEm = C.LightGreen,
+        linenoEm = C.LightGreen,
+        nameEm = C.LightPurple,
+        valEm = C.LightBlue,
+
+        # Colors for printing the exception
+        excName = C.LightRed,
+        line = C.Yellow,
+        caret = C.White,
+        Normal = C.Normal
+        ))
+
+    # For light backgrounds, swap dark/light colors
+    ex_colors.add_scheme(ColorScheme(
+        'LightBG',
+        # The color to be used for the top line
+        topline = C.Red,
+
+        # The colors to be used in the traceback
+        filename = C.LightGreen,
+        lineno = C.LightGreen,
+        name = C.LightPurple,
+        vName = C.Cyan,
+        val = C.LightGreen,
+        em = C.Cyan,
+
+        # Emphasized colors for the last frame of the traceback
+        normalEm = C.Cyan,
+        filenameEm = C.Green,
+        linenoEm = C.Green,
+        nameEm = C.Purple,
+        valEm = C.Blue,
+
+        # Colors for printing the exception
+        excName = C.Red,
+        #line = C.Brown,  # brown often is displayed as yellow
+        line = C.Red,
+        caret = C.Normal,
+        Normal = C.Normal,
+        ))
+
+    return ex_colors
+
+
+# For backwards compatibility, keep around a single global object.  Note that
+# this should NOT be used, the factory function should be used instead, since
+# these objects are stateful and it's very easy to get strange bugs if any code
+# modifies the module-level object's state.
+ExceptionColors = exception_colors()

IPython/external/Itpl.py

@@ -27,7 +27,7 b' how to do interpolation:'
     import Itpl
     sys.stdout = Itpl.filter()
     f = "fancy"
-    print "Isn't this $f?"
+    print "Is this not $f?"
     print "Standard output has been replaced with a $sys.stdout object."
     sys.stdout = Itpl.unfilter()
     print "Okay, back $to $normal."
@@ -43,9 +43,7 b' each time the instance is evaluated with str(instance). For example:'
     print str(s)
     foo = "bar"
     print str(s)
-
-$Id: Itpl.py 2305 2007-05-04 05:34:42Z bgranger $
-"""                   # ' -> close an open quote for stupid emacs
+"""
 
 #*****************************************************************************
 #

IPython/external/mglob.py

@@ -73,8 +73,6 b' __version__ = "0.2"'
 
 
 import os,glob,fnmatch,sys,re
-from sets import Set as set
-
                 
 def expand(flist,exp_dirs = False):
     """ Expand the glob(s) in flist.

IPython/genutils.py

@@ -1,11 +1,9 b''
 # -*- coding: utf-8 -*-
-"""
-General purpose utilities.
+"""General purpose utilities.
 
 This is a grab-bag of stuff I find useful in most programs I write. Some of
 these things are also convenient when working at the command line.
-
-$Id: genutils.py 2998 2008-01-31 10:06:04Z vivainio $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
@@ -14,10 +12,6 b' $Id: genutils.py 2998 2008-01-31 10:06:04Z vivainio $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 #****************************************************************************
 # required modules from the Python standard library
 import __main__
@@ -928,12 +922,15 b' def get_home_dir():'
     # first, check py2exe distribution root directory for _ipython.
     # This overrides all. Normally does not exist.
 
-    if '\\library.zip\\' in IPython.__file__.lower():
-        root, rest = IPython.__file__.lower().split('library.zip')
-        if isdir(root + '_ipython'):
-            os.environ["IPYKITROOT"] = root.rstrip('\\')
-            return root
-
+    if hasattr(sys, "frozen"): #Is frozen by py2exe
+        if '\\library.zip\\' in IPython.__file__.lower():#libraries compressed to zip-file
+            root, rest = IPython.__file__.lower().split('library.zip')
+        else: 
+            root=os.path.join(os.path.split(IPython.__file__)[0],"../../")
+        root=os.path.abspath(root).rstrip('\\')
+        if isdir(os.path.join(root, '_ipython')):
+            os.environ["IPYKITROOT"] = root
+        return root
     try:
         homedir = env['HOME']
         if not isdir(homedir):
@@ -953,7 +950,7 b' def get_home_dir():'
                     if not isdir(homedir):
                         raise HomeDirError
                 return homedir
-            except:
+            except KeyError:
                 try:
                     # Use the registry to get the 'My Documents' folder.
                     import _winreg as wreg
@@ -992,8 +989,8 b' def get_ipython_dir():'
          ipdir_def = '_ipython'
     home_dir = get_home_dir()
     ipdir = os.path.abspath(os.environ.get('IPYTHONDIR',
-                                           os.path.join(home_dir,ipdir_def)))
-    return ipdir
+                                           os.path.join(home_dir, ipdir_def)))
+    return ipdir.decode(sys.getfilesystemencoding())
 
 def get_security_dir():
     """Get the IPython security directory.
@@ -1234,11 +1231,11 b' def esc_quotes(strng):'
 def make_quoted_expr(s):
     """Return string s in appropriate quotes, using raw string if possible.
 
-    Effectively this turns string: cd \ao\ao\
-    to: r"cd \ao\ao\_"[:-1]
-
-    Note the use of raw string and padding at the end to allow trailing backslash.
+    XXX - example removed because it caused encoding errors in documentation
+    generation.  We need a new example that doesn't contain invalid chars.
 
+    Note the use of raw string and padding at the end to allow trailing
+    backslash.
     """
 
     tail = ''

IPython/gui/wx/ipshell_nonblocking.py

@@ -62,11 +62,10 b' class _Helper(object):'
 ##############################################################################
 class _CodeExecutor(ThreadEx):
     ''' Thread that execute ipython code '''
-    def __init__(self, instance, after):
+    def __init__(self, instance):
         ThreadEx.__init__(self)
         self.instance = instance
-        self._afterExecute = after
-
+        
     def run(self):
         '''Thread main loop'''
         try:
@@ -74,7 +73,7 b' class _CodeExecutor(ThreadEx):'
             self.instance._help_text = None
             self.instance._execute()
             # used for uper class to generate event after execution
-            self._afterExecute() 
+            self.instance._after_execute() 
             
         except KeyboardInterrupt:
             pass
@@ -114,8 +113,7 b' class NonBlockingIPShell(object):'
         '''
         #ipython0 initialisation
         self._IP = None
-        self._term = None
-        self.initIpython0(argv, user_ns, user_global_ns,
+        self.init_ipython0(argv, user_ns, user_global_ns,
                           cin, cout, cerr,
                           ask_exit_handler)
         
@@ -127,33 +125,32 b' class NonBlockingIPShell(object):'
 
         #thread working vars
         self._line_to_execute = ''
-
+        self._threading = True
+        
         #vars that will be checked by GUI loop to handle thread states...
         #will be replaced later by PostEvent GUI funtions...
         self._doc_text = None
         self._help_text = None
         self._add_button = None
 
-    def initIpython0(self, argv=[], user_ns={}, user_global_ns=None,
+    def init_ipython0(self, argv=[], user_ns={}, user_global_ns=None,
                      cin=None, cout=None, cerr=None,
                      ask_exit_handler=None):
-        ''' Initialize an ithon0 instance '''
+        ''' Initialize an ipython0 instance '''
         
-        #first we redefine in/out/error functions of IPython 
+        #first we redefine in/out/error functions of IPython
+        #BUG: we've got a limitation form ipython0 there
+        #only one instance can be instanciated else tehre will be
+        #cin/cout/cerr clash...
         if cin:
-            IPython.Shell.Term.cin = cin
+            IPython.genutils.Term.cin = cin
         if cout:
-            IPython.Shell.Term.cout = cout
+            IPython.genutils.Term.cout = cout
         if cerr:
-            IPython.Shell.Term.cerr = cerr
+            IPython.genutils.Term.cerr = cerr
         
-        # This is to get rid of the blockage that accurs during
-        # IPython.Shell.InteractiveShell.user_setup()
-        IPython.iplib.raw_input = lambda x: None
-
-        self._term = IPython.genutils.IOTerm(cin=cin, cout=cout, cerr=cerr)
-
         excepthook = sys.excepthook
+
         #Hack to save sys.displayhook, because ipython seems to overwrite it...
         self.sys_displayhook_ori = sys.displayhook
         
@@ -163,7 +160,8 b' class NonBlockingIPShell(object):'
                                     embedded=True,
                                     shell_class=IPython.Shell.InteractiveShell)
 
-        #we restore sys.displayhook
+        #we save ipython0 displayhook and we restore sys.displayhook
+        self.displayhook = sys.displayhook
         sys.displayhook = self.sys_displayhook_ori
 
         #we replace IPython default encoding by wx locale encoding
@@ -173,11 +171,12 b' class NonBlockingIPShell(object):'
         #we replace the ipython default pager by our pager
         self._IP.set_hook('show_in_pager', self._pager)
         
-        #we replace the ipython default shell command caller by our shell handler
+        #we replace the ipython default shell command caller 
+        #by our shell handler
         self._IP.set_hook('shell_hook', self._shell)
         
         #we replace the ipython default input command caller by our method
-        IPython.iplib.raw_input_original = self._raw_input
+        IPython.iplib.raw_input_original = self._raw_input_original
         #we replace the ipython default exit command by our method
         self._IP.exit = ask_exit_handler
         #we replace the help command
@@ -186,26 +185,68 b' class NonBlockingIPShell(object):'
         #we disable cpase magic... until we found a way to use it properly.
         #import IPython.ipapi
         ip = IPython.ipapi.get()
-        def bypassMagic(self, arg):
+        def bypass_magic(self, arg):
             print '%this magic is currently disabled.'
-        ip.expose_magic('cpaste', bypassMagic)
+        ip.expose_magic('cpaste', bypass_magic)
+
+        import __builtin__
+        __builtin__.raw_input = self._raw_input
         
         sys.excepthook = excepthook
 
-    #----------------------- Thread management section ----------------------    
-    def doExecute(self, line):
+    #----------------------- Thread management section ----------------------   
+    def do_execute(self, line):
         """
         Tell the thread to process the 'line' command
         """
 
         self._line_to_execute = line
-        #we launch the ipython line execution in a thread to make it interruptible
-        #with include it in self namespace to be able to call ce.raise_exc(KeyboardInterrupt)
-        self.ce = _CodeExecutor(self, self._afterExecute)
-        self.ce.start()
-        
-    #----------------------- IPython management section ----------------------    
-    def getDocText(self):
+
+        if self._threading:
+            #we launch the ipython line execution in a thread to make it 
+            #interruptible with include it in self namespace to be able 
+            #to call  ce.raise_exc(KeyboardInterrupt)
+            self.ce = _CodeExecutor(self)
+            self.ce.start()
+        else:
+            try:
+                self._doc_text = None
+                self._help_text = None
+                self._execute()
+                # used for uper class to generate event after execution
+                self._after_execute() 
+            
+            except KeyboardInterrupt:
+                pass
+
+    #----------------------- IPython management section ----------------------
+    def get_threading(self):
+        """
+        Returns threading status, is set to True, then each command sent to
+        the interpreter will be executed in a separated thread allowing,
+        for example, breaking a long running commands.
+        Disallowing it, permits better compatibilty with instance that is embedding
+        IPython instance.
+
+        @return: Execution method
+        @rtype: bool
+        """
+        return self._threading
+    
+    def set_threading(self, state):
+        """
+        Sets threading state, if set to True, then each command sent to
+        the interpreter will be executed in a separated thread allowing,
+        for example, breaking a long running commands.
+        Disallowing it, permits better compatibilty with instance that is embedding
+        IPython instance.
+
+        @param state: Sets threading state
+        @type bool
+        """
+        self._threading = state
+
+    def get_doc_text(self):
         """
         Returns the output of the processing that need to be paged (if any)
 
@@ -214,7 +255,7 b' class NonBlockingIPShell(object):'
         """
         return self._doc_text
         
-    def getHelpText(self):
+    def get_help_text(self):
         """
         Returns the output of the processing that need to be paged via help pager(if any)
 
@@ -223,7 +264,7 b' class NonBlockingIPShell(object):'
         """
         return self._help_text
 
-    def getBanner(self):
+    def get_banner(self):
         """
         Returns the IPython banner for useful info on IPython instance
 
@@ -232,7 +273,7 b' class NonBlockingIPShell(object):'
         """
         return self._IP.BANNER
     
-    def getPromptCount(self):
+    def get_prompt_count(self):
         """
         Returns the prompt number.
         Each time a user execute a line in the IPython shell the prompt count is increased
@@ -242,7 +283,7 b' class NonBlockingIPShell(object):'
         """
         return self._IP.outputcache.prompt_count
 
-    def getPrompt(self):
+    def get_prompt(self):
         """
         Returns current prompt inside IPython instance
         (Can be In [...]: ot ...:)
@@ -252,7 +293,7 b' class NonBlockingIPShell(object):'
         """
         return self._prompt
 
-    def getIndentation(self):
+    def get_indentation(self):
         """
         Returns the current indentation level
         Usefull to put the caret at the good start position if we want to do autoindentation.
@@ -262,7 +303,7 b' class NonBlockingIPShell(object):'
         """
         return self._IP.indent_current_nsp
         
-    def updateNamespace(self, ns_dict):
+    def update_namespace(self, ns_dict):
         '''
         Add the current dictionary to the shell namespace.
 
@@ -286,7 +327,7 b' class NonBlockingIPShell(object):'
         possibilities = self._IP.complete(split_line[-1])
         if possibilities:
 
-            def _commonPrefix(str1, str2):
+            def _common_prefix(str1, str2):
                 '''
                 Reduction function. returns common prefix of two given strings.
 
@@ -302,13 +343,13 b' class NonBlockingIPShell(object):'
                     if not str2.startswith(str1[:i+1]):
                         return str1[:i]
                 return str1
-            common_prefix = reduce(_commonPrefix, possibilities)
+            common_prefix = reduce(_common_prefix, possibilities)
             completed = line[:-len(split_line[-1])]+common_prefix
         else:
             completed = line
         return completed, possibilities
 
-    def historyBack(self):
+    def history_back(self):
         '''
         Provides one history command back.
 
@@ -320,10 +361,10 b' class NonBlockingIPShell(object):'
         while((history == '' or history == '\n') and self._history_level >0):
             if self._history_level >= 1:
                 self._history_level -= 1
-            history = self._getHistory()            
+            history = self._get_history()            
         return history
 
-    def historyForward(self):
+    def history_forward(self):
         '''
         Provides one history command forward.
 
@@ -333,38 +374,38 b' class NonBlockingIPShell(object):'
         history = ''
         #the below while loop is used to suppress empty history lines
         while((history == '' or history == '\n') \
-        and self._history_level <= self._getHistoryMaxIndex()):
-            if self._history_level < self._getHistoryMaxIndex():
+        and self._history_level <= self._get_history_max_index()):
+            if self._history_level < self._get_history_max_index():
                 self._history_level += 1
-                history = self._getHistory()
+                history = self._get_history()
             else:
-                if self._history_level == self._getHistoryMaxIndex():
-                    history = self._getHistory()
+                if self._history_level == self._get_history_max_index():
+                    history = self._get_history()
                     self._history_level += 1
                 else:
                     history = ''
         return history
 
-    def initHistoryIndex(self):
+    def init_history_index(self):
         '''
         set history to last command entered
         '''
-        self._history_level = self._getHistoryMaxIndex()+1
+        self._history_level = self._get_history_max_index()+1
 
     #----------------------- IPython PRIVATE management section --------------
-    def _afterExecute(self):
+    def _after_execute(self):
         '''
         Can be redefined to generate post event after excution is done
         '''
         pass
 
-    #def _askExit(self):
-    #    '''
-    #    Can be redefined to generate post event to exit the Ipython shell
-    #    '''
-    #    pass
+    def _ask_exit(self):
+        '''
+        Can be redefined to generate post event to exit the Ipython shell
+        '''
+        pass
 
-    def _getHistoryMaxIndex(self):
+    def _get_history_max_index(self):
         '''
         returns the max length of the history buffer
 
@@ -373,7 +414,7 b' class NonBlockingIPShell(object):'
         '''
         return len(self._IP.input_hist_raw)-1
         
-    def _getHistory(self):
+    def _get_history(self):
         '''
         Get's the command string of the current history level.
 
@@ -388,7 +429,7 b' class NonBlockingIPShell(object):'
         This function is used as a callback replacment to IPython help pager function
 
         It puts the 'text' value inside the self._help_text string that can be retrived via
-        getHelpText function.
+        get_help_text function.
         '''
         if self._help_text == None:
             self._help_text = text
@@ -400,11 +441,11 b' class NonBlockingIPShell(object):'
         This function is used as a callback replacment to IPython pager function
 
         It puts the 'text' value inside the self._doc_text string that can be retrived via
-        getDocText function.
+        get_doc_text function.
         '''
         self._doc_text = text
     
-    def _raw_input(self, prompt=''):
+    def _raw_input_original(self, prompt=''):
         '''
         Custom raw_input() replacement. Get's current line from console buffer.
 
@@ -416,13 +457,21 b' class NonBlockingIPShell(object):'
         '''
         return self._line_to_execute
 
+    def _raw_input(self, prompt=''):
+        """ A replacement from python's raw_input.
+        """
+        raise NotImplementedError
+    
     def _execute(self):
         '''
         Executes the current line provided by the shell object.
         '''
+
         orig_stdout = sys.stdout
         sys.stdout = IPython.Shell.Term.cout
-                
+        #self.sys_displayhook_ori = sys.displayhook
+        #sys.displayhook = self.displayhook
+        
         try:
             line = self._IP.raw_input(None, self._iter_more)
             if self._IP.autoindent:
@@ -440,8 +489,10 b' class NonBlockingIPShell(object):'
         except:
             self._IP.showtraceback()
         else:
+            self._IP.write(str(self._IP.outputcache.prompt_out).strip())
             self._iter_more = self._IP.push(line)
-            if (self._IP.SyntaxTB.last_syntax_error and self._IP.rc.autoedit_syntax):
+            if (self._IP.SyntaxTB.last_syntax_error and \
+                                                            self._IP.rc.autoedit_syntax):
                 self._IP.edit_syntax_error()
         if self._iter_more:
             self._prompt = str(self._IP.outputcache.prompt2).strip()
@@ -450,8 +501,10 b' class NonBlockingIPShell(object):'
         else:
             self._prompt = str(self._IP.outputcache.prompt1).strip()
             self._IP.indent_current_nsp = 0 #we set indentation to 0
+
         sys.stdout = orig_stdout
-    
+        #sys.displayhook = self.sys_displayhook_ori
+                
     def _shell(self, ip, cmd):
         '''
         Replacement method to allow shell commands without them blocking.
@@ -462,7 +515,8 b' class NonBlockingIPShell(object):'
         @type cmd: string
         '''
         stdin, stdout = os.popen4(cmd)
-        result = stdout.read().decode('cp437').encode(locale.getpreferredencoding())
+        result = stdout.read().decode('cp437').\
+                                            encode(locale.getpreferredencoding())
         #we use print command because the shell command is called
         #inside IPython instance and thus is redirected to thread cout
         #"\x01\x1b[1;36m\x02" <-- add colour to the text...

IPython/gui/wx/ipython_history.py

@@ -29,17 +29,21 b' class IPythonHistoryPanel(wx.Panel):'
         self.filter_magic = wx.CheckBox(self, -1, "%: Magic keys")
 
         self.options={'filter_empty':{'value':'True',
-                                      'checkbox':self.filter_empty,'True':True,'False':False,
-                                      'setfunc':lambda x:None},
+                                'checkbox':self.filter_empty, \
+                                                'True':True,'False':False,
+                                'setfunc':lambda x:None},
                       'filter_doc':{'value':'True',
-                                    'checkbox':self.filter_doc,'True':True,'False':False,
-                                    'setfunc':lambda x:None},
+                                'checkbox':self.filter_doc, \
+                                                'True':True,'False':False,
+                                'setfunc':lambda x:None},
                       'filter_cmd':{'value':'True',
-                                    'checkbox':self.filter_cmd,'True':True,'False':False,
-                                    'setfunc':lambda x:None},
+                                'checkbox':self.filter_cmd, \
+                                                'True':True,'False':False,
+                                'setfunc':lambda x:None},
                       'filter_magic':{'value':'True',
-                                      'checkbox':self.filter_magic,'True':True,'False':False,
-                                      'setfunc':lambda x:None},
+                                'checkbox':self.filter_magic, \
+                                                'True':True,'False':False,
+                                'setfunc':lambda x:None},
                      }
         self.reloadOptions(self.options)
 
@@ -199,51 +203,81 b' class PythonSTC(stc.StyledTextCtrl):'
         self.SetLayoutCache(stc.STC_CACHE_PAGE)
 
         # Setup a margin to hold fold markers
-        #self.SetFoldFlags(16)  ###  WHAT IS THIS VALUE?  WHAT ARE THE OTHER FLAGS?  DOES IT MATTER?
+        #self.SetFoldFlags(16)  
+        ###  WHAT IS THIS VALUE?  WHAT ARE THE OTHER FLAGS?  DOES IT MATTER?
         self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)
         self.SetMarginMask(2, stc.STC_MASK_FOLDERS)
         self.SetMarginSensitive(2, True)
         self.SetMarginWidth(2, 12)
 
         if self.fold_symbols == 0:
-            # Arrow pointing right for contracted folders, arrow pointing down for expanded
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_ARROWDOWN, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_ARROW, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_EMPTY, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_EMPTY, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_EMPTY,     "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_EMPTY,     "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_EMPTY,     "white", "black")
+            # Arrow pointing right for contracted folders, 
+            # arrow pointing down for expanded
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
+                                        stc.STC_MARK_ARROWDOWN, "black", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDER, \
+                                        stc.STC_MARK_ARROW, "black", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
+                                        stc.STC_MARK_EMPTY, "black", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
+                                        stc.STC_MARK_EMPTY, "black", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, \
+                                        stc.STC_MARK_EMPTY,     "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
+                                        stc.STC_MARK_EMPTY,     "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
+                                        stc.STC_MARK_EMPTY,     "white", "black")
             
         elif self.fold_symbols == 1:
             # Plus for contracted folders, minus for expanded
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_MINUS, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_PLUS,  "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_EMPTY, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
+                                        stc.STC_MARK_MINUS, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDER, \
+                                        stc.STC_MARK_PLUS,  "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
+                                        stc.STC_MARK_EMPTY, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
+                                        stc.STC_MARK_EMPTY, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, \
+                                        stc.STC_MARK_EMPTY, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
+                                        stc.STC_MARK_EMPTY, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
+                                        stc.STC_MARK_EMPTY, "white", "black")
 
         elif self.fold_symbols == 2:
             # Like a flattened tree control using circular headers and curved joins
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_CIRCLEMINUS,          "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_CIRCLEPLUS,           "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,                "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNERCURVE,         "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_CIRCLEPLUSCONNECTED,  "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_CIRCLEMINUSCONNECTED, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNERCURVE,         "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,  \
+                                        stc.STC_MARK_CIRCLEMINUS, "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDER, \
+                                        stc.STC_MARK_CIRCLEPLUS, "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
+                                        stc.STC_MARK_VLINE, "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
+                                        stc.STC_MARK_LCORNERCURVE, "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, \
+                                        stc.STC_MARK_CIRCLEPLUSCONNECTED, "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
+                                        stc.STC_MARK_CIRCLEMINUSCONNECTED, "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
+                                        stc.STC_MARK_TCORNERCURVE, "white", "#404040")
 
         elif self.fold_symbols == 3:
             # Like a flattened tree control using square headers
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_BOXMINUS,          "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_BOXPLUS,           "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,             "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNER,           "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_BOXPLUSCONNECTED,  "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNER,           "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
+                                        stc.STC_MARK_BOXMINUS, "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,  \
+                                        stc.STC_MARK_BOXPLUS, "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
+                                        stc.STC_MARK_VLINE, "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
+                                        stc.STC_MARK_LCORNER, "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,  \
+                                        stc.STC_MARK_BOXPLUSCONNECTED, "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
+                                        stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
+                                        stc.STC_MARK_TCORNER,           "white", "#808080")
 
 
         self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)
@@ -363,7 +397,7 b' class PythonSTC(stc.StyledTextCtrl):'
         if braceAtCaret < 0:
             charAfter = self.GetCharAt(caretPos)
             styleAfter = self.GetStyleAt(caretPos)
-
+            
             if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
                 braceAtCaret = caretPos
 

IPython/gui/wx/ipython_view.py

@@ -1,5 +1,5 b''
 #!/usr/bin/python
-# -*- coding: iso-8859-15 -*-
+# -*- coding: utf-8 -*-
 '''
 Provides IPython WX console widgets.
 
@@ -19,7 +19,7 b' available under the terms of the BSD which accompanies this distribution, and'
 is available at U{http://www.opensource.org/licenses/bsd-license.php}
 '''
 
-__version__ = 0.8
+__version__ = 0.9
 __author__  = "Laurent Dufrechou"
 __email__   = "laurent.dufrechou _at_ gmail.com"
 __license__ = "BSD"
@@ -33,6 +33,8 b' from StringIO import StringIO'
 import sys
 import codecs
 import locale
+import time
+
 for enc in (locale.getpreferredencoding(),
             sys.getfilesystemencoding(),
             sys.getdefaultencoding()):
@@ -63,17 +65,43 b' class WxNonBlockingIPShell(NonBlockingIPShell):'
         self.parent = parent
 
         self.ask_exit_callback = ask_exit_handler
-        self._IP.exit = self._askExit
+        self._IP.exit = self._ask_exit
 
     def addGUIShortcut(self, text, func):
         wx.CallAfter(self.parent.add_button_handler, 
                 button_info={   'text':text, 
                                 'func':self.parent.doExecuteLine(func)})
 
-    def _askExit(self):
+    def _raw_input(self, prompt=''):
+        """ A replacement from python's raw_input.
+        """
+        self.answer = None
+        if(self._threading == True):			
+			wx.CallAfter(self._yesNoBox,  prompt)
+			while self.answer is None:
+				time.sleep(.1)
+        else:
+			self._yesNoBox(prompt)
+        return self.answer
+        
+    def _yesNoBox(self, prompt):
+        """ yes/no box managed with wx.CallAfter jsut in case caler is executed in a thread"""
+        dlg = wx.TextEntryDialog(
+                self.parent, prompt,
+                'Input requested', 'Python')
+        dlg.SetValue("")
+
+        answer = ''
+        if dlg.ShowModal() == wx.ID_OK:
+            answer = dlg.GetValue()
+        
+        dlg.Destroy()
+        self.answer = answer
+        
+    def _ask_exit(self):
         wx.CallAfter(self.ask_exit_callback, ())
 
-    def _afterExecute(self):
+    def _after_execute(self):
         wx.CallAfter(self.parent.evtStateExecuteDone, ())
 
                 
@@ -249,22 +277,15 b' class WxConsoleView(stc.StyledTextCtrl):'
         @type text: string
         '''
         try:
-            #print >>sys.__stdout__,'entering'
             wx.MutexGuiEnter()
-            #print >>sys.__stdout__,'locking the GUI'
                 
             #be sure not to be interrutpted before the MutexGuiLeave!
             self.write(text)
                 
-            #print >>sys.__stdout__,'done'
-                
         except KeyboardInterrupt:
-            #print >>sys.__stdout__,'got keyboard interrupt'
             wx.MutexGuiLeave()
-            #print >>sys.__stdout__,'interrupt unlock the GUI'
             raise KeyboardInterrupt
         wx.MutexGuiLeave()
-        #print >>sys.__stdout__,'normal unlock the GUI'
         
                 
     def write(self, text):
@@ -419,7 +440,7 b' class WxConsoleView(stc.StyledTextCtrl):'
             self.AutoCompSetIgnoreCase(False)
             self.AutoCompSetAutoHide(False)
             #let compute the length ot last word
-            splitter = [' ', '(', '[', '{']
+            splitter = [' ', '(', '[', '{','=']
             last_word = self.getCurrentLine()
             for breaker in splitter:
                 last_word = last_word.split(breaker)[-1]
@@ -439,7 +460,6 b' class WxConsoleView(stc.StyledTextCtrl):'
         @return: Return True if event as been catched.
         @rtype: boolean
         '''
-
         if not self.AutoCompActive():
             if event.GetKeyCode() == wx.WXK_HOME:
                 if event.Modifiers == wx.MOD_NONE:
@@ -554,24 +574,30 b' class IPShellWidget(wx.Panel):'
         #with intro=''
         if intro is None:
             welcome_text = "Welcome to WxIPython Shell.\n\n"
-            welcome_text+= self.IP.getBanner()
+            welcome_text+= self.IP.get_banner()
             welcome_text+= "!command  -> Execute command in shell\n"
             welcome_text+= "TAB       -> Autocompletion\n"
         else:
             welcome_text = intro
 
         self.text_ctrl = WxConsoleView(self,
-                                       self.IP.getPrompt(),
+                                       self.IP.get_prompt(),
                                        intro=welcome_text,
                                        background_color=background_color)
 
-        self.cout.write = self.text_ctrl.asyncWrite
-
         option_text = wx.StaticText(self, -1, "Options:")
         self.completion_option = wx.CheckBox(self, -1, "Scintilla Completion")
+        self.completion_option.SetToolTip(wx.ToolTip(
+            "Selects the completion type:\nEither Ipython default style or Scintilla one"))
         #self.completion_option.SetValue(False)
         self.background_option = wx.CheckBox(self, -1, "White Background")
+        self.background_option.SetToolTip(wx.ToolTip(
+            "Selects the back ground color: BLACK or WHITE"))
         #self.background_option.SetValue(False)
+        self.threading_option = wx.CheckBox(self, -1, "Execute in thread")
+        self.threading_option.SetToolTip(wx.ToolTip(
+            "Use threading: infinite loop don't freeze the GUI and commands can be breaked\nNo  threading: maximum compatibility"))
+        #self.threading_option.SetValue(False)
         
         self.options={'completion':{'value':'IPYTHON',
                                     'checkbox':self.completion_option,'STC':True,'IPYTHON':False,
@@ -579,12 +605,20 b' class IPShellWidget(wx.Panel):'
                       'background_color':{'value':'BLACK',
                                           'checkbox':self.background_option,'WHITE':True,'BLACK':False,
                                           'setfunc':self.text_ctrl.setBackgroundColor},
+                      'threading':{'value':'True',
+                                   'checkbox':self.threading_option,'True':True,'False':False,
+                                   'setfunc':self.IP.set_threading},
                      }
+
+        #self.cout.write dEfault option is asynchroneous because default sate is threading ON
+        self.cout.write = self.text_ctrl.asyncWrite
+        #we reloard options
         self.reloadOptions(self.options)
         
         self.text_ctrl.Bind(wx.EVT_KEY_DOWN, self.keyPress)
         self.completion_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionCompletion)
         self.background_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionBackgroundColor)
+        self.threading_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionThreading)
             
         ### making the layout of the panel ###
         sizer = wx.BoxSizer(wx.VERTICAL)
@@ -596,7 +630,9 b' class IPShellWidget(wx.Panel):'
                               (5, 5),
                               (self.completion_option, 0, wx.ALIGN_CENTER_VERTICAL),
                               (8, 8),
-                              (self.background_option, 0, wx.ALIGN_CENTER_VERTICAL)
+                              (self.background_option, 0, wx.ALIGN_CENTER_VERTICAL),
+                              (8, 8),
+                              (self.threading_option, 0, wx.ALIGN_CENTER_VERTICAL)
                               ])
         self.SetAutoLayout(True)
         sizer.Fit(self)
@@ -619,13 +655,15 b' class IPShellWidget(wx.Panel):'
         self.text_ctrl.write('\n')
         lines_to_execute = lines.replace('\t',' '*4)
         lines_to_execute = lines_to_execute.replace('\r','')
-        self.IP.doExecute(lines_to_execute.encode(ENCODING))
+        self.IP.do_execute(lines_to_execute.encode(ENCODING))
         self.updateHistoryTracker(lines)
+        if(self.text_ctrl.getCursorPos()!=0):
+            self.text_ctrl.removeCurrentLine()
         self.setCurrentState('WAIT_END_OF_EXECUTION')
         
     def evtStateExecuteDone(self,evt):
-        self.doc = self.IP.getDocText()
-        self.help = self.IP.getHelpText()
+        self.doc = self.IP.get_doc_text()
+        self.help = self.IP.get_help_text()
         if self.doc:
             self.pager_lines = self.doc[7:].split('\n')
             self.pager_state = 'INIT'
@@ -637,15 +675,17 b' class IPShellWidget(wx.Panel):'
             self.setCurrentState('SHOW_DOC')
             self.pager(self.help)                
         else:
+            if(self.text_ctrl.getCursorPos()!=0):
+                self.text_ctrl.removeCurrentLine()
             self.stateShowPrompt()
 
     def stateShowPrompt(self):
         self.setCurrentState('SHOW_PROMPT')
-        self.text_ctrl.setPrompt(self.IP.getPrompt())
-        self.text_ctrl.setIndentation(self.IP.getIndentation())
-        self.text_ctrl.setPromptCount(self.IP.getPromptCount())
+        self.text_ctrl.setPrompt(self.IP.get_prompt())
+        self.text_ctrl.setIndentation(self.IP.get_indentation())
+        self.text_ctrl.setPromptCount(self.IP.get_prompt_count())
         self.text_ctrl.showPrompt()
-        self.IP.initHistoryIndex()
+        self.IP.init_history_index()
         self.setCurrentState('IDLE')
 
     def setCurrentState(self, state):
@@ -751,11 +791,11 b' class IPShellWidget(wx.Panel):'
             
         if self.cur_state == 'IDLE':
             if event.KeyCode == wx.WXK_UP:
-                history = self.IP.historyBack()
+                history = self.IP.history_back()
                 self.text_ctrl.writeHistory(history)
                 return
             if event.KeyCode == wx.WXK_DOWN:
-                history = self.IP.historyForward()
+                history = self.IP.history_forward()
                 self.text_ctrl.writeHistory(history)
                 return
             if event.KeyCode == wx.WXK_TAB:
@@ -802,7 +842,20 b' class IPShellWidget(wx.Panel):'
         self.updateOptionTracker('background_color',
                                  self.options['background_color']['value'])
         self.text_ctrl.SetFocus()
-    
+
+    def evtCheckOptionThreading(self, event):
+        if event.IsChecked():
+            self.options['threading']['value']='True'
+            self.IP.set_threading(True)
+            self.cout.write = self.text_ctrl.asyncWrite
+        else:
+            self.options['threading']['value']='False'
+            self.IP.set_threading(False)
+            self.cout.write = self.text_ctrl.write
+        self.updateOptionTracker('threading',
+                                 self.options['threading']['value'])
+        self.text_ctrl.SetFocus()
+        
     def getOptions(self):
         return self.options
         
@@ -813,7 +866,13 b' class IPShellWidget(wx.Panel):'
             self.options[key]['checkbox'].SetValue(self.options[key][value])
             self.options[key]['setfunc'](value)
         
-        
+        if self.options['threading']['value']=='True':
+            self.IP.set_threading(True)
+            self.cout.write = self.text_ctrl.asyncWrite
+        else:
+            self.IP.set_threading(False)
+            self.cout.write = self.text_ctrl.write
+            
     #------------------------ Hook Section -----------------------------------
     def updateOptionTracker(self,name,value):
         '''
@@ -881,5 +940,3 b" if __name__ == '__main__':"
     shell = frame.shell
 
     app.MainLoop()
-
-

IPython/gui/wx/wxIPython.py

@@ -10,10 +10,18 b' from wx.lib.wordwrap import wordwrap'
 from IPython.gui.wx.ipython_view import IPShellWidget
 from IPython.gui.wx.ipython_history import IPythonHistoryPanel
 
+#used to invoke ipython1 wx implementation
+### FIXME ### temporary disabled due to interference with 'show_in_pager' hook
+is_sync_frontend_ok = False
+try:
+    from IPython.frontend.wx.ipythonx import IPythonXController
+except ImportError:
+    is_sync_frontend_ok = False
+
 #used to create options.conf file in user directory
 from IPython.ipapi import get
 
-__version__ = 0.8
+__version__ = 0.91
 __author__  = "Laurent Dufrechou"
 __email__   = "laurent.dufrechou _at_ gmail.com"
 __license__ = "BSD"
@@ -27,7 +35,7 b' class MyFrame(wx.Frame):'
     application with movables windows"""
     def __init__(self, parent=None, id=-1, title="WxIPython", 
                 pos=wx.DefaultPosition,
-                size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
+                size=(800, 600), style=wx.DEFAULT_FRAME_STYLE, sync_ok=False):
         wx.Frame.__init__(self, parent, id, title, pos, size, style)
         self._mgr = wx.aui.AuiManager()
         
@@ -41,12 +49,18 b' class MyFrame(wx.Frame):'
         
         self.ipython_panel    = IPShellWidget(self,background_color = "BLACK")
         #self.ipython_panel    = IPShellWidget(self,background_color = "WHITE")
-
+        if(sync_ok):
+            self.ipython_panel2   = IPythonXController(self)
+        else:
+            self.ipython_panel2   = None
         self.ipython_panel.setHistoryTrackerHook(self.history_panel.write)
         self.ipython_panel.setStatusTrackerHook(self.updateStatus)
         self.ipython_panel.setAskExitHandler(self.OnExitDlg)
         self.ipython_panel.setOptionTrackerHook(self.optionSave)
 
+        #Create a notebook to display different IPython shell implementations
+        self.nb = wx.aui.AuiNotebook(self)
+        
         self.optionLoad()
         
         self.statusbar = self.createStatus()
@@ -55,7 +69,11 b' class MyFrame(wx.Frame):'
         ########################################################################
         ### add the panes to the manager
         # main panels
-        self._mgr.AddPane(self.ipython_panel , wx.CENTER, "IPython Shell")
+        self._mgr.AddPane(self.nb , wx.CENTER, "IPython Shells")
+        self.nb.AddPage(self.ipython_panel , "IPython0 Shell")
+        if(sync_ok):
+            self.nb.AddPage(self.ipython_panel2, "IPython1 Synchroneous Shell")
+
         self._mgr.AddPane(self.history_panel , wx.RIGHT,  "IPython history")
                 
         # now we specify some panel characteristics
@@ -77,7 +95,10 b' class MyFrame(wx.Frame):'
         warn_text = 'Hello from IPython and wxPython.\n'
         warn_text +='Please Note that this work is still EXPERIMENTAL\n'
         warn_text +='It does NOT emulate currently all the IPython functions.\n'
-        
+        warn_text +="\nIf you use MATPLOTLIB with show() you'll need to deactivate the THREADING option.\n"
+        if(not sync_ok):
+            warn_text +="\n->No twisted package detected, IPython1 example deactivated."
+            
         dlg = wx.MessageDialog(self,
                                warn_text,
                                'Warning Box',
@@ -146,13 +167,6 b' class MyFrame(wx.Frame):'
         about_menu = wx.Menu()
         about_menu.Append(wx.ID_HIGHEST+3, "About")
 
-        #view_menu.AppendSeparator()
-        #options_menu = wx.Menu()
-        #options_menu.AppendCheckItem(wx.ID_HIGHEST+7, "Allow Floating")
-        #options_menu.AppendCheckItem(wx.ID_HIGHEST+8, "Transparent Hint")
-        #options_menu.AppendCheckItem(wx.ID_HIGHEST+9, "Transparent Hint Fade-in")
-        
-        
         mb.Append(file_menu, "File")
         mb.Append(view_menu, "View")
         mb.Append(about_menu, "About")
@@ -233,17 +247,17 b' class MyFrame(wx.Frame):'
 #----------------------------------------- 
 class MyApp(wx.PySimpleApp):
     """Creating our application"""
-    def __init__(self):
+    def __init__(self, sync_ok=False):
         wx.PySimpleApp.__init__(self)
         
-        self.frame = MyFrame()
+        self.frame = MyFrame(sync_ok=sync_ok)
         self.frame.Show()
         
 #-----------------------------------------
 #Main loop
 #----------------------------------------- 
 def main():
-    app = MyApp()
+    app = MyApp(is_sync_frontend_ok)
     app.SetTopWindow(app.frame)
     app.MainLoop()
 

IPython/history.py

@@ -1,5 +1,4 b''
 # -*- coding: utf-8 -*-
-
 """ History related magics and functionality """
 
 # Stdlib imports
@@ -7,7 +6,7 b' import fnmatch'
 import os
 
 # IPython imports
-from IPython.genutils import Term, ask_yes_no
+from IPython.genutils import Term, ask_yes_no, warn
 import IPython.ipapi
 
 def magic_history(self, parameter_s = ''):
@@ -47,8 +46,6 b" def magic_history(self, parameter_s = ''):"
       -f FILENAME: instead of printing the output to the screen, redirect it to
        the given file.  The file is always overwritten, though IPython asks for
        confirmation first if it already exists.
-      
-
     """
 
     ip = self.api
@@ -62,31 +59,28 b" def magic_history(self, parameter_s = ''):"
     try:
         outfname = opts['f']
     except KeyError:
-        outfile = Term.cout
+        outfile = Term.cout  # default
         # We don't want to close stdout at the end!
         close_at_end = False
     else:
         if os.path.exists(outfname):
-            ans = ask_yes_no("File %r exists. Overwrite?" % outfname)
-            if not ans:
+            if not ask_yes_no("File %r exists. Overwrite?" % outfname): 
                 print 'Aborting.'
                 return
-            else:
-                outfile = open(outfname,'w')
-                close_at_end = True
-                
 
-    if opts.has_key('t'):
+        outfile = open(outfname,'w')
+        close_at_end = True
+
+    if 't' in opts:
         input_hist = shell.input_hist
-    elif opts.has_key('r'):
+    elif 'r' in opts:
         input_hist = shell.input_hist_raw
     else:
         input_hist = shell.input_hist
-        
-    
+            
     default_length = 40
     pattern = None
-    if opts.has_key('g'):
+    if 'g' in opts:
         init = 1
         final = len(input_hist)
         parts = parameter_s.split(None,1)
@@ -138,13 +132,11 b" def magic_history(self, parameter_s = ''):"
         outfile.close()
 
 
-
 def magic_hist(self, parameter_s=''):
     """Alternate name for %history."""
     return self.magic_history(parameter_s)
 
 
-
 def rep_f(self, arg):
     r""" Repeat a command, or get command to input line for editing
 
@@ -173,11 +165,9 b' def rep_f(self, arg):'
     %rep foo
     
     Place the most recent line that has the substring "foo" to next input.
-    (e.g. 'svn ci -m foobar').
-    
+    (e.g. 'svn ci -m foobar').    
     """
     
-    
     opts,args = self.parse_options(arg,'',mode='list')
     ip = self.api    
     if not args:
@@ -206,7 +196,6 b' def rep_f(self, arg):'
                 ip.set_next_input(str(h).rstrip())
                 return
         
-
     try:
         lines = self.extract_input_slices(args, True)
         print "lines",lines
@@ -215,7 +204,6 b' def rep_f(self, arg):'
         print "Not found in recent history:", args
         
 
-
 _sentinel = object()
 
 class ShadowHist:
@@ -259,23 +247,12 b' class ShadowHist:'
             if k == idx:
                 return v
 
-def test_shist():
-    from IPython.Extensions import pickleshare
-    db = pickleshare.PickleShareDB('~/shist')
-    s = ShadowHist(db)
-    s.add('hello')
-    s.add('world')
-    s.add('hello')
-    s.add('hello')
-    s.add('karhu')
-    print "all",s.all()
-    print s.get(2)
 
 def init_ipython(ip):
+    import ipy_completers
+
     ip.expose_magic("rep",rep_f)        
     ip.expose_magic("hist",magic_hist)            
     ip.expose_magic("history",magic_history)
 
-    import ipy_completers
     ipy_completers.quick_completer('%hist' ,'-g -t -r -n')
-#test_shist()

IPython/hooks.py

@@ -32,8 +32,7 b" ip.set_hook('editor', calljed)"
 
 You can then enable the functionality by doing 'import myiphooks'
 somewhere in your configuration files or ipython command line.
-
-$Id: hooks.py 2998 2008-01-31 10:06:04Z vivainio $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2005 Fernando Perez. <[e-mail]>
@@ -42,11 +41,7 b' $Id: hooks.py 2998 2008-01-31 10:06:04Z vivainio $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
 from IPython import ipapi
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-__version__ = Release.version
 
 import os,bisect
 from genutils import Term,shell

IPython/ipapi.py

@@ -24,7 +24,6 b' That way the module is imported at startup and you can have all your'
 personal configuration (as opposed to boilerplate ipythonrc-PROFILENAME 
 stuff) in there. 
 
------------------------------------------------
 import IPython.ipapi
 ip = IPython.ipapi.get()
 
@@ -187,7 +186,6 b' class IPApi(object):'
         self.set_custom_exc = ip.set_custom_exc
 
         self.user_ns = ip.user_ns
-        self.user_ns['_ip'] = self
 
         self.set_crash_handler = ip.set_crash_handler
 

IPython/iplib.py

@@ -2,10 +2,9 b''
 """
 IPython -- An enhanced Interactive Python
 
-Requires Python 2.3 or newer.
+Requires Python 2.4 or newer.
 
 This file contains all the classes and helper functions specific to IPython.
-
 """
 
 #*****************************************************************************
@@ -27,12 +26,6 b' This file contains all the classes and helper functions specific to IPython.'
 #****************************************************************************
 # Modules and globals
 
-from IPython import Release
-__author__  = '%s <%s>\n%s <%s>' % \
-              ( Release.authors['Janko'] + Release.authors['Fernando'] )
-__license__ = Release.license
-__version__ = Release.version
-
 # Python standard modules
 import __main__
 import __builtin__
@@ -54,9 +47,6 b' import sys'
 import tempfile
 import traceback
 import types
-import warnings
-warnings.filterwarnings('ignore', r'.*sets module*')
-from sets import Set
 from pprint import pprint, pformat
 
 # IPython's own modules
@@ -292,6 +282,13 b' class InteractiveShell(object,Magic):'
         # This is the namespace where all normal user variables live
         self.user_ns = user_ns
         self.user_global_ns = user_global_ns
+
+        # An auxiliary namespace that checks what parts of the user_ns were
+        # loaded at startup, so we can list later only variables defined in
+        # actual interactive use.  Since it is always a subset of user_ns, it
+        # doesn't need to be seaparately tracked in the ns_table
+        self.user_config_ns = {}
+
         # A namespace to keep track of internal data structures to prevent
         # them from cluttering user-visible stuff.  Will be updated later
         self.internal_ns = {}
@@ -301,6 +298,24 b' class InteractiveShell(object,Magic):'
         # of positional arguments of the alias.
         self.alias_table = {}
 
+        # Now that FakeModule produces a real module, we've run into a nasty
+        # problem: after script execution (via %run), the module where the user
+        # code ran is deleted.  Now that this object is a true module (needed
+        # so docetst and other tools work correctly), the Python module
+        # teardown mechanism runs over it, and sets to None every variable
+        # present in that module.  Top-level references to objects from the
+        # script survive, because the user_ns is updated with them.  However,
+        # calling functions defined in the script that use other things from
+        # the script will fail, because the function's closure had references
+        # to the original objects, which are now all None.  So we must protect
+        # these modules from deletion by keeping a cache.  To avoid keeping
+        # stale modules around (we only need the one from the last run), we use
+        # a dict keyed with the full path to the script, so only the last
+        # version of the module is held in the cache.  The %reset command will
+        # flush this cache.  See the cache_main_mod() and clear_main_mod_cache()
+        # methods for details on use.
+        self._user_main_modules = {}
+
         # A table holding all the namespaces IPython deals with, so that
         # introspection facilities can search easily.
         self.ns_table = {'user':user_ns,
@@ -309,9 +324,14 b' class InteractiveShell(object,Magic):'
                          'internal':self.internal_ns,
                          'builtin':__builtin__.__dict__
                          }
-        # The user namespace MUST have a pointer to the shell itself.
-        self.user_ns[name] = self
 
+        # Similarly, track all namespaces where references can be held and that
+        # we can safely clear (so it can NOT include builtin).  This one can be
+        # a simple list.
+        self.ns_refs_table = [ user_ns, user_global_ns, self.user_config_ns,
+                               self.alias_table, self.internal_ns,
+                               self._user_main_modules ]
+        
         # We need to insert into sys.modules something that looks like a
         # module but which accesses the IPython namespace, for shelve and
         # pickle to work interactively. Normally they rely on getting
@@ -336,28 +356,13 b' class InteractiveShell(object,Magic):'
                 #print "pickle hack in place"  # dbg
                 #print 'main_name:',main_name # dbg
                 sys.modules[main_name] = FakeModule(self.user_ns)
-
-        # Now that FakeModule produces a real module, we've run into a nasty
-        # problem: after script execution (via %run), the module where the user
-        # code ran is deleted.  Now that this object is a true module (needed
-        # so docetst and other tools work correctly), the Python module
-        # teardown mechanism runs over it, and sets to None every variable
-        # present in that module.  This means that later calls to functions
-        # defined in the script (which have become interactively visible after
-        # script exit) fail, because they hold references to objects that have
-        # become overwritten into None.  The only solution I see right now is
-        # to protect every FakeModule used by %run by holding an internal
-        # reference to it.  This private list will be used for that.  The
-        # %reset command will flush it as well.
-        self._user_main_modules = []
-
+        
         # List of input with multi-line handling.
-        # Fill its zero entry, user counter starts at 1
-        self.input_hist = InputList(['\n'])
+        self.input_hist = InputList()
         # This one will hold the 'raw' input history, without any
         # pre-processing.  This will allow users to retrieve the input just as
         # it was exactly typed in by the user, with %hist -r.
-        self.input_hist_raw = InputList(['\n'])
+        self.input_hist_raw = InputList()
 
         # list of visited directories
         try:
@@ -383,17 +388,7 b' class InteractiveShell(object,Magic):'
             no_alias[key] = 1
         no_alias.update(__builtin__.__dict__)
         self.no_alias = no_alias
-                
-        # make global variables for user access to these
-        self.user_ns['_ih'] = self.input_hist
-        self.user_ns['_oh'] = self.output_hist
-        self.user_ns['_dh'] = self.dir_hist
-
-        # user aliases to input and output histories
-        self.user_ns['In']  = self.input_hist
-        self.user_ns['Out'] = self.output_hist
 
-        self.user_ns['_sh'] = IPython.shadowns
         # Object variable to store code object waiting execution.  This is
         # used mainly by the multithreaded shells, but it can come in handy in
         # other situations.  No need to use a Queue here, since it's a single
@@ -586,11 +581,13 b' class InteractiveShell(object,Magic):'
         else:
             auto_alias = ()
         self.auto_alias = [s.split(None,1) for s in auto_alias]
-
         
         # Produce a public API instance
         self.api = IPython.ipapi.IPApi(self)
 
+        # Initialize all user-visible namespaces
+        self.init_namespaces()
+        
         # Call the actual (public) initializer
         self.init_auto_alias()
 
@@ -601,10 +598,6 b' class InteractiveShell(object,Magic):'
         
         #TODO: remove this, redundant
         self.add_builtins()
-
-        
-        
-
     # end __init__
 
     def var_expand(self,cmd,depth=0):
@@ -633,16 +626,15 b' class InteractiveShell(object,Magic):'
         """
         rc = self.rc
         try:
-            self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")            
+            self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
         except exceptions.UnicodeDecodeError:
             print "Your ipythondir can't be decoded to unicode!"
             print "Please set HOME environment variable to something that"
             print r"only has ASCII characters, e.g. c:\home"
             print "Now it is",rc.ipythondir
             sys.exit()
-        self.shadowhist = IPython.history.ShadowHist(self.db)            
-            
-    
+        self.shadowhist = IPython.history.ShadowHist(self.db)
+
     def post_config_initialization(self):
         """Post configuration init method
 
@@ -662,7 +654,6 b' class InteractiveShell(object,Magic):'
         # Load readline proper
         if rc.readline:
             self.init_readline()
-
         
         # local shortcut, this is used a LOT
         self.log = self.logger.log
@@ -729,6 +720,39 b' class InteractiveShell(object,Magic):'
         if batchrun and not self.rc.interact:
             self.ask_exit()            
 
+    def init_namespaces(self):
+        """Initialize all user-visible namespaces to their minimum defaults.
+
+        Certain history lists are also initialized here, as they effectively
+        act as user namespaces.
+
+        Note
+        ----
+        All data structures here are only filled in, they are NOT reset by this
+        method.  If they were not empty before, data will simply be added to
+        therm.
+        """
+        # The user namespace MUST have a pointer to the shell itself.
+        self.user_ns[self.name] = self
+
+        # Store the public api instance
+        self.user_ns['_ip'] = self.api
+
+        # make global variables for user access to the histories
+        self.user_ns['_ih'] = self.input_hist
+        self.user_ns['_oh'] = self.output_hist
+        self.user_ns['_dh'] = self.dir_hist
+
+        # user aliases to input and output histories
+        self.user_ns['In']  = self.input_hist
+        self.user_ns['Out'] = self.output_hist
+
+        self.user_ns['_sh'] = IPython.shadowns
+
+        # Fill the history zero entry, user counter starts at 1
+        self.input_hist.append('\n')
+        self.input_hist_raw.append('\n')
+
     def add_builtins(self):
         """Store ipython references into the builtin namespace.
 
@@ -909,7 +933,6 b' class InteractiveShell(object,Magic):'
     call_pdb = property(_get_call_pdb,_set_call_pdb,None,
                         'Control auto-activation of pdb at exceptions')
  
-
     # These special functions get installed in the builtin namespace, to
     # provide programmatic (pure python) access to magics, aliases and system
     # calls.  This is important for logging, user scripting, and more.
@@ -1139,7 +1162,8 b' IPython will create a minimal default configuration for you.'
                 inif = 'ipythonrc.ini'
             else:
                 inif = 'ipythonrc'
-            minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults', inif : '# intentionally left blank' }    
+            minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults',
+                             inif : '# intentionally left blank' }
             os.makedirs(ipythondir, mode = 0777)
             for f, cont in minimal_setup.items():
                 open(ipythondir + '/' + f,'w').write(cont)
@@ -1257,7 +1281,27 b' want to merge them back into the new files.""" % locals()'
             except OSError:
                 pass
 
+        # Clear all user namespaces to release all references cleanly.
+        self.reset()
+
+        # Run user hooks
         self.hooks.shutdown_hook()
+
+    def reset(self):
+        """Clear all internal namespaces.
+
+        Note that this is much more aggressive than %reset, since it clears
+        fully all namespaces, as well as all input/output lists.
+        """
+        for ns in self.ns_refs_table:
+            ns.clear()
+
+        # Clear input and output histories
+        self.input_hist[:] = []
+        self.input_hist_raw[:] = []
+        self.output_hist.clear()
+        # Restore the user namespaces to minimal usability
+        self.init_namespaces()
         
     def savehist(self):
         """Save input history to a file (via readline library)."""
@@ -1298,7 +1342,6 b' want to merge them back into the new files.""" % locals()'
             finally:
                 readline.read_history_file(self.histfile)
         return wrapper
-                
             
     def pre_readline(self):
         """readline hook to be used at the start of each line.
@@ -1371,6 +1414,7 b' want to merge them back into the new files.""" % locals()'
             # not run as the syntax for libedit is different.
             if not readline.uses_libedit:
                 for rlcommand in self.rc.readline_parse_and_bind:
+                    #print "loading rl:",rlcommand  # dbg
                     readline.parse_and_bind(rlcommand)
 
             # remove some chars from the delimiters list
@@ -1396,7 +1440,59 b' want to merge them back into the new files.""" % locals()'
         if self.rc.quiet:
             return True
         return ask_yes_no(prompt,default)
-    
+
+    def cache_main_mod(self,mod):
+        """Cache a main module.
+
+        When scripts are executed via %run, we must keep a reference to their
+        __main__ module (a FakeModule instance) around so that Python doesn't
+        clear it, rendering objects defined therein useless.
+
+        This method keeps said reference in a private dict, keyed by the
+        absolute path of the module object (which corresponds to the script
+        path).  This way, for multiple executions of the same script we only
+        keep one copy of __main__ (the last one), thus preventing memory leaks
+        from old references while allowing the objects from the last execution
+        to be accessible.
+
+        Parameters
+        ----------
+          mod : a module object
+
+        Examples
+        --------
+
+        In [10]: import IPython
+
+        In [11]: _ip.IP.cache_main_mod(IPython)
+
+        In [12]: IPython.__file__ in _ip.IP._user_main_modules
+        Out[12]: True
+        """
+        self._user_main_modules[os.path.abspath(mod.__file__) ] = mod
+
+    def clear_main_mod_cache(self):
+        """Clear the cache of main modules.
+
+        Mainly for use by utilities like %reset.
+
+        Examples
+        --------
+
+        In [15]: import IPython
+
+        In [16]: _ip.IP.cache_main_mod(IPython)
+
+        In [17]: len(_ip.IP._user_main_modules) > 0
+        Out[17]: True
+
+        In [18]: _ip.IP.clear_main_mod_cache()
+
+        In [19]: len(_ip.IP._user_main_modules) == 0
+        Out[19]: True
+        """
+        self._user_main_modules.clear()
+
     def _should_recompile(self,e):
         """Utility routine for edit_syntax_error"""
 
@@ -1556,8 +1652,6 b' want to merge them back into the new files.""" % locals()'
                         self.set_completer()
         except KeyboardInterrupt:
             self.write("\nKeyboardInterrupt\n")
-            
-        
 
     def mainloop(self,banner=None):
         """Creates the local namespace and starts the mainloop.
@@ -1585,7 +1679,9 b' want to merge them back into the new files.""" % locals()'
             try:
                 self.interact(banner)
                 #self.interact_with_readline()                
-                # XXX for testing of a readline-decoupled repl loop, call interact_with_readline above
+
+                # XXX for testing of a readline-decoupled repl loop, call
+                # interact_with_readline above
 
                 break
             except KeyboardInterrupt:
@@ -1866,7 +1962,7 b' want to merge them back into the new files.""" % locals()'
         """
         line = fn + " " + rest
         
-        done = Set()
+        done = set()
         while 1:
             pre,fn,rest = prefilter.splitUserInput(line,
                                                    prefilter.shell_line_split)
@@ -1978,7 +2074,6 b' want to merge them back into the new files.""" % locals()'
             # NOT skip even a blank line if we are in a code block (more is
             # true)
             
-            
             if line or more:
                 # push to raw history, so hist line numbers stay in sync
                 self.input_hist_raw.append("# " + line + "\n")

IPython/ipmaker.py

@@ -5,32 +5,28 b' IPython -- An enhanced Interactive Python'
 Requires Python 2.1 or better.
 
 This file contains the main make_IPython() starter function.
-
-$Id: ipmaker.py 2930 2008-01-11 07:03:11Z vivainio $"""
+"""
 
 #*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
+#       Copyright (C) 2008-2009 The IPython Development Team
+#       Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-__version__ = Release.version
-
 try:
     credits._Printer__data = """
     Python: %s
 
-    IPython: Fernando Perez, Janko Hauser, Nathan Gray, and many users.
+    IPython: The IPython Development Team.
     See http://ipython.scipy.org for more information.""" \
     % credits._Printer__data
 
     copyright._Printer__data += """
 
-    Copyright (c) 2001-2004 Fernando Perez, Janko Hauser, Nathan Gray.
+    Copyright (c) 2008-2009 The IPython Development Team.
+    Copyright (c) 2001-2007 Fernando Perez, Janko Hauser, Nathan Gray.
     All Rights Reserved."""
 except NameError:
     # Can happen if ipython was started with 'python -S', so that site.py is
@@ -51,6 +47,7 b' from pprint import pprint,pformat'
 
 # Our own
 from IPython import DPyGetOpt
+from IPython import Release
 from IPython.ipstruct import Struct
 from IPython.OutputTrap import OutputTrap
 from IPython.ConfigLoader import ConfigLoader
@@ -108,8 +105,6 b' def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,'
         IP.user_ns['help'] = _Helper()
     except ImportError:
         warn('help() not available - check site.py')
-    IP.user_config_ns = {}
-
 
     if DEVDEBUG:
         # For developer debugging only (global flag)
@@ -121,7 +116,7 b' def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,'
                          'for more information.\n'
                          % (sys.version.split('\n')[0],),
                          "IPython %s -- An enhanced Interactive Python."
-                         % (__version__,),
+                         % (Release.version,),
 """\
 ?         -> Introduction and overview of IPython's features.
 %quickref -> Quick reference.
@@ -131,20 +126,15 b" object? -> Details about 'object'. ?object also works, ?? prints more."
 
     IP.usage = interactive_usage
 
-    # Platform-dependent suffix and directory names.  We use _ipython instead
-    # of .ipython under win32 b/c there's software that breaks with .named
-    # directories on that platform.
+    # Platform-dependent suffix.
     if os.name == 'posix':
         rc_suffix = ''
-        ipdir_def = '.ipython'
     else:
         rc_suffix = '.ini'
-        ipdir_def = '_ipython'
 
     # default directory for configuration
-    ipythondir_def = os.path.abspath(os.environ.get('IPYTHONDIR',
-                                 os.path.join(IP.home_dir,ipdir_def)))
-
+    ipythondir_def = get_ipython_dir() 
+    
     sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran
 
     # we need the directory where IPython itself is installed
@@ -335,7 +325,7 b" object? -> Details about 'object'. ?object also works, ?? prints more."
         sys.exit()
 
     if opts_all.Version:
-        print __version__
+        print Release.version
         sys.exit()
 
     if opts_all.magic_docstrings:

IPython/ipstruct.py

@@ -1,7 +1,6 b''
 # -*- coding: utf-8 -*-
 """Mimic C structs with lots of extra functionality.
-
-$Id: ipstruct.py 1950 2006-11-28 19:15:35Z vivainio $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2001-2004 Fernando Perez <[e-mail]>
@@ -10,10 +9,6 b' $Id: ipstruct.py 1950 2006-11-28 19:15:35Z vivainio $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 __all__ = ['Struct']
 
 import types
@@ -163,8 +158,22 b' class Struct:'
         return self.__dict__[key]
 
     def __contains__(self,key):
-        """Allows use of the 'in' operator."""
-        return self.__dict__.has_key(key)
+        """Allows use of the 'in' operator.
+
+        Examples:
+        >>> s = Struct(x=1)
+        >>> 'x' in s
+        True
+        >>> 'y' in s
+        False
+        >>> s[4] = None
+        >>> 4 in s
+        True
+        >>> s.z = None
+        >>> 'z' in s
+        True
+        """
+        return key in self.__dict__
 
     def __iadd__(self,other):
         """S += S2 is a shorthand for S.merge(S2)."""
@@ -246,12 +255,13 b' class Struct:'
         Optionally, one or more key=value pairs can be given at the end for
         direct update."""
 
-        # The funny name __loc_data__ is to prevent a common variable name which
-        # could be a fieled of a Struct to collide with this parameter. The problem
-        # would arise if the function is called with a keyword with this same name
-        # that a user means to add as a Struct field.
+        # The funny name __loc_data__ is to prevent a common variable name
+        # which could be a fieled of a Struct to collide with this
+        # parameter. The problem would arise if the function is called with a
+        # keyword with this same name that a user means to add as a Struct
+        # field.
         newdict = Struct.__make_dict(self,__loc_data__,**kw)
-        for k,v in newdict.items():
+        for k,v in newdict.iteritems():
             self[k] = v
 
     def merge(self,__loc_data__=None,__conflict_solve=None,**kw):

IPython/kernel/core/prompts.py

@@ -1,6 +1,10 b''
 # encoding: utf-8
+"""Classes for handling input/output prompts.
 
-"""Classes for handling input/output prompts."""
+Authors
+-------
+- Fernando Perez <[e-mail]>
+"""
 
 __docformat__ = "restructuredtext en"
 
@@ -15,12 +19,6 b' __docformat__ = "restructuredtext en"'
 # Imports
 #-------------------------------------------------------------------------------
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-__version__ = Release.version
-
-#****************************************************************************
 # Required modules
 import __builtin__
 import os
@@ -32,12 +30,11 b' import time'
 from IPython.external.Itpl import ItplNS
 from macro import Macro
 
-# Temporarily use this until it is ported to ipython1
-
 from IPython import ColorANSI
+from IPython import Release
+from IPython.ipapi import TryNext
 from IPython.ipstruct import Struct
 from IPython.genutils import *
-from IPython.ipapi import TryNext
 
 #****************************************************************************
 #Color schemes for Prompts.
@@ -159,7 +156,7 b' prompt_specials_color = {'
     # Carriage return
     r'\r': '\r',
     # Release version
-    r'\v': __version__,
+    r'\v': Release.version,
     # Root symbol ($ or #)
     r'\$': ROOT_SYMBOL,
     }

IPython/kernel/core/ultraTB.py

@@ -1,5 +1,4 b''
-# encoding: utf-8
-
+# -*- coding: utf-8 -*-
 """
 ultraTB.py -- Spice up your tracebacks!
 
@@ -60,26 +59,15 b' ColorSchemeTable class. Currently the following exist:'
 You can implement other color schemes easily, the syntax is fairly
 self-explanatory. Please send back new schemes you develop to the author for
 possible inclusion in future releases.
+"""
 
-$Id: ultraTB.py 2480 2007-07-06 19:33:43Z fperez $"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
+#*****************************************************************************
+#       Copyright (C) 2001 Nathaniel Gray <[e-mail]>
+#       Copyright (C) 2001-2004 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-from IPython import Release
-__author__  = '%s <%s>\n%s <%s>' % (Release.authors['Nathan']+
-                                    Release.authors['Fernando'])
-__license__ = Release.license
+#*****************************************************************************
 
 # Required modules
 import inspect
@@ -104,7 +92,7 b' from inspect import getsourcefile, getfile, getmodule,\\'
 # Modified pdb which doesn't damage IPython's readline handling
 from IPython import Debugger, PyColorize
 from IPython.ipstruct import Struct
-from IPython.excolors import ExceptionColors
+from IPython.excolors import exception_colors
 from IPython.genutils import Term,uniq_stable,error,info
 
 # Globals
@@ -141,11 +129,18 b' def findsource(object):'
     FIXED version with which we monkeypatch the stdlib to work around a bug."""
 
     file = getsourcefile(object) or getfile(object)
-    module = getmodule(object, file)
-    if module:
-        lines = linecache.getlines(file, module.__dict__)
+    # If the object is a frame, then trying to get the globals dict from its
+    # module won't work. Instead, the frame object itself has the globals
+    # dictionary.
+    globals_dict = None
+    if inspect.isframe(object):
+        # XXX: can this ever be false?
+        globals_dict = object.f_globals
     else:
-        lines = linecache.getlines(file)
+        module = getmodule(object, file)
+        if module:
+            globals_dict = module.__dict__
+    lines = linecache.getlines(file, globals_dict)
     if not lines:
         raise IOError('could not get source code')
 
@@ -202,11 +197,31 b' def findsource(object):'
 if sys.version_info[:2] >= (2,5):
     inspect.findsource = findsource
 
+def fix_frame_records_filenames(records):
+    """Try to fix the filenames in each record from inspect.getinnerframes().
+
+    Particularly, modules loaded from within zip files have useless filenames
+    attached to their code object, and inspect.getinnerframes() just uses it.
+    """
+    fixed_records = []
+    for frame, filename, line_no, func_name, lines, index in records:
+        # Look inside the frame's globals dictionary for __file__, which should
+        # be better.
+        better_fn = frame.f_globals.get('__file__', None)
+        if isinstance(better_fn, str):
+            # Check the type just in case someone did something weird with
+            # __file__. It might also be None if the error occurred during
+            # import.
+            filename = better_fn
+        fixed_records.append((frame, filename, line_no, func_name, lines, index))
+    return fixed_records
+
+
 def _fixed_getinnerframes(etb, context=1,tb_offset=0):
     import linecache
     LNUM_POS, LINES_POS, INDEX_POS =  2, 4, 5
 
-    records  = inspect.getinnerframes(etb, context)
+    records  = fix_frame_records_filenames(inspect.getinnerframes(etb, context))
 
     # If the error is at the console, don't build any context, since it would
     # otherwise produce 5 blank lines printed out (there is no file at the
@@ -299,7 +314,7 b' class TBTools:'
         self.call_pdb = call_pdb
 
         # Create color table
-        self.color_scheme_table = ExceptionColors 
+        self.color_scheme_table = exception_colors()
 
         self.set_colors(color_scheme)
         self.old_scheme = color_scheme  # save initial value for toggles
@@ -356,8 +371,8 b' class ListTB(TBTools):'
         
     def __call__(self, etype, value, elist):
         Term.cout.flush()
-        Term.cerr.flush()
         print >> Term.cerr, self.text(etype,value,elist)
+        Term.cerr.flush()
 
     def text(self,etype, value, elist,context=5):
         """Return a color formatted string with the traceback info."""
@@ -424,7 +439,8 b' class ListTB(TBTools):'
         
         Also lifted nearly verbatim from traceback.py
         """
-        
+
+        have_filedata = False
         Colors = self.Colors
         list = []
         try:
@@ -438,8 +454,9 b' class ListTB(TBTools):'
                 try:
                     msg, (filename, lineno, offset, line) = value
                 except:
-                    pass
+                    have_filedata = False
                 else:
+                    have_filedata = True
                     #print 'filename is',filename  # dbg
                     if not filename: filename = "<string>"
                     list.append('%s  File %s"%s"%s, line %s%d%s\n' % \
@@ -469,6 +486,12 b' class ListTB(TBTools):'
                                               Colors.Normal, s))
             else:
                 list.append('%s\n' % str(stype))
+
+        # vds:>>
+        if have_filedata:
+            __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
+        # vds:<<
+
         return list
 
     def _some_str(self, value):
@@ -780,6 +803,15 b' class VerboseTB(TBTools):'
             for name in names:
                 value = text_repr(getattr(evalue, name))
                 exception.append('\n%s%s = %s' % (indent, name, value))
+
+        # vds: >>
+        if records:
+             filepath, lnum = records[-1][1:3]
+             #print "file:", str(file), "linenb", str(lnum) # dbg
+             filepath = os.path.abspath(filepath)
+             __IPYTHON__.hooks.synchronize_with_editor(filepath, lnum, 0)
+        # vds: <<
+                
         # return all our info assembled as a single string
         return '%s\n\n%s\n%s' % (head,'\n'.join(frames),''.join(exception[0]) )
 
@@ -834,8 +866,8 b' class VerboseTB(TBTools):'
         (etype, evalue, etb) = info or sys.exc_info()
         self.tb = etb
         Term.cout.flush()
-        Term.cerr.flush()
         print >> Term.cerr, self.text(etype, evalue, etb)
+        Term.cerr.flush()
 
     # Changed so an instance can just be called as VerboseTB_inst() and print
     # out the right info on its own.
@@ -845,7 +877,10 b' class VerboseTB(TBTools):'
             self.handler()
         else:
             self.handler((etype, evalue, etb))
-        self.debugger()
+        try:
+            self.debugger()
+        except KeyboardInterrupt:
+            print "\nKeyboardInterrupt"
 
 #----------------------------------------------------------------------------
 class FormattedTB(VerboseTB,ListTB):
@@ -953,14 +988,17 b' class AutoFormattedTB(FormattedTB):'
         if out is None:
             out = Term.cerr
         Term.cout.flush()
-        out.flush()
         if tb_offset is not None:
             tb_offset, self.tb_offset = self.tb_offset, tb_offset
             print >> out, self.text(etype, evalue, etb)
             self.tb_offset = tb_offset
         else:
             print >> out, self.text(etype, evalue, etb)
-        self.debugger()
+        out.flush()
+        try:
+            self.debugger()
+        except KeyboardInterrupt:
+            print "\nKeyboardInterrupt"
 
     def text(self,etype=None,value=None,tb=None,context=5,mode=None):
         if etype is None:

IPython/kernel/core/util.py

@@ -70,8 +70,8 b' def esc_quotes(strng):'
 def make_quoted_expr(s):
     """Return string s in appropriate quotes, using raw string if possible.
     
-    Effectively this turns string: cd \ao\ao\
-    to: r"cd \ao\ao\_"[:-1]
+    XXX - example removed because it caused encoding errors in documentation
+    generation.  We need a new example that doesn't contain invalid chars.
     
     Note the use of raw string and padding at the end to allow trailing
     backslash.

IPython/kernel/tests/engineservicetest.py

@@ -49,8 +49,8 b" validCommands = ['a=5',"
 time.sleep(0.1)""",
                 """from math import cos;
 x = 1.0*cos(0.5)""", # Semicolons lead to Discard ast nodes that should be discarded
-                """from sets import Set
-s = Set()
+                """s = 1
+s = set()
    """, # Trailing whitespace should be allowed.
                 """import math
 math.cos(1.0)""", # Test a method call with a discarded return value

IPython/macro.py

@@ -9,7 +9,6 b''
 
 import IPython.ipapi 
 
-
 from IPython.genutils import Term
 from IPython.ipapi import IPyAutocall
 
@@ -41,4 +40,4 b' class Macro(IPyAutocall):'
     
     def __getstate__(self):
         """ needed for safe pickling via %store """
-        return {'value': self.value}
  No newline at end of file
+        return {'value': self.value}

IPython/numutils.py

@@ -4,8 +4,7 b' A set of convenient utilities for numerical work.'
 
 Most of this module requires Numerical Python or is meant to be used with it.
 See http://www.pfdubois.com/numpy for details.
-
-$Id: numutils.py 958 2005-12-27 23:17:51Z fperez $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2001-2005 Fernando Perez <[e-mail]>
@@ -14,10 +13,6 b' $Id: numutils.py 958 2005-12-27 23:17:51Z fperez $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
 __all__ = ['sum_flat','mean_flat','rms_flat','base_repr','binary_repr',
            'amin','amax','amap','zeros_like','empty_like',
            'frange','diagonal_matrix','identity',

IPython/platutils.py

@@ -12,10 +12,6 b' for your operation system, from platutils_PLATFORMNAME module.'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Ville']
-__license__ = Release.license
-
 import os
 import sys
 
@@ -35,8 +31,26 b' else:'
 # Functionality that's logically common to all platforms goes here, each
 # platform-specific module only provides the bits that are OS-dependent.
 
-def freeze_term_title():
-    _platutils.ignore_termtitle = True
+# XXX - I'm still not happy with a module global for this, but at least now
+# there is a public, cross-platform way of toggling the term title control on
+# and off.  We should make this a stateful object later on so that each user
+# can have its own instance if needed.
+def toggle_set_term_title(val):
+    """Control whether set_term_title is active or not.
+
+    set_term_title() allows writing to the console titlebar.  In embedded
+    widgets this can cause problems, so this call can be used to toggle it on
+    or off as needed.
+
+    The default state of the module is for the function to be disabled.
+
+    Parameters
+    ----------
+      val : bool
+        If True, set_term_title() actually writes to the terminal (using the
+        appropriate platform-specific module).  If False, it is a no-op.
+    """
+    _platutils.ignore_termtitle = not(val)
 
 
 def set_term_title(title):
@@ -45,3 +59,12 b' def set_term_title(title):'
     if _platutils.ignore_termtitle:
         return
     _platutils.set_term_title(title)
+
+
+#-----------------------------------------------------------------------------
+# Deprecated functions
+#-----------------------------------------------------------------------------
+def freeze_term_title():
+    warnings.warn("This function is deprecated, use toggle_set_term_title()")
+    _platutils.ignore_termtitle = True
+

IPython/platutils_dummy.py

@@ -3,19 +3,20 b''
 
 This has empty implementation of the platutils functions, used for 
 unsupported operating systems.
+
+Authors
+-------
+- Ville Vainio <[e-mail]>
 """
 
 #*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
+#       Copyright (C) 2008-2009 The IPython Development Team
+#       Copyright (C) 2001-2007 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Ville']
-__license__ = Release.license
-
 # This variable is part of the expected API of the module:
 ignore_termtitle = True
 

IPython/platutils_posix.py

@@ -12,14 +12,10 b' to use these functions in platform agnostic fashion.'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Ville']
-__license__ = Release.license
-
 import sys
 import os
 
-ignore_termtitle = False
+ignore_termtitle = True
 
 def _dummy_op(*a, **b):
     """ A no-op function """
@@ -27,7 +23,7 b' def _dummy_op(*a, **b):'
 def _set_term_title_xterm(title):
     """ Change virtual terminal title in xterm-workalikes """
 
-    sys.stdout.write('\033]%d;%s\007' % (0,title))
+    sys.stdout.write('\033]0;%s\007' % title)
 
 
 if os.environ.get('TERM','') == 'xterm':

IPython/platutils_win32.py

@@ -12,13 +12,9 b' to use these functions in platform agnostic fashion.'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Ville']
-__license__ = Release.license
-
 import os
 
-ignore_termtitle = False
+ignore_termtitle = True
 
 try:
     import ctypes

IPython/rlineimpl.py

@@ -5,8 +5,7 b" Readline is used throughout IPython as 'import IPython.rlineimpl as readline'."
 
 In addition to normal readline stuff, this module provides have_readline
 boolean and _outputfile variable used in genutils.
-
-$Id: Magic.py 1096 2006-01-28 20:08:02Z vivainio $"""
+"""
 
 import sys
 
@@ -53,4 +52,4 b' if have_readline:'
         _rl.clear_history
     except AttributeError:
         def clear_history(): pass
-        _rl.clear_history = clear_history
  No newline at end of file
+        _rl.clear_history = clear_history

IPython/shellglobals.py

@@ -1,6 +1,13 b''
-from IPython.genutils import Term,warn,error,flag_calls, ask_yes_no
+"""Some globals used by the main Shell classes.
+"""
+
+#-----------------------------------------------------------------------------
+# Module imports
+#-----------------------------------------------------------------------------
 
-import thread,inspect
+# stdlib
+import inspect
+import thread
 
 try:
     import ctypes
@@ -8,8 +15,12 b' try:'
 except ImportError:
     HAS_CTYPES = False
 
+# our own
+from IPython.genutils import Term,warn,error,flag_calls, ask_yes_no
 
+#-----------------------------------------------------------------------------
 # Globals
+#-----------------------------------------------------------------------------
 # global flag to pass around information about Ctrl-C without exceptions
 KBINT = False
 
@@ -22,13 +33,11 b' MAIN_THREAD_ID = thread.get_ident()'
 # Tag when runcode() is active, for exception handling
 CODE_RUN = None
 
-
 #-----------------------------------------------------------------------------
 # This class is trivial now, but I want to have it in to publish a clean
 # interface. Later when the internals are reorganized, code that uses this
 # shouldn't have to change.
 
-
 if HAS_CTYPES:
     #  Add async exception support.  Trick taken from:
     # http://sebulba.wikispaces.com/recipe+thread2
@@ -81,16 +90,12 b' else:'
         # Set global flag so that runsource can know that Ctrl-C was hit
         KBINT = True
 
+
 def run_in_frontend(src):
-    """ Check if source snippet can be run in the REPL thread, as opposed to GUI mainloop
-    
-    (to prevent unnecessary hanging of mainloop).  
-    
+    """ Check if source snippet can be run in the REPL thread, as opposed to
+    GUI mainloop (to prevent unnecessary hanging of mainloop).
     """
     
     if src.startswith('_ip.system(') and not '\n' in src:
         return True
     return False
-    
-    
-    

IPython/strdispatch.py

@@ -8,7 +8,6 b' import re'
 from IPython.hooks import CommandChainDispatcher
 import IPython.hooks
 
-
 # Code begins
 class StrDispatch(object):
     """Dispatch (lookup) a set of strings / regexps for match.

IPython/testing/decorators.py

@@ -1,12 +1,10 b''
 """Decorators for labeling test objects.
 
-Decorators that merely return a modified version of the original
-function object are straightforward.  Decorators that return a new
-function object need to use
-nose.tools.make_decorator(original_function)(decorator) in returning
-the decorator, in order to preserve metadata such as function name,
-setup and teardown functions and so on - see nose.tools for more
-information.
+Decorators that merely return a modified version of the original function
+object are straightforward.  Decorators that return a new function object need
+to use nose.tools.make_decorator(original_function)(decorator) in returning the
+decorator, in order to preserve metadata such as function name, setup and
+teardown functions and so on - see nose.tools for more information.
 
 This module provides a set of useful decorators meant to be ready to use in
 your own tests.  See the bottom of the file for the ready-made ones, and if you
@@ -115,6 +113,115 b' def make_label_dec(label,ds=None):'
     
     return decor
 
+
+# Inspired by numpy's skipif, but uses the full apply_wrapper utility to
+# preserve function metadata better and allows the skip condition to be a
+# callable.
+def skipif(skip_condition, msg=None):
+    ''' Make function raise SkipTest exception if skip_condition is true
+
+    Parameters
+    ----------
+    skip_condition : bool or callable. 
+ 	Flag to determine whether to skip test.  If the condition is a 
+ 	callable, it is used at runtime to dynamically make the decision.  This 
+ 	is useful for tests that may require costly imports, to delay the cost 
+ 	until the test suite is actually executed.        
+    msg : string
+        Message to give on raising a SkipTest exception
+
+   Returns
+   -------
+   decorator : function
+       Decorator, which, when applied to a function, causes SkipTest
+       to be raised when the skip_condition was True, and the function
+       to be called normally otherwise.
+
+    Notes
+    -----
+    You will see from the code that we had to further decorate the
+    decorator with the nose.tools.make_decorator function in order to
+    transmit function name, and various other metadata.
+    '''
+
+    def skip_decorator(f):
+        # Local import to avoid a hard nose dependency and only incur the 
+        # import time overhead at actual test-time. 
+        import nose
+
+        # Allow for both boolean or callable skip conditions.
+        if callable(skip_condition):
+            skip_val = lambda : skip_condition()
+        else:
+            skip_val = lambda : skip_condition
+
+        def get_msg(func,msg=None):
+            """Skip message with information about function being skipped."""
+            if msg is None: out = 'Test skipped due to test condition.'
+            else: out = msg
+            return "Skipping test: %s. %s" % (func.__name__,out)
+
+        # We need to define *two* skippers because Python doesn't allow both
+        # return with value and yield inside the same function.
+        def skipper_func(*args, **kwargs):
+            """Skipper for normal test functions."""
+            if skip_val():
+                raise nose.SkipTest(get_msg(f,msg))
+            else:
+                return f(*args, **kwargs) 
+
+        def skipper_gen(*args, **kwargs):
+            """Skipper for test generators."""
+            if skip_val():
+                raise nose.SkipTest(get_msg(f,msg))
+            else:
+                for x in f(*args, **kwargs):
+                    yield x
+
+        # Choose the right skipper to use when building the actual generator.
+        if nose.util.isgenerator(f):
+            skipper = skipper_gen
+        else:
+            skipper = skipper_func
+            
+        return nose.tools.make_decorator(f)(skipper)
+
+    return skip_decorator
+
+# A version with the condition set to true, common case just to attacha message
+# to a skip decorator
+def skip(msg=None):
+    """Decorator factory - mark a test function for skipping from test suite.
+
+    :Parameters:
+      msg : string
+        Optional message to be added.
+
+    :Returns:
+       decorator : function
+         Decorator, which, when applied to a function, causes SkipTest
+         to be raised, with the optional message added.
+      """
+
+    return skipif(True,msg)
+
+
+#-----------------------------------------------------------------------------
+# Utility functions for decorators
+def numpy_not_available():
+    """Can numpy be imported?  Returns true if numpy does NOT import.
+
+    This is used to make a decorator to skip tests that require numpy to be
+    available, but delay the 'import numpy' to test execution time.
+    """
+    try:
+        import numpy
+        np_not_avail = False
+    except ImportError:
+        np_not_avail = True
+
+    return np_not_avail
+
 #-----------------------------------------------------------------------------
 # Decorators for public use
 
@@ -125,36 +232,23 b" skip_doctest = make_label_dec('skip_doctest',"
     omit from testing, while preserving the docstring for introspection, help,
     etc.""")                              
 
-def skip(msg=''):
-    """Decorator - mark a test function for skipping from test suite.
-
-    This function *is* already a decorator, it is not a factory like
-    make_label_dec or some of those in decorators_numpy.
-
-    :Parameters:
-
-      func : function
-        Test function to be skipped
-
-      msg : string
-        Optional message to be added.
-      """
-
-    import nose
-
-    def inner(func):
+# Decorators to skip certain tests on specific platforms.
+skip_win32 = skipif(sys.platform == 'win32',
+                    "This test does not run under Windows")
+skip_linux = skipif(sys.platform == 'linux2',
+                    "This test does not run under Linux")
+skip_osx = skipif(sys.platform == 'darwin',"This test does not run under OS X")
 
-        def wrapper(*a,**k):
-            if msg: out = '\n'+msg
-            else: out = ''
-            raise nose.SkipTest("Skipping test for function: %s%s" %
-                                (func.__name__,out))
 
-        return apply_wrapper(wrapper,func)
+# Decorators to skip tests if not on specific platforms.
+skip_if_not_win32 = skipif(sys.platform != 'win32',
+                           "This test only runs under Windows")
+skip_if_not_linux = skipif(sys.platform != 'linux2',
+                           "This test only runs under Linux")
+skip_if_not_osx = skipif(sys.platform != 'darwin',
+                         "This test only runs under OSX")
 
-    return inner
+# Other skip decorators
+skipif_not_numpy = skipif(numpy_not_available,"This test requires numpy")
 
-# Decorators to skip certain tests on specific platforms.
-skip_win32 = skipif(sys.platform=='win32',"This test does not run under Windows")
-skip_linux = skipif(sys.platform=='linux2',"This test does not run under Linux")
-skip_osx = skipif(sys.platform=='darwin',"This test does not run under OSX")
+skipknownfailure = skip('This test is known to fail')

IPython/testing/decorators_numpy.py

@@ -46,13 +46,16 b' def setastest(tf=True):'
         return t
     return set_test
 
-def skipif(skip_condition, msg=None):
+def skipif(skip_condition=True, msg=None):
     ''' Make function raise SkipTest exception if skip_condition is true
 
     Parameters
-    ---------
-    skip_condition : bool
-        Flag to determine whether to skip test (True) or not (False)
+    ----------
+    skip_condition : bool or callable. 
+ 	Flag to determine whether to skip test.  If the condition is a 
+ 	callable, it is used at runtime to dynamically make the decision.  This 
+ 	is useful for tests that may require costly imports, to delay the cost 
+ 	until the test suite is actually executed.        
     msg : string
         Message to give on raising a SkipTest exception
 

IPython/testing/iptest.py

@@ -1,16 +1,52 b''
-#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """IPython Test Suite Runner.
+
+This module provides a main entry point to a user script to test IPython itself
+from the command line.  The main() routine can be used in a similar manner to
+the ``nosetests`` script, and it takes similar arguments, but if no arguments
+are given it defaults to testing all of IPython.  This should be preferred to
+using plain ``nosetests`` because a number of nose plugins necessary to test
+IPython correctly are automatically configured by this code.
 """
 
+#-----------------------------------------------------------------------------
+# Module imports
+#-----------------------------------------------------------------------------
+
+# stdlib
 import sys
 import warnings
 
-from nose.core import TestProgram
+# third-party
 import nose.plugins.builtin
+from nose.core import TestProgram
 
+# Our own imports
 from IPython.testing.plugin.ipdoctest import IPythonDoctest
 
+#-----------------------------------------------------------------------------
+# Constants and globals
+#-----------------------------------------------------------------------------
+
+# For the IPythonDoctest plugin, we need to exclude certain patterns that cause
+# testing problems.  We should strive to minimize the number of skipped
+# modules, since this means untested code.  As the testing machinery
+# solidifies, this list should eventually become empty.
+EXCLUDE = ['IPython/external/',
+           'IPython/platutils_win32',
+           'IPython/frontend/cocoa',
+           'IPython_doctest_plugin',
+           'IPython/Gnuplot',
+           'IPython/Extensions/ipy_',
+           'IPython/Extensions/clearcmd',
+           'IPython/Extensions/PhysicalQIn',
+           'IPython/Extensions/scitedirector',
+           ]
+
+#-----------------------------------------------------------------------------
+# Functions and classes
+#-----------------------------------------------------------------------------
+
 def main():
     """Run the IPython test suite.
     """
@@ -18,36 +54,45 b' def main():'
     warnings.filterwarnings('ignore', 
         'This will be removed soon.  Use IPython.testing.util instead')
 
-    
-    # construct list of plugins, omitting the existing doctest plugin
-    plugins = [IPythonDoctest()]
+    argv = sys.argv + [ 
+                        # Loading ipdoctest causes problems with Twisted.
+                        # I am removing this as a temporary fix to get the 
+                        # test suite back into working shape.  Our nose
+                        # plugin needs to be gone through with a fine
+                        # toothed comb to find what is causing the problem.
+                        # '--with-ipdoctest',
+                        '--doctest-tests','--doctest-extension=txt',
+                        '--detailed-errors',
+                       
+                        # We add --exe because of setuptools' imbecility (it
+                        # blindly does chmod +x on ALL files).  Nose does the
+                        # right thing and it tries to avoid executables,
+                        # setuptools unfortunately forces our hand here.  This
+                        # has been discussed on the distutils list and the
+                        # setuptools devs refuse to fix this problem!
+                        '--exe',
+                        ]
+
+    # Detect if any tests were required by explicitly calling an IPython
+    # submodule or giving a specific path
+    has_tests = False
+    for arg in sys.argv:
+        if 'IPython' in arg or arg.endswith('.py') or \
+           (':' in arg and  '.py' in arg):
+            has_tests = True
+            break
+    # If nothing was specifically requested, test full IPython
+    if not has_tests:
+        argv.append('IPython')
+
+    # Construct list of plugins, omitting the existing doctest plugin.
+    plugins = [IPythonDoctest(EXCLUDE)]
     for p in nose.plugins.builtin.plugins:
         plug = p()
         if plug.name == 'doctest':
             continue
 
-        #print 'adding plugin:',plug.name  # dbg
+        #print '*** adding plugin:',plug.name  # dbg
         plugins.append(plug)
 
-    argv = sys.argv + ['--doctest-tests','--doctest-extension=txt',
-                       '--detailed-errors',
-                       
-                       # We add --exe because of setuptools' imbecility (it
-                       # blindly does chmod +x on ALL files).  Nose does the
-                       # right thing and it tries to avoid executables,
-                       # setuptools unfortunately forces our hand here.  This
-                       # has been discussed on the distutils list and the
-                       # setuptools devs refuse to fix this problem!
-                       '--exe',
-                       ]
-
-    has_ip = False
-    for arg in sys.argv:
-        if 'IPython' in arg:
-            has_ip = True
-            break
-
-    if not has_ip:
-        argv.append('IPython')
-
     TestProgram(argv=argv,plugins=plugins)

IPython/testing/plugin/Makefile

@@ -36,8 +36,8 b' deco:'
 magic: plugin
 	$(NOSE) IPython.Magic
 
-ipipe: plugin
-	$(NOSE) IPython.Extensions.ipipe
+excolors: plugin
+	$(NOSE) IPython.excolors
 
 iplib: plugin
 	$(NOSE)  IPython.iplib

IPython/testing/plugin/dtexample.py

@@ -29,9 +29,6 b' def ipfunc():'
 
     In [1]: import os
 
-    In [2]: cd /
-    /
-
     In [3]: 2+3
     Out[3]: 5
 

IPython/testing/plugin/ipdoctest.py

@@ -65,13 +65,28 b' log = logging.getLogger(__name__)'
 # test globals.  Once we move over to a clean magic system, this will be done
 # with much less ugliness.
 
+class py_file_finder(object):
+    def __init__(self,test_filename):
+        self.test_filename = test_filename
+        
+    def __call__(self,name):
+        from IPython.genutils import get_py_filename
+        try:
+            return get_py_filename(name)
+        except IOError:
+            test_dir = os.path.dirname(self.test_filename)
+            new_path = os.path.join(test_dir,name)
+            return get_py_filename(new_path)
+    
+
 def _run_ns_sync(self,arg_s,runner=None):
     """Modified version of %run that syncs testing namespaces.
 
     This is strictly needed for running doctests that call %run.
     """
 
-    out = _ip.IP.magic_run_ori(arg_s,runner)
+    finder = py_file_finder(_run_ns_sync.test_filename)
+    out = _ip.IP.magic_run_ori(arg_s,runner,finder)
     _run_ns_sync.test_globs.update(_ip.user_ns)
     return out
 
@@ -129,8 +144,7 b' def start_ipython():'
 
     # Start IPython instance.  We customize it to start with minimal frills.
     user_ns,global_ns = IPython.ipapi.make_user_namespaces(ipnsdict(),dict())
-    
-    IPython.Shell.IPShell(['--classic','--noterm_title'],
+    IPython.Shell.IPShell(['--colors=NoColor','--noterm_title'],
                           user_ns,global_ns)
 
     # Deactivate the various python system hooks added by ipython for
@@ -172,13 +186,19 b' def is_extension_module(filename):'
     return os.path.splitext(filename)[1].lower() in ('.so','.pyd')
 
 
-class nodoc(object):
+class DocTestSkip(object):
+    """Object wrapper for doctests to be skipped."""
+    
+    ds_skip = """Doctest to skip.
+    >>> 1 #doctest: +SKIP
+    """
+
     def __init__(self,obj):
         self.obj = obj
 
     def __getattribute__(self,key):
         if key == '__doc__':
-            return None
+            return DocTestSkip.ds_skip
         else:
             return getattr(object.__getattribute__(self,'obj'),key)
 
@@ -222,7 +242,7 b' class DocTestFinder(doctest.DocTestFinder):'
 
         if hasattr(obj,"skip_doctest"):
             #print 'SKIPPING DOCTEST FOR:',obj  # dbg
-            obj = nodoc(obj)
+            obj = DocTestSkip(obj)
 
         doctest.DocTestFinder._find(self,tests, obj, name, module,
                                     source_lines, globs, seen)
@@ -372,7 +392,6 b' class DocTestCase(doctests.DocTestCase):'
             self._dt_test.globs = _ip.IP.user_ns
 
         doctests.DocTestCase.setUp(self)
-    
 
 
 # A simple subclassing of the original with a different class name, so we can
@@ -444,7 +463,11 b' class IPDocTestParser(doctest.DocTestParser):'
         """Convert input IPython source into valid Python."""
         out = []
         newline = out.append
-        for lnum,line in enumerate(source.splitlines()):
+        #print 'IPSRC:\n',source,'\n###'  # dbg
+        # The input source must be first stripped of all bracketing whitespace
+        # and turned into lines, so it looks to the parser like regular user
+        # input
+        for lnum,line in enumerate(source.strip().splitlines()):
             newline(_ip.IP.prefilter(line,lnum>0))
         newline('')  # ensure a closing newline, needed by doctest
         #print "PYSRC:", '\n'.join(out)  # dbg
@@ -638,7 +661,8 b' class IPDocTestRunner(doctest.DocTestRunner,object):'
         # when called (rather than unconconditionally updating test.globs here
         # for all examples, most of which won't be calling %run anyway).
         _run_ns_sync.test_globs = test.globs
-
+        _run_ns_sync.test_filename = test.filename
+        
         return super(IPDocTestRunner,self).run(test,
                                                compileflags,out,clear_globs)
 
@@ -656,6 +680,22 b' class ExtensionDoctest(doctests.Doctest):'
     name = 'extdoctest'   # call nosetests with --with-extdoctest
     enabled = True
 
+    def __init__(self,exclude_patterns=None):
+        """Create a new ExtensionDoctest plugin.
+
+        Parameters
+        ----------
+
+        exclude_patterns : sequence of strings, optional
+          These patterns are compiled as regular expressions, subsequently used
+          to exclude any filename which matches them from inclusion in the test
+          suite (using pattern.search(), NOT pattern.match() ).
+        """
+        if exclude_patterns is None:
+            exclude_patterns = []
+        self.exclude_patterns = map(re.compile,exclude_patterns)
+        doctests.Doctest.__init__(self)
+
     def options(self, parser, env=os.environ):
         Plugin.options(self, parser, env)
         parser.add_option('--doctest-tests', action='store_true',
@@ -688,6 +728,7 b' class ExtensionDoctest(doctests.Doctest):'
         self.globs = None
         self.extraglobs = None
 
+
     def loadTestsFromExtensionModule(self,filename):
         bpath,mod = os.path.split(filename)
         modname = os.path.splitext(mod)[0]
@@ -703,8 +744,8 b' class ExtensionDoctest(doctests.Doctest):'
     # a  few modifications to control output checking.
 
     def loadTestsFromModule(self, module):
-        #print 'lTM',module  # dbg
-
+        #print '*** ipdoctest - lTM',module  # dbg
+        
         if not self.matches(module.__name__):
             log.debug("Doctest doesn't want module %s", module)
             return
@@ -733,8 +774,6 b' class ExtensionDoctest(doctests.Doctest):'
 
 
     def loadTestsFromFile(self, filename):
-        #print 'lTF',filename  # dbg
-
         if is_extension_module(filename):
             for t in self.loadTestsFromExtensionModule(filename):
                 yield t
@@ -761,22 +800,10 b' class ExtensionDoctest(doctests.Doctest):'
         Modified version that accepts extension modules as valid containers for
         doctests.
         """
-        print 'Filename:',filename  # dbg
-
-        # XXX - temporarily hardcoded list, will move to driver later
-        exclude = ['IPython/external/',
-                   'IPython/platutils_win32',
-                   'IPython/frontend/cocoa',
-                   'IPython_doctest_plugin',
-                   'IPython/Gnuplot',
-                   'IPython/Extensions/ipy_',
-                   'IPython/Extensions/PhysicalQIn',
-                   'IPython/Extensions/scitedirector',
-                   'IPython/testing/plugin',
-                   ]
-
-        for fex in exclude:
-            if fex in filename:  # substring
+        #print '*** ipdoctest- wantFile:',filename  # dbg
+
+        for pat in self.exclude_patterns:
+            if pat.search(filename):
                 #print '###>>> SKIP:',filename  # dbg
                 return False
 
@@ -791,6 +818,23 b' class IPythonDoctest(ExtensionDoctest):'
     """
     name = 'ipdoctest'   # call nosetests with --with-ipdoctest
     enabled = True
+    
+    def makeTest(self, obj, parent):
+        """Look for doctests in the given object, which will be a
+        function, method or class.
+        """
+        # always use whitespace and ellipsis options
+        optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
+
+        doctests = self.finder.find(obj, module=getmodule(parent))
+        if doctests:
+            for test in doctests:
+                if len(test.examples) == 0:
+                    continue
+
+                yield DocTestCase(test, obj=obj,
+                                  optionflags=optionflags,
+                                  checker=self.checker)
 
     def configure(self, options, config):
 

IPython/tests/test_genutils.py

@@ -15,18 +15,277 b' __docformat__ = "restructuredtext en"'
 # Imports
 #-----------------------------------------------------------------------------
 
+# stdlib
+import os
+import shutil
+import sys
+import tempfile
+
+from os.path import join, abspath, split
+
+# third-party
+import nose.tools as nt
+
+from nose import with_setup
+from nose.tools import raises
+
+# Our own
+import IPython
 from IPython import genutils
+from IPython.testing.decorators import skipif, skip_if_not_win32
+
+# Platform-dependent imports
+try:
+    import _winreg as wreg
+except ImportError:
+    #Fake _winreg module on none windows platforms
+    import new
+    sys.modules["_winreg"] = new.module("_winreg")
+    import _winreg as wreg
+    #Add entries that needs to be stubbed by the testing code
+    (wreg.OpenKey, wreg.QueryValueEx,) = (None, None)
+
+#-----------------------------------------------------------------------------
+# Globals
+#-----------------------------------------------------------------------------
+env = os.environ
+TEST_FILE_PATH = split(abspath(__file__))[0]
+TMP_TEST_DIR = tempfile.mkdtemp()
+HOME_TEST_DIR = join(TMP_TEST_DIR, "home_test_dir")
+IP_TEST_DIR = join(HOME_TEST_DIR,'_ipython')
+#
+# Setup/teardown functions/decorators
+#
+
+def setup():
+    """Setup testenvironment for the module:
+    
+            - Adds dummy home dir tree
+    """
+    # Do not mask exceptions here.  In particular, catching WindowsError is a
+    # problem because that exception is only defined on Windows...
+    os.makedirs(IP_TEST_DIR)
+
+def teardown():
+    """Teardown testenvironment for the module:
+    
+            - Remove dummy home dir tree
+    """
+    # Note: we remove the parent test dir, which is the root of all test
+    # subdirs we may have created.  Use shutil instead of os.removedirs, so
+    # that non-empty directories are all recursively removed.
+    shutil.rmtree(TMP_TEST_DIR)
+
+    
+def setup_environment():
+    """Setup testenvironment for some functions that are tested 
+    in this module. In particular this functions stores attributes
+    and other things that we need to stub in some test functions.
+    This needs to be done on a function level and not module level because 
+    each testfunction needs a pristine environment.
+    """
+    global oldstuff, platformstuff
+    oldstuff = (env.copy(), os.name, genutils.get_home_dir, IPython.__file__,)
+
+    if os.name == 'nt':
+        platformstuff = (wreg.OpenKey, wreg.QueryValueEx,)
+
+    if 'IPYTHONDIR' in env:
+        del env['IPYTHONDIR']
+
+def teardown_environment():
+    """Restore things that were remebered by the setup_environment function
+    """
+    (oldenv, os.name, genutils.get_home_dir, IPython.__file__,) = oldstuff
+    for key in env.keys():
+        if key not in oldenv:
+            del env[key]
+    env.update(oldenv)
+    if hasattr(sys, 'frozen'):
+        del sys.frozen
+    if os.name == 'nt':
+        (wreg.OpenKey, wreg.QueryValueEx,) = platformstuff
+
+# Build decorator that uses the setup_environment/setup_environment
+with_enivronment = with_setup(setup_environment, teardown_environment)
+
+
+#
+# Tests for get_home_dir
+#
+
+@skip_if_not_win32
+@with_enivronment
+def test_get_home_dir_1():
+    """Testcase for py2exe logic, un-compressed lib
+    """
+    sys.frozen = True
+    
+    #fake filename for IPython.__init__
+    IPython.__file__ = abspath(join(HOME_TEST_DIR, "Lib/IPython/__init__.py"))
+    
+    home_dir = genutils.get_home_dir()
+    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
+    
+@skip_if_not_win32
+@with_enivronment
+def test_get_home_dir_2():
+    """Testcase for py2exe logic, compressed lib
+    """
+    sys.frozen = True
+    #fake filename for IPython.__init__
+    IPython.__file__ = abspath(join(HOME_TEST_DIR, "Library.zip/IPython/__init__.py")).lower()
+    
+    home_dir = genutils.get_home_dir()
+    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR).lower())
+
+@with_enivronment
+def test_get_home_dir_3():
+    """Testcase $HOME is set, then use its value as home directory."""
+    env["HOME"] = HOME_TEST_DIR
+    home_dir = genutils.get_home_dir()
+    nt.assert_equal(home_dir, env["HOME"])
+
+@with_enivronment
+def test_get_home_dir_4():
+    """Testcase $HOME is not set, os=='poix'. 
+    This should fail with HomeDirError"""
+    
+    os.name = 'posix'
+    if 'HOME' in env: del env['HOME']
+    nt.assert_raises(genutils.HomeDirError, genutils.get_home_dir)
+        
+@skip_if_not_win32
+@with_enivronment
+def test_get_home_dir_5():
+    """Testcase $HOME is not set, os=='nt' 
+    env['HOMEDRIVE'],env['HOMEPATH'] points to path."""
+
+    os.name = 'nt'
+    if 'HOME' in env: del env['HOME']
+    env['HOMEDRIVE'], env['HOMEPATH'] = os.path.splitdrive(HOME_TEST_DIR)
 
+    home_dir = genutils.get_home_dir()
+    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
+
+@skip_if_not_win32
+@with_enivronment
+def test_get_home_dir_6():
+    """Testcase $HOME is not set, os=='nt' 
+    env['HOMEDRIVE'],env['HOMEPATH'] do not point to path.
+    env['USERPROFILE'] points to path
+    """
+
+    os.name = 'nt'
+    if 'HOME' in env: del env['HOME']
+    env['HOMEDRIVE'], env['HOMEPATH'] = os.path.abspath(TEST_FILE_PATH), "DOES NOT EXIST"
+    env["USERPROFILE"] = abspath(HOME_TEST_DIR)
+
+    home_dir = genutils.get_home_dir()
+    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
+
+# Should we stub wreg fully so we can run the test on all platforms?
+@skip_if_not_win32
+@with_enivronment
+def test_get_home_dir_7():
+    """Testcase $HOME is not set, os=='nt' 
+    env['HOMEDRIVE'],env['HOMEPATH'], env['USERPROFILE'] missing
+    """
+    os.name = 'nt'
+    if 'HOME' in env: del env['HOME']
+    if 'HOMEDRIVE' in env: del env['HOMEDRIVE']
+
+    #Stub windows registry functions
+    def OpenKey(x, y):
+        class key:
+            def Close(self):
+                pass
+        return key()
+    def QueryValueEx(x, y):
+        return [abspath(HOME_TEST_DIR)]
+
+    wreg.OpenKey = OpenKey
+    wreg.QueryValueEx = QueryValueEx
 
-def test_get_home_dir():
-    """Make sure we can get the home directory."""
     home_dir = genutils.get_home_dir()
+    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
+
+
+#
+# Tests for get_ipython_dir
+#
+
+@with_enivronment
+def test_get_ipython_dir_1():
+    """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions."""
+    env['IPYTHONDIR'] = "someplace/.ipython"
+    ipdir = genutils.get_ipython_dir()
+    nt.assert_equal(ipdir, os.path.abspath("someplace/.ipython"))
 
-def test_get_ipython_dir():
-    """Make sure we can get the ipython directory."""
+
+@with_enivronment
+def test_get_ipython_dir_2():
+    """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions."""
+    genutils.get_home_dir = lambda : "someplace"
+    os.name = "posix"
+    ipdir = genutils.get_ipython_dir()
+    nt.assert_equal(ipdir, os.path.abspath(os.path.join("someplace", ".ipython")))
+
+@with_enivronment
+def test_get_ipython_dir_3():
+    """test_get_ipython_dir_3, Testcase to see if we can call get_ipython_dir without Exceptions."""
+    genutils.get_home_dir = lambda : "someplace"
+    os.name = "nt"
     ipdir = genutils.get_ipython_dir()
+    nt.assert_equal(ipdir, os.path.abspath(os.path.join("someplace", "_ipython")))
+
+
+#
+# Tests for get_security_dir
+#
 
+@with_enivronment
 def test_get_security_dir():
-    """Make sure we can get the ipython/security directory."""
+    """Testcase to see if we can call get_security_dir without Exceptions."""
     sdir = genutils.get_security_dir()
-    
  No newline at end of file
+
+
+#
+# Tests for popkey
+#
+
+def test_popkey_1():
+    """test_popkey_1, Basic usage test of popkey
+    """
+    dct = dict(a=1, b=2, c=3)
+    nt.assert_equal(genutils.popkey(dct, "a"), 1)
+    nt.assert_equal(dct, dict(b=2, c=3))
+    nt.assert_equal(genutils.popkey(dct, "b"), 2)
+    nt.assert_equal(dct, dict(c=3))
+    nt.assert_equal(genutils.popkey(dct, "c"), 3)
+    nt.assert_equal(dct, dict())
+
+def test_popkey_2():
+    """test_popkey_2, Test to see that popkey of non occuring keys
+    generates a KeyError exception
+    """
+    dct = dict(a=1, b=2, c=3)
+    nt.assert_raises(KeyError, genutils.popkey, dct, "d")
+
+def test_popkey_3():
+    """test_popkey_3, Tests to see that popkey calls returns the correct value
+    and that the key/value was removed from the dict.
+    """
+    dct = dict(a=1, b=2, c=3)
+    nt.assert_equal(genutils.popkey(dct, "A", 13), 13)
+    nt.assert_equal(dct, dict(a=1, b=2, c=3))
+    nt.assert_equal(genutils.popkey(dct, "B", 14), 14)
+    nt.assert_equal(dct, dict(a=1, b=2, c=3))
+    nt.assert_equal(genutils.popkey(dct, "C", 15), 15)
+    nt.assert_equal(dct, dict(a=1, b=2, c=3))
+    nt.assert_equal(genutils.popkey(dct, "a"), 1)
+    nt.assert_equal(dct, dict(b=2, c=3))
+    nt.assert_equal(genutils.popkey(dct, "b"), 2)
+    nt.assert_equal(dct, dict(c=3))
+    nt.assert_equal(genutils.popkey(dct, "c"), 3)
+    nt.assert_equal(dct, dict())

IPython/tests/test_magic.py

@@ -1,8 +1,21 b''
-""" Tests for various magic functions
-
-Needs to be run by nose (to make ipython session available)
+"""Tests for various magic functions.
 
+Needs to be run by nose (to make ipython session available).
 """
+
+# Standard library imports
+import os
+import sys
+
+# Third-party imports
+import nose.tools as nt
+
+# From our own code
+from IPython.testing import decorators as dec
+
+#-----------------------------------------------------------------------------
+# Test functions begin
+
 def test_rehashx():
     # clear up everything
     _ip.IP.alias_table.clear()
@@ -19,3 +32,104 b' def test_rehashx():'
     # rehashx must fill up syscmdlist
     scoms = _ip.db['syscmdlist']
     assert len(scoms) > 10
+
+
+def doctest_run_ns():
+    """Classes declared %run scripts must be instantiable afterwards.
+
+    In [11]: run tclass
+
+    In [12]: isinstance(f(),foo)
+    Out[12]: True
+    """
+
+    
+def doctest_run_ns2():
+    """Classes declared %run scripts must be instantiable afterwards.
+
+    In [3]: run tclass.py
+
+    In [4]: run tclass first_pass
+
+    In [5]: run tclass second_pass
+    Deleting object: first_pass
+    """
+
+
+def doctest_hist_f():
+    """Test %hist -f with temporary filename.
+
+    In [9]: import tempfile
+
+    In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-')
+
+    In [11]: %history -n -f $tfile 3
+    """
+
+
+def doctest_hist_r():
+    """Test %hist -r
+
+    XXX - This test is not recording the output correctly.  Not sure why...
+
+    In [6]: x=1
+
+    In [7]: hist -n -r 2
+    x=1  # random
+    hist -n -r 2  # random
+    """
+
+
+def test_obj_del():
+    """Test that object's __del__ methods are called on exit."""
+    test_dir = os.path.dirname(__file__)
+    del_file = os.path.join(test_dir,'obj_del.py')
+    out = _ip.IP.getoutput('ipython %s' % del_file)
+    nt.assert_equals(out,'object A deleted')
+
+
+def test_shist():
+    # Simple tests of ShadowHist class - test generator.
+    import os, shutil, tempfile
+
+    from IPython.Extensions import pickleshare
+    from IPython.history import ShadowHist
+    
+    tfile = tempfile.mktemp('','tmp-ipython-')
+    
+    db = pickleshare.PickleShareDB(tfile)
+    s = ShadowHist(db)
+    s.add('hello')
+    s.add('world')
+    s.add('hello')
+    s.add('hello')
+    s.add('karhu')
+
+    yield nt.assert_equals,s.all(),[(1, 'hello'), (2, 'world'), (3, 'karhu')]
+    
+    yield nt.assert_equal,s.get(2),'world'
+    
+    shutil.rmtree(tfile)
+    
[e-mail]_not_numpy
+def test_numpy_clear_array_undec():
+    _ip.ex('import numpy as np')
+    _ip.ex('a = np.empty(2)')
+    
+    yield nt.assert_true,'a' in _ip.user_ns
+    _ip.magic('clear array')
+    yield nt.assert_false,'a' in _ip.user_ns
+    
+
[e-mail]()
+def test_fail_dec(*a,**k):
+    yield nt.assert_true, False
+
[e-mail]('This one shouldn not run')
+def test_fail_dec2(*a,**k):
+    yield nt.assert_true, False
+
[e-mail]
+def test_fail_dec3(*a,**k):
+    yield nt.assert_true, False
+

IPython/twshell.py

@@ -1,3 +1,7 b''
+"""Twisted shell support.
+
+XXX - This module is missing proper docs.
+"""
 import sys
 
 from twisted.internet import reactor, threads

IPython/ultraTB.py

@@ -59,8 +59,7 b' ColorSchemeTable class. Currently the following exist:'
 You can implement other color schemes easily, the syntax is fairly
 self-explanatory. Please send back new schemes you develop to the author for
 possible inclusion in future releases.
-
-$Id: ultraTB.py 2908 2007-12-30 21:07:46Z vivainio $"""
+"""
 
 #*****************************************************************************
 #       Copyright (C) 2001 Nathaniel Gray <[e-mail]>
@@ -70,11 +69,6 b' $Id: ultraTB.py 2908 2007-12-30 21:07:46Z vivainio $"""'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = '%s <%s>\n%s <%s>' % (Release.authors['Nathan']+
-                                    Release.authors['Fernando'])
-__license__ = Release.license
-
 # Required modules
 import inspect
 import keyword
@@ -98,7 +92,7 b' from inspect import getsourcefile, getfile, getmodule,\\'
 # Modified pdb which doesn't damage IPython's readline handling
 from IPython import Debugger, PyColorize
 from IPython.ipstruct import Struct
-from IPython.excolors import ExceptionColors
+from IPython.excolors import exception_colors
 from IPython.genutils import Term,uniq_stable,error,info
 
 # Globals
@@ -320,7 +314,7 b' class TBTools:'
         self.call_pdb = call_pdb
 
         # Create color table
-        self.color_scheme_table = ExceptionColors 
+        self.color_scheme_table = exception_colors()
 
         self.set_colors(color_scheme)
         self.old_scheme = color_scheme  # save initial value for toggles

IPython/usage.py

@@ -6,13 +6,6 b''
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-# $Id: usage.py 2723 2007-09-07 07:44:16Z fperez $
-
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-__version__ = Release.version
-
 __doc__ = """
 IPython -- An enhanced Interactive Python
 =========================================
@@ -650,5 +643,3 b' or python names.'
 The following magic functions are currently available:
 
 """
-
-

IPython/wildcard.py

@@ -1,7 +1,9 b''
 # -*- coding: utf-8 -*-
 """Support for wildcard pattern matching in object inspection.
 
-$Id: OInspect.py 608 2005-07-06 17:52:32Z fperez $
+Authors
+-------
+- Jörgen Stenarson <[e-mail]>
 """
 
 #*****************************************************************************
@@ -11,10 +13,6 b' $Id: OInspect.py 608 2005-07-06 17:52:32Z fperez $'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-from IPython import Release
-__author__  = "Jörgen Stenarson <[e-mail]>"
-__license__ = Release.license
-
 import __builtin__
 import exceptions
 import pdb

docs/Makefile

@@ -5,13 +5,14 b''
 SPHINXOPTS    =
 SPHINXBUILD   = sphinx-build
 PAPER         =
+SRCDIR        = source
 
 # Internal variables.
 PAPEROPT_a4     = -D latex_paper_size=a4
 PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS   = -d build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
+ALLSPHINXOPTS   = -d build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) $(SRCDIR)
 
-.PHONY: help clean html web pickle htmlhelp latex changes linkcheck
+.PHONY: help clean html web pickle htmlhelp latex changes linkcheck api
 
 help:
 	@echo "Please use \`make <target>' where <target> is one of"
@@ -28,7 +29,7 b' help:'
 	@echo "dist         all, and then puts the results in dist/"
 
 clean:
-	-rm -rf build/* dist/*
+	-rm -rf build/* dist/* $(SRCDIR)/api/generated
 
 pdf: latex
 	cd build/latex && make all-pdf
@@ -41,12 +42,16 b' dist: clean all'
 	cp -al build/html dist/
 	@echo "Build finished.  Final docs are in dist/"
 
-html:
+html: api
 	mkdir -p build/html build/doctrees
 	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) build/html
 	@echo
 	@echo "Build finished. The HTML pages are in build/html."
 
+api:
+	python autogen_api.py
+	@echo "Build API docs finished."
+
 pickle:
 	mkdir -p build/pickle build/doctrees
 	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) build/pickle

docs/source/conf.py

@@ -36,9 +36,13 b" execfile('../../IPython/Release.py',iprelease)"
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = ['sphinx.ext.autodoc',
-              'inheritance_diagram', 'only_directives',
+              'sphinx.ext.doctest',
+              
+              'only_directives',
+              'inheritance_diagram',
               'ipython_console_highlighting', 
               # 'plot_directive', # disabled for now, needs matplotlib
+              'numpydoc',  # to preprocess docstrings
               ]
 
 # Add any paths that contain templates here, relative to this directory.

docs/source/development/index.txt

@@ -1,11 +1,14 b''
-==================
-Development
-==================
+===========================
+ IPython Developer's Guide
+===========================
 
 .. toctree::
    :maxdepth: 2
 
-   development.txt
+   overview.txt
+   coding_guide.txt
+   doc_guide.txt
    roadmap.txt
+
    notification_blueprint.txt
    config_blueprint.txt

docs/source/development/overview.txt

@@ -17,7 +17,29 b' How to contribute to IPython'
 
 IPython development is done using Bazaar [Bazaar]_ and Launchpad [Launchpad]_.
 This makes it easy for people to contribute to the development of IPython.
-Here is a sketch of how to get going.
+There are several ways in which you can join in.
+
+If you have a small change that you want to send to the team, you can edit your
+bazaar checkout of IPython (see below) in-place, and ask bazaar for the
+differences::
+
+    $ cd /path/to/your/copy/of/ipython
+    $ bzr diff > my_fixes.diff
+
+This produces a patch file with your fixes, which we can apply to the source
+tree.  This file should then be attached to a ticket in our `bug tracker
+<https://bugs.launchpad.net/ipython>`_, indicating what it does.
+
+This model of creating small, self-contained patches works very well and there
+are open source projects that do their entire development this way.  However,
+in IPython we have found that for tracking larger changes, making use of
+bazaar's full capabilities in conjunction with Launchpad's code hosting
+services makes for a much better experience.
+
+Making your own branch of IPython allows you to refine your changes over time,
+track the development of the main team, and propose your own full version of
+the code for others to use and review, with a minimum amount of fuss.  The next
+parts of this document will explain how to do this.
 
 Install Bazaar and create a Launchpad account
 ---------------------------------------------
@@ -102,12 +124,16 b' commands::'
     $ bzr merge ../ipython
     $ bzr commit -m "Merging changes from trunk"
 
-Along the way, you should also run the IPython test suite.  You can do this using the :command:`iptest` command::
+Along the way, you should also run the IPython test suite.  You can do this
+using the :command:`iptest` command (which is basically a customized version of
+:command:`nosetests`)::
 
     $ cd
     $ iptest
 
-The :command:`iptest` command will also pick up and run any tests you have written.
+The :command:`iptest` command will also pick up and run any tests you have
+written.  See :ref:`_devel_testing` for further details on the testing system.
+
 
 Post your branch and request a code review
 ------------------------------------------
@@ -151,7 +177,8 b' source tree. The documentation in this location will serve as the main source'
 for IPython documentation and all existing documentation should be converted
 to this format.
 
-To build the final documentation, we use Sphinx [Sphinx]_.  Once you have Sphinx installed, you can build the html docs yourself by doing::
+To build the final documentation, we use Sphinx [Sphinx]_.  Once you have
+Sphinx installed, you can build the html docs yourself by doing::
 
     $ cd ipython-mybranch/docs
     $ make html
@@ -198,7 +225,8 b' Naming conventions'
 In terms of naming conventions, we'll follow the guidelines from the `Style
 Guide for Python Code`_.
 
-For all new IPython code (and much existing code is being refactored), we'll use:
+For all new IPython code (and much existing code is being refactored), we'll
+use:
 
 * All ``lowercase`` module names.
 
@@ -270,17 +298,119 b' twisted reactor will be handled correctly.'
 
 Each subpackage in IPython should have its own :file:`tests` directory that
 contains all of the tests for that subpackage. This allows each subpackage to
-be self-contained. If a subpackage has any dependencies beyond the Python
-standard library, the tests for that subpackage should be skipped if the
-dependencies are not found. This is very important so users don't get tests
-failing simply because they don't have dependencies.
-
-To run the IPython test suite, use the :command:`iptest` command that is installed with IPython::
+be self-contained.  A good convention to follow is to have a file named
+:file:`test_foo.py` for each module :file:`foo.py` in the package.  This makes
+it easy to organize the tests, though like most conventions, it's OK to break
+it if logic and common sense dictate otherwise.
+
+If a subpackage has any dependencies beyond the Python standard library, the
+tests for that subpackage should be skipped if the dependencies are not
+found. This is very important so users don't get tests failing simply because
+they don't have dependencies.  We ship a set of decorators in the
+:mod:`IPython.testing` package to tag tests that may be platform-specific or
+otherwise may have restrictions; if the existing ones don't fit your needs, add
+a new decorator in that location so other tests can reuse it.
+
+To run the IPython test suite, use the :command:`iptest` command that is
+installed with IPython (if you are using IPython in-place, without installing
+it, you can find this script in the :file:`scripts` directory)::
 
     $ iptest
 
-This command runs Nose with the proper options and extensions.
-
+This command runs Nose with the proper options and extensions.  By default,
+:command:`iptest` runs the entire IPython test suite (skipping tests that may
+be platform-specific or which depend on tools you may not have).  But you can
+also use it to run only one specific test file, or a specific test function.
+For example, this will run only the :file:`test_magic` file from the test
+suite::
+
+    $ iptest IPython.tests.test_magic
+    ----------------------------------------------------------------------
+    Ran 10 tests in 0.348s
+
+    OK (SKIP=3)
+    Deleting object: second_pass
+
+while the ``path:function`` syntax allows you to select a specific function in
+that file to run::
+
+    $ iptest IPython.tests.test_magic:test_obj_del
+    ----------------------------------------------------------------------
+    Ran 1 test in 0.204s
+
+    OK
+
+Since :command:`iptest` is based on nosetests, you can pass it any regular
+nosetests option.  For example, you can use ``--pdb`` or ``--pdb-failures`` to
+automatically activate the interactive Pdb debugger on errors or failures.  See
+the nosetests documentation for further details.
+
+A few tips for writing tests
+----------------------------
+
+You can write tests either as normal test files, using all the conventions that
+Nose recognizes, or as doctests.  Note that *all* IPython functions should have
+at least one example that serves as a doctest, whenever technically feasible.
+However, example doctests should only be in the main docstring if they are *a
+good example*, i.e. if they convey useful information about the function.  If
+you simply would like to write a test as a doctest, put it in a separate test
+file and write a no-op function whose only purpose is its docstring.
+
+Note, however, that in a file named :file:`test_X`, functions whose only test
+is their docstring (as a doctest) and which have no test functionality of their
+own, should be called *doctest_foo* instead of *test_foo*, otherwise they get
+double-counted (the empty function call is counted as a test, which just
+inflates tests numbers artificially).  This restriction does not apply to
+functions in files with other names, due to how Nose discovers tests.
+
+You can use IPython examples in your docstrings.  Those can make full use of
+IPython functionality (magics, variable substitution, etc), but be careful to
+keep them generic enough that they run identically on all Operating Systems.
+
+The prompts in your doctests can be either of the plain Python ``>>>`` variety
+or ``In [1]:`` IPython style.  Since this is the IPython system, after all, we
+encourage you to use IPython prompts throughout, unless you are illustrating a
+specific aspect of the normal prompts (such as the ``%doctest_mode`` magic).
+
+If a test isn't safe to run inside the main nose process (e.g. because it loads
+a GUI toolkit), consider running it in a subprocess and capturing its output
+for evaluation and test decision later.  Here is an example of how to do it, by
+relying on the builtin ``_ip`` object that contains the public IPython api as
+defined in :mod:`IPython.ipapi`::
+
+   def test_obj_del():
+       """Test that object's __del__ methods are called on exit."""
+       test_dir = os.path.dirname(__file__)
+       del_file = os.path.join(test_dir,'obj_del.py')
+       out = _ip.IP.getoutput('ipython %s' % del_file)
+       nt.assert_equals(out,'object A deleted')
+
+
+
+If a doctest contains input whose output you don't want to verify identically
+via doctest (random output, an object id, etc), you can mark a docstring with
+``#random``.  All of these test will have their code executed but no output
+checking will be done::
+
+       >>> 1+3
+       junk goes here...  # random
+
+       >>> 1+2
+       again,  anything goes #random
+       if multiline, the random mark is only needed once.
+
+       >>> 1+2
+       You can also put the random marker at the end:
+       # random
+
+       >>> 1+2
+       # random
+       .. or at the beginning.
+
+In a case where you want an *entire* docstring to be executed but not verified
+(this only serves to check that the code runs without crashing, so it should be
+used very sparingly), you can put ``# all-random`` in the docstring.
+       
 .. _devel_config:
 
 Release checklist
@@ -303,6 +433,20 b' Most of the release process is automated by the :file:`release` script in the'
 
 #. Celebrate!
 
+Porting to 3.0
+==============
+
+There are no definite plans for porting of IPython to python 3. The major 
+issue is the dependency on twisted framework for the networking/threading 
+stuff. It is possible that it the traditional IPython interactive console 
+could be ported more easily since it has no such dependency. Here are a few
+things that will need to be considered when doing such a port especially
+if we want to have a codebase that works directly on both 2.x and 3.x.
+
+	1. The syntax for exceptions changed (PEP 3110). The old 
+	   `except exc, var` changed to `except exc as var`. At last
+	   count there was 78 occurences of this usage in the codebase
+	   
 .. [Bazaar] Bazaar. http://bazaar-vcs.org/
 .. [Launchpad] Launchpad. http://www.launchpad.net/ipython
 .. [reStructuredText] reStructuredText.  http://docutils.sourceforge.net/rst.html

docs/source/index.txt

@@ -17,10 +17,11 b' IPython Documentation'
    interactive/index.txt
    parallel/index.txt
    config/index.txt
-   changes.txt
-   development/index.txt
    faq.txt
    history.txt
+   changes.txt
+   development/index.txt
+   api/index.txt
    license_and_copyright.txt
    credits.txt
 

docs/source/install/index.txt

@@ -1,8 +1,8 b''
 .. _install_index:
 
-==================
+============
 Installation
-==================
+============
 
 .. toctree::
    :maxdepth: 2

docs/source/install/install.txt

@@ -1,29 +1,45 b''
 Overview
 ========
 
-This document describes the steps required to install IPython.  IPython is organized into a number of subpackages, each of which has its own dependencies.  All of the subpackages come with IPython, so you don't need to download and install them separately.  However, to use a given subpackage, you will need to install all of its dependencies.  
+This document describes the steps required to install IPython.  IPython is
+organized into a number of subpackages, each of which has its own dependencies.
+All of the subpackages come with IPython, so you don't need to download and
+install them separately.  However, to use a given subpackage, you will need to
+install all of its dependencies.
 
 
 Please let us know if you have problems installing IPython or any of its
-dependencies. IPython requires Python version 2.4 or greater.  We have not tested
-IPython with the upcoming 2.6 or 3.0 versions.
+dependencies. IPython requires Python version 2.4 or greater.  Light testing
+has been done on version 2.6, and so far everything looks fine.  We have *not*
+yet started to port IPython to Python 3.0, where the language changes are much
+more significant.
 
 .. warning::
 
-	IPython will not work with Python 2.3 or below.
+	IPython will not work with Python 2.4 or below.
 
-Some of the installation approaches use the :mod:`setuptools` package and its :command:`easy_install` command line program.  In many scenarios, this provides the most simple method of installing IPython and its dependencies.  It is not required though.  More information about :mod:`setuptools` can be found on its website.
+Some of the installation approaches use the :mod:`setuptools` package and its
+:command:`easy_install` command line program.  In many scenarios, this provides
+the most simple method of installing IPython and its dependencies.  It is not
+required though.  More information about :mod:`setuptools` can be found on its
+website.
 
-More general information about installing Python packages can be found in Python's documentation at http://www.python.org/doc/.
+More general information about installing Python packages can be found in
+Python's documentation at http://www.python.org/doc/.
 
 Quickstart
 ==========
 
-If you have :mod:`setuptools` installed and you are on OS X or Linux (not Windows), the following will download and install IPython *and* the main optional dependencies::
+If you have :mod:`setuptools` installed and you are on OS X or Linux (not
+Windows), the following will download and install IPython *and* the main
+optional dependencies::
 
     $ easy_install ipython[kernel,security,test]
 
-This will get Twisted, zope.interface and Foolscap, which are needed for IPython's parallel computing features as well as the nose package, which will enable you to run IPython's test suite.  To run IPython's test suite, use the :command:`iptest` command::
+This will get Twisted, zope.interface and Foolscap, which are needed for
+IPython's parallel computing features as well as the nose package, which will
+enable you to run IPython's test suite.  To run IPython's test suite, use the
+:command:`iptest` command::
 
     $ iptest
 
@@ -32,12 +48,19 b' Read on for more specific details and instructions for Windows.'
 Installing IPython itself
 =========================
 
-Given a properly built Python, the basic interactive IPython shell will work with no external dependencies.  However, some Python distributions (particularly on Windows and OS X), don't come with a working :mod:`readline` module.  The IPython shell will work without :mod:`readline`, but will lack many features that users depend on, such as tab completion and command line editing.  See below for details of how to make sure you have a working :mod:`readline`.
+Given a properly built Python, the basic interactive IPython shell will work
+with no external dependencies.  However, some Python distributions
+(particularly on Windows and OS X), don't come with a working :mod:`readline`
+module.  The IPython shell will work without :mod:`readline`, but will lack
+many features that users depend on, such as tab completion and command line
+editing.  See below for details of how to make sure you have a working
+:mod:`readline`.
 
 Installation using easy_install
 -------------------------------
 
-If you have :mod:`setuptools` installed, the easiest way of getting IPython is to simple use :command:`easy_install`::
+If you have :mod:`setuptools` installed, the easiest way of getting IPython is
+to simple use :command:`easy_install`::
 
 	$ easy_install ipython
 
@@ -46,68 +69,91 b" That's it."
 Installation from source
 ------------------------
 
-If you don't want to use :command:`easy_install`, or don't have it installed, just grab the latest stable build of IPython from `here <http://ipython.scipy.org/dist/>`_.  Then do the following::
+If you don't want to use :command:`easy_install`, or don't have it installed,
+just grab the latest stable build of IPython from `here
+<http://ipython.scipy.org/dist/>`_.  Then do the following::
 
 	$ tar -xzf ipython.tar.gz
 	$ cd ipython
 	$ python setup.py install
 
-If you are installing to a location (like ``/usr/local``) that requires higher permissions, you may need to run the last command with :command:`sudo`.
+If you are installing to a location (like ``/usr/local``) that requires higher
+permissions, you may need to run the last command with :command:`sudo`.
 
 Windows
 -------
 
-There are a few caveats for Windows users.  The main issue is that a basic ``python setup.py install`` approach won't create ``.bat`` file or Start Menu shortcuts, which most users want.  To get an installation with these, there are two choices:
+There are a few caveats for Windows users.  The main issue is that a basic
+``python setup.py install`` approach won't create ``.bat`` file or Start Menu
+shortcuts, which most users want.  To get an installation with these, there are
+two choices:
 
-1.  Install using :command:`easy_install`.
+1. Install using :command:`easy_install`.
 
-2.  Install using our binary ``.exe`` Windows installer, which can be found at `here <http://ipython.scipy.org/dist/>`_
+2. Install using our binary ``.exe`` Windows installer, which can be found at
+   `here <http://ipython.scipy.org/dist/>`_
 
-3.  Install from source, but using :mod:`setuptools` (``python setupegg.py install``).
+3. Install from source, but using :mod:`setuptools` (``python setupegg.py
+   install``).
 
 Installing the development version
 ----------------------------------
 
-It is also possible to install the development version of IPython from our `Bazaar <http://bazaar-vcs.org/>`_ source code
-repository.  To do this you will need to have Bazaar installed on your system.  Then just do::
+It is also possible to install the development version of IPython from our
+`Bazaar <http://bazaar-vcs.org/>`_ source code repository.  To do this you will
+need to have Bazaar installed on your system.  Then just do::
 
 	$ bzr branch lp:ipython
 	$ cd ipython
 	$ python setup.py install
 
-Again, this last step on Windows won't create ``.bat`` files or Start Menu shortcuts, so you will have to use one of the other approaches listed above.
+Again, this last step on Windows won't create ``.bat`` files or Start Menu
+shortcuts, so you will have to use one of the other approaches listed above.
 
-Some users want to be able to follow the development branch as it changes.  If you have :mod:`setuptools` installed, this is easy. Simply replace the last step by::
+Some users want to be able to follow the development branch as it changes.  If
+you have :mod:`setuptools` installed, this is easy. Simply replace the last
+step by::
 
 	$ python setupegg.py develop
 
-This creates links in the right places and installs the command line script to the appropriate places.  Then, if you want to update your IPython at any time, just do::
+This creates links in the right places and installs the command line script to
+the appropriate places.  Then, if you want to update your IPython at any time,
+just do::
 
 	$ bzr pull
 
 Basic optional dependencies
 ===========================
 
-There are a number of basic optional dependencies that most users will want to get.  These are:
+There are a number of basic optional dependencies that most users will want to
+get.  These are:
 
 * readline (for command line editing, tab completion, etc.)
 * nose (to run the IPython test suite)
 * pexpect (to use things like irunner)
 
-If you are comfortable installing these things yourself, have at it, otherwise read on for more details.
+If you are comfortable installing these things yourself, have at it, otherwise
+read on for more details.
 
 readline
 --------
 
-In principle, all Python distributions should come with a working :mod:`readline` module.  But, reality is not quite that simple.  There are two common situations where you won't have a working :mod:`readline` module:
+In principle, all Python distributions should come with a working
+:mod:`readline` module.  But, reality is not quite that simple.  There are two
+common situations where you won't have a working :mod:`readline` module:
 
 * If you are using the built-in Python on Mac OS X.
 
 * If you are running Windows, which doesn't have a :mod:`readline` module.
 
-On OS X, the built-in Python doesn't not have :mod:`readline` because of license issues.  Starting with OS X 10.5 (Leopard), Apple's built-in Python has a BSD-licensed not-quite-compatible readline replacement. As of IPython 0.9, many of the issues related to the differences between readline and libedit have been resolved.  For many users, libedit may be sufficient.
+On OS X, the built-in Python doesn't not have :mod:`readline` because of
+license issues.  Starting with OS X 10.5 (Leopard), Apple's built-in Python has
+a BSD-licensed not-quite-compatible readline replacement. As of IPython 0.9,
+many of the issues related to the differences between readline and libedit have
+been resolved.  For many users, libedit may be sufficient.
 
-Most users on OS X will want to get the full :mod:`readline` module.  To get a working :mod:`readline` module, just do (with :mod:`setuptools` installed)::
+Most users on OS X will want to get the full :mod:`readline` module.  To get a
+working :mod:`readline` module, just do (with :mod:`setuptools` installed)::
 
 	$ easy_install readline
 
@@ -117,20 +163,22 b' Most users on OS X will want to get the full :mod:`readline` module. To get a w'
     official python.org binaries) already have readline installed so 
     you don't have to do this step.
 
-If needed, the readline egg can be build and installed from source (see the wiki page at http://ipython.scipy.org/moin/InstallationOSXLeopard).
+If needed, the readline egg can be build and installed from source (see the
+wiki page at http://ipython.scipy.org/moin/InstallationOSXLeopard).
 
 On Windows, you will need the PyReadline module. PyReadline is a separate,
 Windows only implementation of readline that uses native Windows calls through
 :mod:`ctypes`. The easiest way of installing PyReadline is you use the binary
-installer available `here <http://ipython.scipy.org/dist/>`_. The
-:mod:`ctypes` module, which comes with Python 2.5 and greater, is required by
-PyReadline. It is available for Python 2.4 at
-http://python.net/crew/theller/ctypes.
+installer available `here <http://ipython.scipy.org/dist/>`_. The :mod:`ctypes`
+module, which comes with Python 2.5 and greater, is required by PyReadline. It
+is available for Python 2.4 at http://python.net/crew/theller/ctypes.
 
 nose
 ----
 
-To run the IPython test suite you will need the :mod:`nose` package.  Nose provides a great way of sniffing out and running all of the IPython tests.  The simplest way of getting nose, is to use :command:`easy_install`::
+To run the IPython test suite you will need the :mod:`nose` package.  Nose
+provides a great way of sniffing out and running all of the IPython tests.  The
+simplest way of getting nose, is to use :command:`easy_install`::
 
 	$ easy_install nose
 
@@ -138,7 +186,9 b' Another way of getting this is to do::'
 
     $ easy_install ipython[test]
 
-For more installation options, see the `nose website <http://somethingaboutorange.com/mrl/projects/nose/>`_.  Once you have nose installed, you can run IPython's test suite using the iptest command::
+For more installation options, see the `nose website
+<http://somethingaboutorange.com/mrl/projects/nose/>`_.  Once you have nose
+installed, you can run IPython's test suite using the iptest command::
 
 	$ iptest
 
@@ -146,7 +196,8 b' For more installation options, see the `nose website <http://somethingaboutorang'
 pexpect
 -------
 
-The `pexpect <http://www.noah.org/wiki/Pexpect>`_ package is used in IPython's :command:`irunner` script.  On Unix platforms (including OS X), just do::
+The `pexpect <http://www.noah.org/wiki/Pexpect>`_ package is used in IPython's
+:command:`irunner` script.  On Unix platforms (including OS X), just do::
 
 	$ easy_install pexpect
 
@@ -155,7 +206,9 b' Windows users are out of luck as pexpect does not run there.'
 Dependencies for IPython.kernel (parallel computing)
 ====================================================
 
-The IPython kernel provides a nice architecture for parallel computing.  The main focus of this architecture is on interactive parallel computing.  These features require a number of additional packages:
+The IPython kernel provides a nice architecture for parallel computing.  The
+main focus of this architecture is on interactive parallel computing.  These
+features require a number of additional packages:
 
 * zope.interface (yep, we use interfaces)
 * Twisted (asynchronous networking framework)
@@ -170,14 +223,17 b' On a Unix style platform (including OS X), if you want to use :mod:`setuptools`,'
 zope.interface and Twisted
 --------------------------
 
-Twisted [Twisted]_ and zope.interface [ZopeInterface]_ are used for networking related things. On Unix
-style platforms (including OS X), the simplest way of getting the these is to
-use :command:`easy_install`::
+Twisted [Twisted]_ and zope.interface [ZopeInterface]_ are used for networking
+related things. On Unix style platforms (including OS X), the simplest way of
+getting the these is to use :command:`easy_install`::
 
 	$ easy_install zope.interface
 	$ easy_install Twisted
 
-Of course, you can also download the source tarballs from the `Twisted website <twistedmatrix.org>`_ and the `zope.interface page at PyPI <http://pypi.python.org/pypi/zope.interface>`_ and do the usual ``python setup.py install`` if you prefer.
+Of course, you can also download the source tarballs from the `Twisted website
+<twistedmatrix.org>`_ and the `zope.interface page at PyPI
+<http://pypi.python.org/pypi/zope.interface>`_ and do the usual ``python
+setup.py install`` if you prefer.
 
 Windows is a bit different.  For zope.interface and Twisted, simply get the latest binary ``.exe`` installer from the Twisted website.  This installer includes both zope.interface and Twisted and should just work.
 
@@ -190,12 +246,15 b' On all platforms a simple::'
 
     $ easy_install foolscap
 
-should work.  You can also download the source tarballs from the `Foolscap website <http://foolscap.lothar.com/trac>`_ and do ``python setup.py install`` if you prefer.
+should work.  You can also download the source tarballs from the `Foolscap
+website <http://foolscap.lothar.com/trac>`_ and do ``python setup.py install``
+if you prefer.
 
 pyOpenSSL
 ---------
 
-IPython requires an older version of pyOpenSSL [pyOpenSSL]_ (0.6 rather than the current 0.7).  There are a couple of options for getting this:
+IPython requires an older version of pyOpenSSL [pyOpenSSL]_ (0.6 rather than
+the current 0.7).  There are a couple of options for getting this:
 
 1.  Most Linux distributions have packages for pyOpenSSL.
 2.  The built-in Python 2.5 on OS X 10.5 already has it installed.
@@ -209,9 +268,14 b' Dependencies for IPython.frontend (the IPython GUI)'
 wxPython
 --------
 
-Starting with IPython 0.9, IPython has a new IPython.frontend package that has a nice wxPython based IPython GUI.  As you would expect, this GUI requires wxPython.  Most Linux distributions have wxPython packages available and the built-in Python on OS X comes with wxPython preinstalled.  For Windows, a binary installer is available on the `wxPython website <http://www.wxpython.org/>`_.
+Starting with IPython 0.9, IPython has a new IPython.frontend package that has
+a nice wxPython based IPython GUI.  As you would expect, this GUI requires
+wxPython.  Most Linux distributions have wxPython packages available and the
+built-in Python on OS X comes with wxPython preinstalled.  For Windows, a
+binary installer is available on the `wxPython website
+<http://www.wxpython.org/>`_.
 
 .. [Twisted] Twisted matrix.  http://twistedmatrix.org
 .. [ZopeInterface] http://pypi.python.org/pypi/zope.interface
 .. [Foolscap] Foolscap network protocol.  http://foolscap.lothar.com/trac
-.. [pyOpenSSL] pyOpenSSL.  http://pyopenssl.sourceforge.net
  No newline at end of file
+.. [pyOpenSSL] pyOpenSSL.  http://pyopenssl.sourceforge.net

docs/source/interactive/reference.txt

@@ -490,9 +490,9 b' following example defines a new magic command, %impall::'
     ip.expose_magic('impall', doimp)
 
 You can also define your own aliased names for magic functions. In your
-ipythonrc file, placing a line like:
+ipythonrc file, placing a line like::
 
-execute __IP.magic_cl = __IP.magic_clear
+    execute __IP.magic_cl = __IP.magic_clear
 
 will define %cl as a new name for %clear.
 
@@ -502,1572 +502,9 b' magic functions at any time and their docstrings. You can also type'
 information on the '?' system) to get information about any particular
 magic function you are interested in.
 
+The API documentation for the :mod:`IPython.Magic` module contains the full
+docstrings of all currently available magic commands.
 
-Magic commands
---------------
-
-The rest of this section is automatically generated for each release
-from the docstrings in the IPython code. Therefore the formatting is
-somewhat minimal, but this method has the advantage of having
-information always in sync with the code.
-
-A list of all the magic commands available in IPython's default
-installation follows. This is similar to what you'll see by simply
-typing %magic at the prompt, but that will also give you information
-about magic commands you may have added as part of your personal
-customizations.
-
-.. magic_start
-
-**%Exit**::
-
-	Exit IPython without confirmation.
-
-**%Pprint**::
-
-	Toggle pretty printing on/off.
-
-**%alias**::
-
-	Define an alias for a system command.
-
-        '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
-
-        Then, typing 'alias_name params' will execute the system command 'cmd
-        params' (from your underlying operating system).
-
-        Aliases have lower precedence than magic functions and Python normal
-        variables, so if 'foo' is both a Python variable and an alias, the
-        alias can not be executed until 'del foo' removes the Python variable.
-
-        You can use the %l specifier in an alias definition to represent the
-        whole line when the alias is called.  For example:
-
-          In [2]: alias all echo "Input in brackets: <%l>"\
-          In [3]: all hello world\
-          Input in brackets: <hello world>
-
-        You can also define aliases with parameters using %s specifiers (one
-        per parameter):
-        
-          In [1]: alias parts echo first %s second %s\
-          In [2]: %parts A B\
-          first A second B\
-          In [3]: %parts A\
-          Incorrect number of arguments: 2 expected.\
-          parts is an alias to: 'echo first %s second %s'
-
-        Note that %l and %s are mutually exclusive.  You can only use one or
-        the other in your aliases.
-
-        Aliases expand Python variables just like system calls using ! or !! 
-        do: all expressions prefixed with '$' get expanded.  For details of
-        the semantic rules, see PEP-215:
-        http://www.python.org/peps/pep-0215.html.  This is the library used by
-        IPython for variable expansion.  If you want to access a true shell
-        variable, an extra $ is necessary to prevent its expansion by IPython:
-
-        In [6]: alias show echo\
-        In [7]: PATH='A Python string'\
-        In [8]: show $PATH\
-        A Python string\
-        In [9]: show $$PATH\
-        /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
-
-        You can use the alias facility to acess all of $PATH.  See the %rehash
-        and %rehashx functions, which automatically create aliases for the
-        contents of your $PATH.
-
-        If called with no parameters, %alias prints the current alias table.
-
-**%autocall**::
-
-	Make functions callable without having to type parentheses.
-
-        Usage:
-
-           %autocall [mode]
-
-        The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the
-        value is toggled on and off (remembering the previous state).
-
-        In more detail, these values mean:
-
-        0 -> fully disabled
-
-        1 -> active, but do not apply if there are no arguments on the line.
-
-        In this mode, you get:
-
-        In [1]: callable
-        Out[1]: <built-in function callable>
-
-        In [2]: callable 'hello'
-        ------> callable('hello')
-        Out[2]: False
-
-        2 -> Active always.  Even if no arguments are present, the callable
-        object is called:
-
-        In [4]: callable
-        ------> callable()
-
-        Note that even with autocall off, you can still use '/' at the start of
-        a line to treat the first argument on the command line as a function
-        and add parentheses to it:
-
-        In [8]: /str 43
-        ------> str(43)
-        Out[8]: '43'
-
-**%autoindent**::
-
-	Toggle autoindent on/off (if available).
-
-**%automagic**::
-
-	Make magic functions callable without having to type the initial %.
-
-        Without argumentsl toggles on/off (when off, you must call it as
-        %automagic, of course).  With arguments it sets the value, and you can
-        use any of (case insensitive):
-
-         - on,1,True: to activate
-
-         - off,0,False: to deactivate.
-
-        Note that magic functions have lowest priority, so if there's a
-        variable whose name collides with that of a magic fn, automagic won't
-        work for that function (you get the variable instead). However, if you
-        delete the variable (del var), the previously shadowed magic function
-        becomes visible to automagic again.
-
-**%bg**::
-
-	Run a job in the background, in a separate thread.
-
-        For example,
-
-          %bg myfunc(x,y,z=1)
-
-        will execute 'myfunc(x,y,z=1)' in a background thread.  As soon as the
-        execution starts, a message will be printed indicating the job
-        number.  If your job number is 5, you can use
-
-          myvar = jobs.result(5)  or  myvar = jobs[5].result
-
-        to assign this result to variable 'myvar'.
-
-        IPython has a job manager, accessible via the 'jobs' object.  You can
-        type jobs? to get more information about it, and use jobs.<TAB> to see
-        its attributes.  All attributes not starting with an underscore are
-        meant for public use.
-
-        In particular, look at the jobs.new() method, which is used to create
-        new jobs.  This magic %bg function is just a convenience wrapper
-        around jobs.new(), for expression-based jobs.  If you want to create a
-        new job with an explicit function object and arguments, you must call
-        jobs.new() directly.
-
-        The jobs.new docstring also describes in detail several important
-        caveats associated with a thread-based model for background job
-        execution.  Type jobs.new? for details.
-
-        You can check the status of all jobs with jobs.status().
-
-        The jobs variable is set by IPython into the Python builtin namespace.
-        If you ever declare a variable named 'jobs', you will shadow this
-        name.  You can either delete your global jobs variable to regain
-        access to the job manager, or make a new name and assign it manually
-        to the manager (stored in IPython's namespace).  For example, to
-        assign the job manager to the Jobs name, use:
-
-          Jobs = __builtins__.jobs
-
-**%bookmark**::
-
-	Manage IPython's bookmark system.
-
-        %bookmark <name>       - set bookmark to current dir
-        %bookmark <name> <dir> - set bookmark to <dir>
-        %bookmark -l           - list all bookmarks
-        %bookmark -d <name>    - remove bookmark
-        %bookmark -r           - remove all bookmarks
-
-        You can later on access a bookmarked folder with:
-          %cd -b <name>
-        or simply '%cd <name>' if there is no directory called <name> AND
-        there is such a bookmark defined.
-
-        Your bookmarks persist through IPython sessions, but they are
-        associated with each profile.
-
-**%cd**::
-
-	Change the current working directory.
-
-        This command automatically maintains an internal list of directories
-        you visit during your IPython session, in the variable _dh. The
-        command %dhist shows this history nicely formatted. You can also
-        do 'cd -<tab>' to see directory history conveniently.
-
-        Usage:
-
-          cd 'dir': changes to directory 'dir'.
-
-          cd -: changes to the last visited directory.
-
-          cd -<n>: changes to the n-th directory in the directory history.
-
-          cd -b <bookmark_name>: jump to a bookmark set by %bookmark
-             (note: cd <bookmark_name> is enough if there is no
-              directory <bookmark_name>, but a bookmark with the name exists.)
-              'cd -b <tab>' allows you to tab-complete bookmark names. 
-
-        Options:
-
-        -q: quiet.  Do not print the working directory after the cd command is
-        executed.  By default IPython's cd command does print this directory,
-        since the default prompts do not display path information.
-        
-        Note that !cd doesn't work for this purpose because the shell where
-        !command runs is immediately discarded after executing 'command'.
-
-**%clear**::
-
-	 Clear various data (e.g. stored history data)
-    
-    %clear out - clear output history
-    %clear in  - clear input history
-    %clear shadow_compress - Compresses shadow history (to speed up ipython)
-    %clear shadow_nuke - permanently erase all entries in shadow history
-    %clear dhist - clear dir history
-
-**%color_info**::
-
-	Toggle color_info.
-
-        The color_info configuration parameter controls whether colors are
-        used for displaying object details (by things like %psource, %pfile or
-        the '?' system). This function toggles this value with each call.
-
-        Note that unless you have a fairly recent pager (less works better
-        than more) in your system, using colored object information displays
-        will not work properly. Test it and see.
-
-**%colors**::
-
-	Switch color scheme for prompts, info system and exception handlers.
-
-        Currently implemented schemes: NoColor, Linux, LightBG.
-
-        Color scheme names are not case-sensitive.
-
-**%cpaste**::
-
-	Allows you to paste & execute a pre-formatted code block from clipboard
-        
-        You must terminate the block with '--' (two minus-signs) alone on the
-        line. You can also provide your own sentinel with '%paste -s %%' ('%%' 
-        is the new sentinel for this operation)
-        
-        The block is dedented prior to execution to enable execution of method
-        definitions. '>' and '+' characters at the beginning of a line are
-        ignored, to allow pasting directly from e-mails or diff files. The
-        executed block is also assigned to variable named 'pasted_block' for
-        later editing with '%edit pasted_block'.
-        
-        You can also pass a variable name as an argument, e.g. '%cpaste foo'.
-        This assigns the pasted block to variable 'foo' as string, without 
-        dedenting or executing it.
-        
-        Do not be alarmed by garbled output on Windows (it's a readline bug). 
-        Just press enter and type -- (and press enter again) and the block 
-        will be what was just pasted.
-        
-        IPython statements (magics, shell escapes) are not supported (yet).
-
-**%debug**::
-
-	Activate the interactive debugger in post-mortem mode.
-
-        If an exception has just occurred, this lets you inspect its stack
-        frames interactively.  Note that this will always work only on the last
-        traceback that occurred, so you must call this quickly after an
-        exception that you wish to inspect has fired, because if another one
-        occurs, it clobbers the previous one.
-
-        If you want IPython to automatically do this on every exception, see
-        the %pdb magic for more details.
-
-**%dhist**::
-
-	Print your history of visited directories.
-
-        %dhist       -> print full history\
-        %dhist n     -> print last n entries only\
-        %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\
-
-        This history is automatically maintained by the %cd command, and
-        always available as the global list variable _dh. You can use %cd -<n>
-        to go to directory number <n>.
-        
-        Note that most of time, you should view directory history by entering
-        cd -<TAB>.
-
-**%dirs**::
-
-	Return the current directory stack.
-
-**%doctest_mode**::
-
-	Toggle doctest mode on and off.
-
-        This mode allows you to toggle the prompt behavior between normal
-        IPython prompts and ones that are as similar to the default IPython
-        interpreter as possible.
-
-        It also supports the pasting of code snippets that have leading '>>>'
-        and '...' prompts in them.  This means that you can paste doctests from
-        files or docstrings (even if they have leading whitespace), and the
-        code will execute correctly.  You can then use '%history -tn' to see
-        the translated history without line numbers; this will give you the
-        input after removal of all the leading prompts and whitespace, which
-        can be pasted back into an editor.
-
-        With these features, you can switch into this mode easily whenever you
-        need to do testing and changes to doctests, without having to leave
-        your existing IPython session.
-
-**%ed**::
-
-	Alias to %edit.
-
-**%edit**::
-
-	Bring up an editor and execute the resulting code.
-
-        Usage:
-          %edit [options] [args]
-
-        %edit runs IPython's editor hook.  The default version of this hook is
-        set to call the __IPYTHON__.rc.editor command.  This is read from your
-        environment variable $EDITOR.  If this isn't found, it will default to
-        vi under Linux/Unix and to notepad under Windows.  See the end of this
-        docstring for how to change the editor hook.
-
-        You can also set the value of this editor via the command line option
-        '-editor' or in your ipythonrc file. This is useful if you wish to use
-        specifically for IPython an editor different from your typical default
-        (and for Windows users who typically don't set environment variables).
-
-        This command allows you to conveniently edit multi-line code right in
-        your IPython session.
-        
-        If called without arguments, %edit opens up an empty editor with a
-        temporary file and will execute the contents of this file when you
-        close it (don't forget to save it!).
-
-
-        Options:
-
-        -n <number>: open the editor at a specified line number.  By default,
-        the IPython editor hook uses the unix syntax 'editor +N filename', but
-        you can configure this by providing your own modified hook if your
-        favorite editor supports line-number specifications with a different
-        syntax.
-        
-        -p: this will call the editor with the same data as the previous time
-        it was used, regardless of how long ago (in your current session) it
-        was.
-
-        -r: use 'raw' input.  This option only applies to input taken from the
-        user's history.  By default, the 'processed' history is used, so that
-        magics are loaded in their transformed version to valid Python.  If
-        this option is given, the raw input as typed as the command line is
-        used instead.  When you exit the editor, it will be executed by
-        IPython's own processor.
-        
-        -x: do not execute the edited code immediately upon exit. This is
-        mainly useful if you are editing programs which need to be called with
-        command line arguments, which you can then do using %run.
-
-
-        Arguments:
-
-        If arguments are given, the following possibilites exist:
-
-        - The arguments are numbers or pairs of colon-separated numbers (like
-        1 4:8 9). These are interpreted as lines of previous input to be
-        loaded into the editor. The syntax is the same of the %macro command.
-
-        - If the argument doesn't start with a number, it is evaluated as a
-        variable and its contents loaded into the editor. You can thus edit
-        any string which contains python code (including the result of
-        previous edits).
-
-        - If the argument is the name of an object (other than a string),
-        IPython will try to locate the file where it was defined and open the
-        editor at the point where it is defined. You can use `%edit function`
-        to load an editor exactly at the point where 'function' is defined,
-        edit it and have the file be executed automatically.
-
-        If the object is a macro (see %macro for details), this opens up your
-        specified editor with a temporary file containing the macro's data.
-        Upon exit, the macro is reloaded with the contents of the file.
-
-        Note: opening at an exact line is only supported under Unix, and some
-        editors (like kedit and gedit up to Gnome 2.8) do not understand the
-        '+NUMBER' parameter necessary for this feature. Good editors like
-        (X)Emacs, vi, jed, pico and joe all do.
-
-        - If the argument is not found as a variable, IPython will look for a
-        file with that name (adding .py if necessary) and load it into the
-        editor. It will execute its contents with execfile() when you exit,
-        loading any code in the file into your interactive namespace.
-
-        After executing your code, %edit will return as output the code you
-        typed in the editor (except when it was an existing file). This way
-        you can reload the code in further invocations of %edit as a variable,
-        via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
-        the output.
-
-        Note that %edit is also available through the alias %ed.
-
-        This is an example of creating a simple function inside the editor and
-        then modifying it. First, start up the editor:
-
-        In [1]: ed\
-        Editing... done. Executing edited code...\
-        Out[1]: 'def foo():\n    print "foo() was defined in an editing session"\n'
-
-        We can then call the function foo():
-        
-        In [2]: foo()\
-        foo() was defined in an editing session
-
-        Now we edit foo.  IPython automatically loads the editor with the
-        (temporary) file where foo() was previously defined:
-        
-        In [3]: ed foo\
-        Editing... done. Executing edited code...
-
-        And if we call foo() again we get the modified version:
-        
-        In [4]: foo()\
-        foo() has now been changed!
-
-        Here is an example of how to edit a code snippet successive
-        times. First we call the editor:
-
-        In [8]: ed\
-        Editing... done. Executing edited code...\
-        hello\
-        Out[8]: "print 'hello'\n"
-
-        Now we call it again with the previous output (stored in _):
-
-        In [9]: ed _\
-        Editing... done. Executing edited code...\
-        hello world\
-        Out[9]: "print 'hello world'\n"
-
-        Now we call it with the output #8 (stored in _8, also as Out[8]):
-
-        In [10]: ed _8\
-        Editing... done. Executing edited code...\
-        hello again\
-        Out[10]: "print 'hello again'\n"
-
-
-        Changing the default editor hook:
-
-        If you wish to write your own editor hook, you can put it in a
-        configuration file which you load at startup time.  The default hook
-        is defined in the IPython.hooks module, and you can use that as a
-        starting example for further modifications.  That file also has
-        general instructions on how to set a new hook for use once you've
-        defined it.
-
-**%env**::
-
-	List environment variables.
-
-**%exit**::
-
-	Exit IPython, confirming if configured to do so.
-
-        You can configure whether IPython asks for confirmation upon exit by
-        setting the confirm_exit flag in the ipythonrc file.
-
-**%hist**::
-
-	Alternate name for %history.
-
-**%history**::
-
-	Print input history (_i<n> variables), with most recent last.
-    
-    %history       -> print at most 40 inputs (some may be multi-line)\
-    %history n     -> print at most n inputs\
-    %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\
-    
-    Each input's number <n> is shown, and is accessible as the
-    automatically generated variable _i<n>.  Multi-line statements are
-    printed starting at a new line for easy copy/paste.
-    
-
-    Options:
-
-      -n: do NOT print line numbers. This is useful if you want to get a
-      printout of many lines which can be directly pasted into a text
-      editor.
-
-      This feature is only available if numbered prompts are in use.
-
-      -t: (default) print the 'translated' history, as IPython understands it.
-      IPython filters your input and converts it all into valid Python source
-      before executing it (things like magics or aliases are turned into
-      function calls, for example). With this option, you'll see the native
-      history instead of the user-entered version: '%cd /' will be seen as
-      '_ip.magic("%cd /")' instead of '%cd /'.
-      
-      -r: print the 'raw' history, i.e. the actual commands you typed.
-      
-      -g: treat the arg as a pattern to grep for in (full) history.
-      This includes the "shadow history" (almost all commands ever written).
-      Use '%hist -g' to show full shadow history (may be very long).
-      In shadow history, every index nuwber starts with 0.
-
-      -f FILENAME: instead of printing the output to the screen, redirect it to
-       the given file.  The file is always overwritten, though IPython asks for
-       confirmation first if it already exists.
-
-**%logoff**::
-
-	Temporarily stop logging.
-
-        You must have previously started logging.
-
-**%logon**::
-
-	Restart logging.
-
-        This function is for restarting logging which you've temporarily
-        stopped with %logoff. For starting logging for the first time, you
-        must use the %logstart function, which allows you to specify an
-        optional log filename.
-
-**%logstart**::
-
-	Start logging anywhere in a session.
-
-        %logstart [-o|-r|-t] [log_name [log_mode]]
-
-        If no name is given, it defaults to a file named 'ipython_log.py' in your
-        current directory, in 'rotate' mode (see below).
-
-        '%logstart name' saves to file 'name' in 'backup' mode.  It saves your
-        history up to that point and then continues logging.
-
-        %logstart takes a second optional parameter: logging mode. This can be one
-        of (note that the modes are given unquoted):\
-          append: well, that says it.\
-          backup: rename (if exists) to name~ and start name.\
-          global: single logfile in your home dir, appended to.\
-          over  : overwrite existing log.\
-          rotate: create rotating logs name.1~, name.2~, etc.
-
-        Options:
-
-          -o: log also IPython's output.  In this mode, all commands which
-          generate an Out[NN] prompt are recorded to the logfile, right after
-          their corresponding input line.  The output lines are always
-          prepended with a '#[Out]# ' marker, so that the log remains valid
-          Python code.
-
-          Since this marker is always the same, filtering only the output from
-          a log is very easy, using for example a simple awk call:
-
-            awk -F'#\[Out\]# ' '{if($2) {print $2}}' ipython_log.py
-
-          -r: log 'raw' input.  Normally, IPython's logs contain the processed
-          input, so that user lines are logged in their final form, converted
-          into valid Python.  For example, %Exit is logged as
-          '_ip.magic("Exit").  If the -r flag is given, all input is logged
-          exactly as typed, with no transformations applied.
-
-          -t: put timestamps before each input line logged (these are put in
-          comments).
-
-**%logstate**::
-
-	Print the status of the logging system.
-
-**%logstop**::
-
-	Fully stop logging and close log file.
-
-        In order to start logging again, a new %logstart call needs to be made,
-        possibly (though not necessarily) with a new filename, mode and other
-        options.
-
-**%lsmagic**::
-
-	List currently available magic functions.
-
-**%macro**::
-
-	Define a set of input lines as a macro for future re-execution.
-
-        Usage:\
-          %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
-
-        Options:
-        
-          -r: use 'raw' input.  By default, the 'processed' history is used,
-          so that magics are loaded in their transformed version to valid
-          Python.  If this option is given, the raw input as typed as the
-          command line is used instead.
-
-        This will define a global variable called `name` which is a string
-        made of joining the slices and lines you specify (n1,n2,... numbers
-        above) from your input history into a single string. This variable
-        acts like an automatic function which re-executes those lines as if
-        you had typed them. You just type 'name' at the prompt and the code
-        executes.
-
-        The notation for indicating number ranges is: n1-n2 means 'use line
-        numbers n1,...n2' (the endpoint is included).  That is, '5-7' means
-        using the lines numbered 5,6 and 7.
-
-        Note: as a 'hidden' feature, you can also use traditional python slice
-        notation, where N:M means numbers N through M-1.
-
-        For example, if your history contains (%hist prints it):
-        
-          44: x=1\
-          45: y=3\
-          46: z=x+y\
-          47: print x\
-          48: a=5\
-          49: print 'x',x,'y',y\
-
-        you can create a macro with lines 44 through 47 (included) and line 49
-        called my_macro with:
-
-          In [51]: %macro my_macro 44-47 49
-
-        Now, typing `my_macro` (without quotes) will re-execute all this code
-        in one pass.
-
-        You don't need to give the line-numbers in order, and any given line
-        number can appear multiple times. You can assemble macros with any
-        lines from your input history in any order.
-
-        The macro is a simple object which holds its value in an attribute,
-        but IPython's display system checks for macros and executes them as
-        code instead of printing them when you type their name.
-
-        You can view a macro's contents by explicitly printing it with:
-        
-          'print macro_name'.
-
-        For one-off cases which DON'T contain magic function calls in them you
-        can obtain similar results by explicitly executing slices from your
-        input history with:
-
-          In [60]: exec In[44:48]+In[49]
-
-**%magic**::
-
-	Print information about the magic function system.
-
-**%mglob**::
-
-	    This program allows specifying filenames with "mglob" mechanism.
-    Supported syntax in globs (wilcard matching patterns)::
-    
-     *.cpp ?ellowo*                
-         - obvious. Differs from normal glob in that dirs are not included.
-           Unix users might want to write this as: "*.cpp" "?ellowo*"
-     rec:/usr/share=*.txt,*.doc    
-         - get all *.txt and *.doc under /usr/share, 
-           recursively
-     rec:/usr/share
-         - All files under /usr/share, recursively
-     rec:*.py
-         - All .py files under current working dir, recursively
-     foo                           
-         - File or dir foo
-     !*.bak readme*                   
-         - readme*, exclude files ending with .bak
-     !.svn/ !.hg/ !*_Data/ rec:.
-         - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
-           Trailing / is the key, \ does not work!
-     dir:foo                       
-         - the directory foo if it exists (not files in foo)
-     dir:*                         
-         - all directories in current folder
-     foo.py bar.* !h* rec:*.py
-         - Obvious. !h* exclusion only applies for rec:*.py.
-           foo.py is *not* included twice.
-     @filelist.txt
-         - All files listed in 'filelist.txt' file, on separate lines.
-
-**%page**::
-
-	Pretty print the object and display it through a pager.
-        
-        %page [options] OBJECT
-
-        If no object is given, use _ (last output).
-        
-        Options:
-
-          -r: page str(object), don't pretty-print it.
-
-**%pdb**::
-
-	Control the automatic calling of the pdb interactive debugger.
-
-        Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
-        argument it works as a toggle.
-
-        When an exception is triggered, IPython can optionally call the
-        interactive pdb debugger after the traceback printout. %pdb toggles
-        this feature on and off.
-
-        The initial state of this feature is set in your ipythonrc
-        configuration file (the variable is called 'pdb').
-
-        If you want to just activate the debugger AFTER an exception has fired,
-        without having to type '%pdb on' and rerunning your code, you can use
-        the %debug magic.
-
-**%pdef**::
-
-	Print the definition header for any callable object.
-
-        If the object is a class, print the constructor information.
-
-**%pdoc**::
-
-	Print the docstring for an object.
-
-        If the given object is a class, it will print both the class and the
-        constructor docstrings.
-
-**%pfile**::
-
-	Print (or run through pager) the file where an object is defined.
-
-        The file opens at the line where the object definition begins. IPython
-        will honor the environment variable PAGER if set, and otherwise will
-        do its best to print the file in a convenient form.
-
-        If the given argument is not an object currently defined, IPython will
-        try to interpret it as a filename (automatically adding a .py extension
-        if needed). You can thus use %pfile as a syntax highlighting code
-        viewer.
-
-**%pinfo**::
-
-	Provide detailed information about an object.
-    
-        '%pinfo object' is just a synonym for object? or ?object.
-
-**%popd**::
-
-	Change to directory popped off the top of the stack.
-
-**%profile**::
-
-	Print your currently active IPyhton profile.
-
-**%prun**::
-
-	Run a statement through the python code profiler.
-
-        Usage:\
-          %prun [options] statement
-
-        The given statement (which doesn't require quote marks) is run via the
-        python profiler in a manner similar to the profile.run() function.
-        Namespaces are internally managed to work correctly; profile.run
-        cannot be used in IPython because it makes certain assumptions about
-        namespaces which do not hold under IPython.
-
-        Options:
-
-        -l <limit>: you can place restrictions on what or how much of the
-        profile gets printed. The limit value can be:
-
-          * A string: only information for function names containing this string
-          is printed.
-
-          * An integer: only these many lines are printed.
-
-          * A float (between 0 and 1): this fraction of the report is printed
-          (for example, use a limit of 0.4 to see the topmost 40% only).
-
-        You can combine several limits with repeated use of the option. For
-        example, '-l __init__ -l 5' will print only the topmost 5 lines of
-        information about class constructors.
-
-        -r: return the pstats.Stats object generated by the profiling. This
-        object has all the information about the profile in it, and you can
-        later use it for further analysis or in other functions.
-
-       -s <key>: sort profile by given key. You can provide more than one key
-        by using the option several times: '-s key1 -s key2 -s key3...'. The
-        default sorting key is 'time'.
-
-        The following is copied verbatim from the profile documentation
-        referenced below:
-
-        When more than one key is provided, additional keys are used as
-        secondary criteria when the there is equality in all keys selected
-        before them.
-        
-        Abbreviations can be used for any key names, as long as the
-        abbreviation is unambiguous.  The following are the keys currently
-        defined:
-
-                Valid Arg       Meaning\
-                  "calls"      call count\
-                  "cumulative" cumulative time\
-                  "file"       file name\
-                  "module"     file name\
-                  "pcalls"     primitive call count\
-                  "line"       line number\
-                  "name"       function name\
-                  "nfl"        name/file/line\
-                  "stdname"    standard name\
-                  "time"       internal time
-
-        Note that all sorts on statistics are in descending order (placing
-        most time consuming items first), where as name, file, and line number
-        searches are in ascending order (i.e., alphabetical). The subtle
-        distinction between "nfl" and "stdname" is that the standard name is a
-        sort of the name as printed, which means that the embedded line
-        numbers get compared in an odd way.  For example, lines 3, 20, and 40
-        would (if the file names were the same) appear in the string order
-        "20" "3" and "40".  In contrast, "nfl" does a numeric compare of the
-        line numbers.  In fact, sort_stats("nfl") is the same as
-        sort_stats("name", "file", "line").
-
-        -T <filename>: save profile results as shown on screen to a text
-        file. The profile is still shown on screen.
-
-        -D <filename>: save (via dump_stats) profile statistics to given
-        filename. This data is in a format understod by the pstats module, and
-        is generated by a call to the dump_stats() method of profile
-        objects. The profile is still shown on screen.
-
-        If you want to run complete programs under the profiler's control, use
-        '%run -p [prof_opts] filename.py [args to program]' where prof_opts
-        contains profiler specific options as described here.
-        
-        You can read the complete documentation for the profile module with:\
-          In [1]: import profile; profile.help()
-
-**%psearch**::
-
-	Search for object in namespaces by wildcard.
-
-        %psearch [options] PATTERN [OBJECT TYPE]
-
-        Note: ? can be used as a synonym for %psearch, at the beginning or at
-        the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the
-        rest of the command line must be unchanged (options come first), so
-        for example the following forms are equivalent
-
-        %psearch -i a* function
-        -i a* function?
-        ?-i a* function
-
-        Arguments:
-        
-          PATTERN
-
-          where PATTERN is a string containing * as a wildcard similar to its
-          use in a shell.  The pattern is matched in all namespaces on the
-          search path. By default objects starting with a single _ are not
-          matched, many IPython generated objects have a single
-          underscore. The default is case insensitive matching. Matching is
-          also done on the attributes of objects and not only on the objects
-          in a module.
-
-          [OBJECT TYPE]
-
-          Is the name of a python type from the types module. The name is
-          given in lowercase without the ending type, ex. StringType is
-          written string. By adding a type here only objects matching the
-          given type are matched. Using all here makes the pattern match all
-          types (this is the default).
-
-        Options:
-
-          -a: makes the pattern match even objects whose names start with a
-          single underscore.  These names are normally ommitted from the
-          search.
-
-          -i/-c: make the pattern case insensitive/sensitive.  If neither of
-          these options is given, the default is read from your ipythonrc
-          file.  The option name which sets this value is
-          'wildcards_case_sensitive'.  If this option is not specified in your
-          ipythonrc file, IPython's internal default is to do a case sensitive
-          search.
-
-          -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you
-          specifiy can be searched in any of the following namespaces:
-          'builtin', 'user', 'user_global','internal', 'alias', where
-          'builtin' and 'user' are the search defaults.  Note that you should
-          not use quotes when specifying namespaces.
-
-          'Builtin' contains the python module builtin, 'user' contains all
-          user data, 'alias' only contain the shell aliases and no python
-          objects, 'internal' contains objects used by IPython.  The
-          'user_global' namespace is only used by embedded IPython instances,
-          and it contains module-level globals.  You can add namespaces to the
-          search with -s or exclude them with -e (these options can be given
-          more than once).
-    
-        Examples:
-       
-        %psearch a*            -> objects beginning with an a
-        %psearch -e builtin a* -> objects NOT in the builtin space starting in a
-        %psearch a* function   -> all functions beginning with an a
-        %psearch re.e*         -> objects beginning with an e in module re
-        %psearch r*.e*         -> objects that start with e in modules starting in r
-        %psearch r*.* string   -> all strings in modules beginning with r
-
-        Case sensitve search:
-       
-        %psearch -c a*         list all object beginning with lower case a
-
-        Show objects beginning with a single _:
-       
-        %psearch -a _*         list objects beginning with a single underscore
-
-**%psource**::
-
-	Print (or run through pager) the source code for an object.
-
-**%pushd**::
-
-	Place the current dir on stack and change directory.
-        
-        Usage:\
-          %pushd ['dirname']
-
-**%pwd**::
-
-	Return the current working directory path.
-
-**%pycat**::
-
-	Show a syntax-highlighted file through a pager.
-
-        This magic is similar to the cat utility, but it will assume the file
-        to be Python source and will show it with syntax highlighting.
-
-**%quickref**::
-
-	 Show a quick reference sheet
-
-**%quit**::
-
-	Exit IPython, confirming if configured to do so (like %exit)
-
-**%r**::
-
-	Repeat previous input.
-
-        Note: Consider using the more powerfull %rep instead!
-        
-        If given an argument, repeats the previous command which starts with
-        the same string, otherwise it just repeats the previous input.
-
-        Shell escaped commands (with ! as first character) are not recognized
-        by this system, only pure python code and magic commands.
-
-**%rehashdir**::
-
-	 Add executables in all specified dirs to alias table
-     
-    Usage:
-
-    %rehashdir c:/bin;c:/tools
-      - Add all executables under c:/bin and c:/tools to alias table, in 
-      order to make them directly executable from any directory.
-        
-      Without arguments, add all executables in current directory.
-
-**%rehashx**::
-
-	Update the alias table with all executable files in $PATH.
-
-        This version explicitly checks that every entry in $PATH is a file
-        with execute access (os.X_OK), so it is much slower than %rehash.
-
-        Under Windows, it checks executability as a match agains a
-        '|'-separated string of extensions, stored in the IPython config
-        variable win_exec_ext.  This defaults to 'exe|com|bat'.
-        
-        This function also resets the root module cache of module completer,
-        used on slow filesystems.
-
-**%rep**::
-
-	 Repeat a command, or get command to input line for editing
-
-    - %rep (no arguments):
-    
-    Place a string version of last computation result (stored in the special '_'
-    variable) to the next input prompt. Allows you to create elaborate command
-    lines without using copy-paste::
-    
-        $ l = ["hei", "vaan"]       
-        $ "".join(l)        
-        ==> heivaan        
-        $ %rep        
-        $ heivaan_ <== cursor blinking    
-    
-    %rep 45
-    
-    Place history line 45 to next input prompt. Use %hist to find out the
-    number.
-    
-    %rep 1-4 6-7 3
-    
-    Repeat the specified lines immediately. Input slice syntax is the same as
-    in %macro and %save.
-    
-    %rep foo
-    
-    Place the most recent line that has the substring "foo" to next input.
-    (e.g. 'svn ci -m foobar').
-
-**%reset**::
-
-	Resets the namespace by removing all names defined by the user.
-
-        Input/Output history are left around in case you need them.
-
-**%run**::
-
-	Run the named file inside IPython as a program.
-
-        Usage:\
-          %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
-        
-        Parameters after the filename are passed as command-line arguments to
-        the program (put in sys.argv). Then, control returns to IPython's
-        prompt.
-
-        This is similar to running at a system prompt:\
-          $ python file args\
-        but with the advantage of giving you IPython's tracebacks, and of
-        loading all variables into your interactive namespace for further use
-        (unless -p is used, see below).
-
-        The file is executed in a namespace initially consisting only of
-        __name__=='__main__' and sys.argv constructed as indicated. It thus
-        sees its environment as if it were being run as a stand-alone program
-        (except for sharing global objects such as previously imported
-        modules). But after execution, the IPython interactive namespace gets
-        updated with all variables defined in the program (except for __name__
-        and sys.argv). This allows for very convenient loading of code for
-        interactive work, while giving each program a 'clean sheet' to run in.
-
-        Options:
-        
-        -n: __name__ is NOT set to '__main__', but to the running file's name
-        without extension (as python does under import).  This allows running
-        scripts and reloading the definitions in them without calling code
-        protected by an ' if __name__ == "__main__" ' clause.
-
-        -i: run the file in IPython's namespace instead of an empty one. This
-        is useful if you are experimenting with code written in a text editor
-        which depends on variables defined interactively.
-
-        -e: ignore sys.exit() calls or SystemExit exceptions in the script
-        being run.  This is particularly useful if IPython is being used to
-        run unittests, which always exit with a sys.exit() call.  In such
-        cases you are interested in the output of the test results, not in
-        seeing a traceback of the unittest module.
-
-        -t: print timing information at the end of the run.  IPython will give
-        you an estimated CPU time consumption for your script, which under
-        Unix uses the resource module to avoid the wraparound problems of
-        time.clock().  Under Unix, an estimate of time spent on system tasks
-        is also given (for Windows platforms this is reported as 0.0).
-
-        If -t is given, an additional -N<N> option can be given, where <N>
-        must be an integer indicating how many times you want the script to
-        run.  The final timing report will include total and per run results.
-
-        For example (testing the script uniq_stable.py):
-
-            In [1]: run -t uniq_stable
-
-            IPython CPU timings (estimated):\
-              User  :    0.19597 s.\
-              System:        0.0 s.\
-
-            In [2]: run -t -N5 uniq_stable
-
-            IPython CPU timings (estimated):\
-            Total runs performed: 5\
-              Times :      Total       Per run\
-              User  :   0.910862 s,  0.1821724 s.\
-              System:        0.0 s,        0.0 s.
-
-        -d: run your program under the control of pdb, the Python debugger.
-        This allows you to execute your program step by step, watch variables,
-        etc.  Internally, what IPython does is similar to calling:
-        
-          pdb.run('execfile("YOURFILENAME")')
-
-        with a breakpoint set on line 1 of your file.  You can change the line
-        number for this automatic breakpoint to be <N> by using the -bN option
-        (where N must be an integer).  For example:
-
-          %run -d -b40 myscript
-
-        will set the first breakpoint at line 40 in myscript.py.  Note that
-        the first breakpoint must be set on a line which actually does
-        something (not a comment or docstring) for it to stop execution.
-
-        When the pdb debugger starts, you will see a (Pdb) prompt.  You must
-        first enter 'c' (without qoutes) to start execution up to the first
-        breakpoint.
-
-        Entering 'help' gives information about the use of the debugger.  You
-        can easily see pdb's full documentation with "import pdb;pdb.help()"
-        at a prompt.
-
-        -p: run program under the control of the Python profiler module (which
-        prints a detailed report of execution times, function calls, etc).
-
-        You can pass other options after -p which affect the behavior of the
-        profiler itself. See the docs for %prun for details.
-
-        In this mode, the program's variables do NOT propagate back to the
-        IPython interactive namespace (because they remain in the namespace
-        where the profiler executes them).
-
-        Internally this triggers a call to %prun, see its documentation for
-        details on the options available specifically for profiling.
-
-        There is one special usage for which the text above doesn't apply:
-        if the filename ends with .ipy, the file is run as ipython script,
-        just as if the commands were written on IPython prompt.
-
-**%runlog**::
-
-	Run files as logs.
-
-        Usage:\
-          %runlog file1 file2 ...
-
-        Run the named files (treating them as log files) in sequence inside
-        the interpreter, and return to the prompt.  This is much slower than
-        %run because each line is executed in a try/except block, but it
-        allows running files with syntax errors in them.
-
-        Normally IPython will guess when a file is one of its own logfiles, so
-        you can typically use %run even for logs. This shorthand allows you to
-        force any file to be treated as a log file.
-
-**%save**::
-
-	Save a set of lines to a given filename.
-
-        Usage:\
-          %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
-
-        Options:
-        
-          -r: use 'raw' input.  By default, the 'processed' history is used,
-          so that magics are loaded in their transformed version to valid
-          Python.  If this option is given, the raw input as typed as the
-          command line is used instead.
-
-        This function uses the same syntax as %macro for line extraction, but
-        instead of creating a macro it saves the resulting string to the
-        filename you specify.
-
-        It adds a '.py' extension to the file if you don't do so yourself, and
-        it asks for confirmation before overwriting existing files.
-
-**%sc**::
-
-	Shell capture - execute a shell command and capture its output.
-
-        DEPRECATED. Suboptimal, retained for backwards compatibility.
-        
-        You should use the form 'var = !command' instead. Example:
-         
-         "%sc -l myfiles = ls ~" should now be written as
-            
-         "myfiles = !ls ~"
-         
-        myfiles.s, myfiles.l and myfiles.n still apply as documented
-        below.
-
-        --
-        %sc [options] varname=command
-
-        IPython will run the given command using commands.getoutput(), and
-        will then update the user's interactive namespace with a variable
-        called varname, containing the value of the call.  Your command can
-        contain shell wildcards, pipes, etc.
-
-        The '=' sign in the syntax is mandatory, and the variable name you
-        supply must follow Python's standard conventions for valid names.
-        
-        (A special format without variable name exists for internal use)
-
-        Options:
-
-          -l: list output.  Split the output on newlines into a list before
-          assigning it to the given variable.  By default the output is stored
-          as a single string.
-
-          -v: verbose.  Print the contents of the variable.
-
-        In most cases you should not need to split as a list, because the
-        returned value is a special type of string which can automatically
-        provide its contents either as a list (split on newlines) or as a
-        space-separated string.  These are convenient, respectively, either
-        for sequential processing or to be passed to a shell command.
-
-        For example:
-
-            # Capture into variable a
-            In [9]: sc a=ls *py
-
-            # a is a string with embedded newlines
-            In [10]: a
-            Out[10]: 'setup.py win32_manual_post_install.py'
-
-            # which can be seen as a list:
-            In [11]: a.l
-            Out[11]: ['setup.py', 'win32_manual_post_install.py']
-
-            # or as a whitespace-separated string:
-            In [12]: a.s
-            Out[12]: 'setup.py win32_manual_post_install.py'
-
-            # a.s is useful to pass as a single command line:
-            In [13]: !wc -l $a.s
-              146 setup.py
-              130 win32_manual_post_install.py
-              276 total
-
-            # while the list form is useful to loop over:
-            In [14]: for f in a.l:
-               ....:      !wc -l $f
-               ....:
-            146 setup.py
-            130 win32_manual_post_install.py
-
-        Similiarly, the lists returned by the -l option are also special, in
-        the sense that you can equally invoke the .s attribute on them to
-        automatically get a whitespace-separated string from their contents:
-
-            In [1]: sc -l b=ls *py
-
-            In [2]: b
-            Out[2]: ['setup.py', 'win32_manual_post_install.py']
-
-            In [3]: b.s
-            Out[3]: 'setup.py win32_manual_post_install.py'
-
-        In summary, both the lists and strings used for ouptut capture have
-        the following special attributes:
-
-            .l (or .list) : value as list.
-            .n (or .nlstr): value as newline-separated string.
-            .s (or .spstr): value as space-separated string.
-
-**%store**::
-
-	Lightweight persistence for python variables.
-
-    Example:
-    
-    ville@badger[~]|1> A = ['hello',10,'world']\
-    ville@badger[~]|2> %store A\
-    ville@badger[~]|3> Exit
-    
-    (IPython session is closed and started again...)
-    
-    ville@badger:~$ ipython -p pysh\
-    ville@badger[~]|1> print A
-    
-    ['hello', 10, 'world']
-    
-    Usage:
-    
-    %store          - Show list of all variables and their current values\
-    %store <var>    - Store the *current* value of the variable to disk\
-    %store -d <var> - Remove the variable and its value from storage\
-    %store -z       - Remove all variables from storage\
-    %store -r       - Refresh all variables from store (delete current vals)\
-    %store foo >a.txt  - Store value of foo to new file a.txt\
-    %store foo >>a.txt - Append value of foo to file a.txt\   
-    
-    It should be noted that if you change the value of a variable, you
-    need to %store it again if you want to persist the new value.
-    
-    Note also that the variables will need to be pickleable; most basic
-    python types can be safely %stored.
-    
-    Also aliases can be %store'd across sessions.
-
-**%sx**::
-
-	Shell execute - run a shell command and capture its output.
-
-        %sx command
-
-        IPython will run the given command using commands.getoutput(), and
-        return the result formatted as a list (split on '\n').  Since the
-        output is _returned_, it will be stored in ipython's regular output
-        cache Out[N] and in the '_N' automatic variables.
-
-        Notes:
-
-        1) If an input line begins with '!!', then %sx is automatically
-        invoked.  That is, while:
-          !ls
-        causes ipython to simply issue system('ls'), typing
-          !!ls
-        is a shorthand equivalent to:
-          %sx ls
-        
-        2) %sx differs from %sc in that %sx automatically splits into a list,
-        like '%sc -l'.  The reason for this is to make it as easy as possible
-        to process line-oriented shell output via further python commands.
-        %sc is meant to provide much finer control, but requires more
-        typing.
-
-        3) Just like %sc -l, this is a list with special attributes:
-
-          .l (or .list) : value as list.
-          .n (or .nlstr): value as newline-separated string.
-          .s (or .spstr): value as whitespace-separated string.
-
-        This is very useful when trying to use such lists as arguments to
-        system commands.
-
-**%system_verbose**::
-
-	Set verbose printing of system calls.
-
-        If called without an argument, act as a toggle
-
-**%time**::
-
-	Time execution of a Python statement or expression.
-
-        The CPU and wall clock times are printed, and the value of the
-        expression (if any) is returned.  Note that under Win32, system time
-        is always reported as 0, since it can not be measured.
-
-        This function provides very basic timing functionality.  In Python
-        2.3, the timeit module offers more control and sophistication, so this
-        could be rewritten to use it (patches welcome).
-        
-        Some examples:
-
-          In [1]: time 2**128
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00
-          Out[1]: 340282366920938463463374607431768211456L
-
-          In [2]: n = 1000000
-
-          In [3]: time sum(range(n))
-          CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
-          Wall time: 1.37
-          Out[3]: 499999500000L
-
-          In [4]: time print 'hello world'
-          hello world
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00
-
-          Note that the time needed by Python to compile the given expression
-          will be reported if it is more than 0.1s.  In this example, the
-          actual exponentiation is done by Python at compilation time, so while
-          the expression can take a noticeable amount of time to compute, that
-          time is purely due to the compilation:
-
-          In [5]: time 3**9999;
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00 s
-
-          In [6]: time 3**999999;
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00 s
-          Compiler : 0.78 s
-
-**%timeit**::
-
-	Time execution of a Python statement or expression
-
-        Usage:\
-          %timeit [-n<N> -r<R> [-t|-c]] statement
-
-        Time execution of a Python statement or expression using the timeit
-        module.
-
-        Options:
-        -n<N>: execute the given statement <N> times in a loop. If this value
-        is not given, a fitting value is chosen. 
-        
-        -r<R>: repeat the loop iteration <R> times and take the best result.
-        Default: 3
-        
-        -t: use time.time to measure the time, which is the default on Unix.
-        This function measures wall time.
-        
-        -c: use time.clock to measure the time, which is the default on
-        Windows and measures wall time. On Unix, resource.getrusage is used
-        instead and returns the CPU user time.
-
-        -p<P>: use a precision of <P> digits to display the timing result.
-        Default: 3
-
-        
-        Examples:\
-          In [1]: %timeit pass
-          10000000 loops, best of 3: 53.3 ns per loop
-
-          In [2]: u = None
-
-          In [3]: %timeit u is None
-          10000000 loops, best of 3: 184 ns per loop
-
-          In [4]: %timeit -r 4 u == None
-          1000000 loops, best of 4: 242 ns per loop
-
-          In [5]: import time
-
-          In [6]: %timeit -n1 time.sleep(2)
-          1 loops, best of 3: 2 s per loop
-          
-
-        The times reported by %timeit will be slightly higher than those
-        reported by the timeit.py script when variables are accessed. This is
-        due to the fact that %timeit executes the statement in the namespace
-        of the shell, compared with timeit.py, which uses a single setup
-        statement to import function or create variables. Generally, the bias
-        does not matter as long as results from timeit.py are not mixed with
-        those from %timeit.
-
-**%unalias**::
-
-	Remove an alias
-
-**%upgrade**::
-
-	 Upgrade your IPython installation
-        
-        This will copy the config files that don't yet exist in your 
-        ipython dir from the system config dir. Use this after upgrading 
-        IPython if you don't wish to delete your .ipython dir.
-
-        Call with -nolegacy to get rid of ipythonrc* files (recommended for
-        new users)
-
-**%which**::
-
-	 %which <cmd> => search PATH for files matching cmd. Also scans aliases.
-
-    Traverses PATH and prints all files (not just executables!) that match the
-    pattern on command line. Probably more useful in finding stuff
-    interactively than 'which', which only prints the first matching item.
-    
-    Also discovers and expands aliases, so you'll see what will be executed
-    when you call an alias.
-    
-    Example:
-    
-    [~]|62> %which d
-    d -> ls -F --color=auto
-      == c:\cygwin\bin\ls.exe
-    c:\cygwin\bin\d.exe
-    
-    [~]|64> %which diff*
-    diff3 -> diff3
-      == c:\cygwin\bin\diff3.exe
-    diff -> diff
-      == c:\cygwin\bin\diff.exe
-    c:\cygwin\bin\diff.exe
-    c:\cygwin\bin\diff3.exe
-
-**%who**::
-
-	Print all interactive variables, with some minimal formatting.
-
-        If any arguments are given, only variables whose type matches one of
-        these are printed.  For example:
-
-          %who function str
-
-        will only list functions and strings, excluding all other types of
-        variables.  To find the proper type names, simply use type(var) at a
-        command line to see how python prints type names.  For example:
-
-          In [1]: type('hello')\
-          Out[1]: <type 'str'>
-
-        indicates that the type name for strings is 'str'.
-
-        %who always excludes executed names loaded through your configuration
-        file and things which are internal to IPython.
-
-        This is deliberate, as typically you may load many modules and the
-        purpose of %who is to show you only what you've manually defined.
-
-**%who_ls**::
-
-	Return a sorted list of all interactive variables.
-
-        If arguments are given, only variables of types matching these
-        arguments are returned.
-
-**%whos**::
-
-	Like %who, but gives some extra information about each variable.
-
-        The same type filtering of %who can be applied here.
-
-        For all variables, the type is printed. Additionally it prints:
-        
-          - For {},[],(): their length.
-
-          - For numpy and Numeric arrays, a summary with shape, number of
-          elements, typecode and size in memory.
-
-          - Everything else: a string representation, snipping their middle if
-          too long.
-
-**%xmode**::
-
-	Switch modes for the exception handlers.
-
-        Valid modes: Plain, Context and Verbose.
-
-        If called without arguments, acts as a toggle.
-
-.. magic_end
 
 Access to the standard Python help
 ----------------------------------

docs/source/overview.txt

@@ -91,10 +91,10 b' Main features of the interactive shell'
   IPython has an internal job manager called jobs, and a
   convenience backgrounding magic function called :samp:`%bg`.
 
-* The ability to expand python variables when calling the system
-  shell. In a shell command, any python variable prefixed with :samp:`$` is
-  expanded. A double :samp:`$$` allows passing a literal :samp:`$` to the shell (for
-  access to shell and environment variables like :envvar:`PATH`).
+* The ability to expand python variables when calling the system shell. In a
+  shell command, any python variable prefixed with :samp:`$` is expanded. A
+  double :samp:`$$` allows passing a literal :samp:`$` to the shell (for access
+  to shell and environment variables like :envvar:`PATH`).
 
 * Filesystem navigation, via a magic :samp:`%cd` command, along with a
   persistent bookmark system (using :samp:`%bookmark`) for fast access to
@@ -150,17 +150,16 b' Main features of the interactive shell'
   about the local namespaces (very useful in debugging and data
   analysis situations).
 
-* Easy debugger access. You can set IPython to call up an enhanced
-  version of the Python debugger (pdb) every time there is an
-  uncaught exception. This drops you inside the code which triggered
-  the exception with all the data live and it is possible to
-  navigate the stack to rapidly isolate the source of a bug. The
-  :samp:`%run` magic command (with the :samp:`-d` option) can run any script under
-  pdb's control, automatically setting initial breakpoints for you.
-  This version of pdb has IPython-specific improvements, including
-  tab-completion and traceback coloring support. For even easier
-  debugger access, try :samp:`%debug` after seeing an exception. winpdb is 
-  also supported, see ipy_winpdb extension.
+* Easy debugger access. You can set IPython to call up an enhanced version of
+  the Python debugger (pdb) every time there is an uncaught exception. This
+  drops you inside the code which triggered the exception with all the data
+  live and it is possible to navigate the stack to rapidly isolate the source
+  of a bug. The :samp:`%run` magic command (with the :samp:`-d` option) can run
+  any script under pdb's control, automatically setting initial breakpoints for
+  you.  This version of pdb has IPython-specific improvements, including
+  tab-completion and traceback coloring support. For even easier debugger
+  access, try :samp:`%debug` after seeing an exception. winpdb is also
+  supported, see ipy_winpdb extension.
 
 * Profiler support. You can run single statements (similar to
   :samp:`profile.run()`) or complete programs under the profiler's control.
@@ -176,10 +175,11 b' Main features of the interactive shell'
 Interactive parallel computing
 ==============================
 
-Increasingly, parallel computer hardware, such as multicore CPUs, clusters and supercomputers, is becoming ubiquitous. Over the last 3 years, we have developed an
-architecture within IPython that allows such hardware to be used quickly and easily
-from Python. Moreover, this architecture is designed to support interactive and
-collaborative parallel computing.
+Increasingly, parallel computer hardware, such as multicore CPUs, clusters and
+supercomputers, is becoming ubiquitous. Over the last 3 years, we have
+developed an architecture within IPython that allows such hardware to be used
+quickly and easily from Python. Moreover, this architecture is designed to
+support interactive and collaborative parallel computing.
 
 The main features of this system are:
 
@@ -204,16 +204,16 b' The main features of this system are:'
 
 * Capabilities based security model with full encryption of network connections.
 
-* Share live parallel jobs with other users securely.  We call this collaborative
-  parallel computing.
+* Share live parallel jobs with other users securely.  We call this
+  collaborative parallel computing.
 
 * Dynamically load balanced task farming system.
 
 * Robust error handling.  Python exceptions raised in parallel execution are
   gathered and presented to the top-level code.
 
-For more information, see our :ref:`overview <parallel_index>` of using IPython for
-parallel computing.
+For more information, see our :ref:`overview <parallel_index>` of using IPython
+for parallel computing.
 
 Portability and Python requirements
 -----------------------------------
@@ -225,8 +225,7 b' work with some minor changes.'
 IPython is known to work on the following operating systems:
 
 	* Linux
-	* AIX
-	* Most other Unix-like OSs (Solaris, BSD, etc.)
+	* Most other Unix-like OSs (AIX, Solaris, BSD, etc.)
 	* Mac OS X
 	* Windows (CygWin, XP, Vista, etc.)
 

docs/source/parallel/index.txt

@@ -13,4 +13,4 b' Using IPython for parallel computing'
    parallel_task.txt
    parallel_mpi.txt
    parallel_security.txt
-
+   visionhpc.txt

docs/sphinxext/inheritance_diagram.py

@@ -39,11 +39,20 b' except ImportError:'
     from md5 import md5
 
 from docutils.nodes import Body, Element
-from docutils.writers.html4css1 import HTMLTranslator
-from sphinx.latexwriter import LaTeXTranslator
 from docutils.parsers.rst import directives
 from sphinx.roles import xfileref_role
 
+def my_import(name):
+    """Module importer - taken from the python documentation.
+
+    This function allows importing names with dots in them."""
+    
+    mod = __import__(name)
+    components = name.split('.')
+    for comp in components[1:]:
+        mod = getattr(mod, comp)
+    return mod
+
 class DotException(Exception):
     pass
 
@@ -84,11 +93,15 b' class InheritanceGraph(object):'
         path = (path and path.rstrip('.'))
         if not path:
             path = base
-        if not path:
-            raise ValueError(
-                "Invalid class or module '%s' specified for inheritance diagram" % name)
         try:
             module = __import__(path, None, None, [])
+            # We must do an import of the fully qualified name.  Otherwise if a
+            # subpackage 'a.b' is requested where 'import a' does NOT provide
+            # 'a.b' automatically, then 'a.b' will not be found below.  This
+            # second call will force the equivalent of 'import a.b' to happen
+            # after the top-level import above.
+            my_import(fullname)
+            
         except ImportError:
             raise ValueError(
                 "Could not import class or module '%s' specified for inheritance diagram" % name)
@@ -277,12 +290,16 b' class inheritance_diagram(Body, Element):'
     """
     pass
 
-def inheritance_diagram_directive_run(class_names, options, state):
+def inheritance_diagram_directive(name, arguments, options, content, lineno,
+                                  content_offset, block_text, state,
+                                  state_machine):
     """
     Run when the inheritance_diagram directive is first encountered.
     """
     node = inheritance_diagram()
 
+    class_names = arguments
+
     # Create a graph starting with the list of classes
     graph = InheritanceGraph(class_names)
 
@@ -315,15 +332,12 b' def html_output_graph(self, node):'
 
     graph_hash = get_graph_hash(node)
     name = "inheritance%s" % graph_hash
-    png_path = os.path.join('_static', name + ".png")
-
-    path = '_static'
-    source = self.document.attributes['source']
-    count = source.split('/doc/')[-1].count('/')
-    for i in range(count):
-        if os.path.exists(path): break
-        path = '../'+path
-    path = '../'+path #specifically added for matplotlib
+    path = '_images'
+    dest_path = os.path.join(setup.app.builder.outdir, path)
+    if not os.path.exists(dest_path):
+        os.makedirs(dest_path)
+    png_path = os.path.join(dest_path, name + ".png")
+    path = setup.app.builder.imgpath
 
     # Create a mapping from fully-qualified class names to URLs.
     urls = {}
@@ -349,11 +363,14 b' def latex_output_graph(self, node):'
 
     graph_hash = get_graph_hash(node)
     name = "inheritance%s" % graph_hash
-    pdf_path = os.path.join('_static', name + ".pdf")
+    dest_path = os.path.abspath(os.path.join(setup.app.builder.outdir, '_images'))
+    if not os.path.exists(dest_path):
+        os.makedirs(dest_path)
+    pdf_path = os.path.abspath(os.path.join(dest_path, name + ".pdf"))
 
     graph.run_dot(['-Tpdf', '-o%s' % pdf_path],
                   name, parts, graph_options={'size': '"6.0,6.0"'})
-    return '\\includegraphics{../../%s}' % pdf_path
+    return '\n\\includegraphics{%s}\n\n' % pdf_path
 
 def visit_inheritance_diagram(inner_func):
     """
@@ -377,47 +394,14 b' def visit_inheritance_diagram(inner_func):'
 def do_nothing(self, node):
     pass
 
-options_spec = {
-    'parts': directives.nonnegative_int
-    }
-
-# Deal with the old and new way of registering directives
-try:
-    from docutils.parsers.rst import Directive
-except ImportError:
-    from docutils.parsers.rst.directives import _directives
-    def inheritance_diagram_directive(name, arguments, options, content, lineno,
-                                      content_offset, block_text, state,
-                                      state_machine):
-        return inheritance_diagram_directive_run(arguments, options, state)
-    inheritance_diagram_directive.__doc__ = __doc__
-    inheritance_diagram_directive.arguments = (1, 100, 0)
-    inheritance_diagram_directive.options = options_spec
-    inheritance_diagram_directive.content = 0
-    _directives['inheritance-diagram'] = inheritance_diagram_directive
-else:
-    class inheritance_diagram_directive(Directive):
-        has_content = False
-        required_arguments = 1
-        optional_arguments = 100
-        final_argument_whitespace = False
-        option_spec = options_spec
-
-        def run(self):
-            return inheritance_diagram_directive_run(
-                self.arguments, self.options, self.state)
-    inheritance_diagram_directive.__doc__ = __doc__
-
-    directives.register_directive('inheritance-diagram',
-                                  inheritance_diagram_directive)
-
 def setup(app):
-    app.add_node(inheritance_diagram)
-
-    HTMLTranslator.visit_inheritance_diagram = \
-        visit_inheritance_diagram(html_output_graph)
-    HTMLTranslator.depart_inheritance_diagram = do_nothing
-
-    LaTeXTranslator.visit_inheritance_diagram = \
-        visit_inheritance_diagram(latex_output_graph)
-    LaTeXTranslator.depart_inheritance_diagram = do_nothing
+    setup.app = app
+    setup.confdir = app.confdir
+
+    app.add_node(
+        inheritance_diagram,
+        latex=(visit_inheritance_diagram(latex_output_graph), do_nothing),
+        html=(visit_inheritance_diagram(html_output_graph), do_nothing))
+    app.add_directive(
+        'inheritance-diagram', inheritance_diagram_directive,
+        False, (1, 100, 0), parts = directives.nonnegative_int)

docs/sphinxext/ipython_console_highlighting.py

@@ -1,18 +1,32 b''
+"""reST directive for syntax-highlighting ipython interactive sessions.
+"""
+
+#-----------------------------------------------------------------------------
+# Needed modules
+
+# Standard library
+import re
+
+# Third party
 from pygments.lexer import Lexer, do_insertions
-from pygments.lexers.agile import PythonConsoleLexer, PythonLexer, \
-    PythonTracebackLexer
+from pygments.lexers.agile import (PythonConsoleLexer, PythonLexer, 
+                                   PythonTracebackLexer)
 from pygments.token import Comment, Generic
+
 from sphinx import highlighting
-import re
 
+
+#-----------------------------------------------------------------------------
+# Global constants
 line_re = re.compile('.*?\n')
 
+#-----------------------------------------------------------------------------
+# Code begins - classes and functions
+
 class IPythonConsoleLexer(Lexer):
     """
     For IPython console output or doctests, such as:
 
-    Tracebacks are not currently supported.
-
     .. sourcecode:: ipython
 
       In [1]: a = 'foo'
@@ -24,7 +38,14 b' class IPythonConsoleLexer(Lexer):'
       foo
 
       In [4]: 1 / 0
+
+    Notes:
+
+      - Tracebacks are not currently supported.
+
+      - It assumes the default IPython prompts, not customized ones.
     """
+    
     name = 'IPython console session'
     aliases = ['ipython']
     mimetypes = ['text/x-ipython-console']
@@ -72,4 +93,6 b' class IPythonConsoleLexer(Lexer):'
                                       pylexer.get_tokens_unprocessed(curcode)):
                 yield item
 
+#-----------------------------------------------------------------------------
+# Register the extension as a valid pygments lexer
 highlighting.lexers['ipython'] = IPythonConsoleLexer()