- Cleanup [1786], which went in with unfinished stuff by accident.

- Revert [1785] and replace it by installing our own quitter in place of the
builtin (for all py versions).  This obviates the need for [1785] and gives
a cleaner exit.

- Fix ipdb to work with python 2.5, and update ipdb color schemes with
%colors.

- irunner improvements, mostly for use as a doctest runner.

IPython/Debugger.py

@@ -1,363 +1,315 b''
 # -*- coding: utf-8 -*-
 """
 Pdb debugger class.
 
 Modified from the standard pdb.Pdb class to avoid including readline, so that
 the command line completion of other programs which include this isn't
 damaged.
 
 In the future, this class will be expanded with improvements over the standard
 pdb.
 
 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 1786 2006-09-27 05:47:28Z fperez $"""
+$Id: Debugger.py 1787 2006-09-27 06:56:29Z fperez $"""
 
 #*****************************************************************************
 #
 # Since this file is essentially a modified copy of the pdb module which is
 # part of the standard Python distribution, I assume that the proper procedure
 # is to maintain its copyright as belonging to the Python Software Foundation
 # (in addition to my own, for all new code).
 #
 #       Copyright (C) 2001 Python Software Foundation, www.python.org
 #       Copyright (C) 2005-2006 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #
 #*****************************************************************************
 
 from IPython import Release
 __author__  = '%s <%s>' % Release.authors['Fernando']
 __license__ = 'Python'
 
 import bdb
 import cmd
 import linecache
 import os
 import pdb
 import sys
 
 from IPython import PyColorize, ColorANSI
 from IPython.genutils import Term
 from IPython.excolors import ExceptionColors
 
 def _file_lines(fname):
     """Return the contents of a named file as a list of lines.
 
     This function never raises an IOError exception: if the file can't be
     read, it simply returns an empty list."""
 
     try:
         outfile = open(fname)
     except IOError:
         return []
     else:
         out = outfile.readlines()
         outfile.close()
         return out
 
 class Pdb(pdb.Pdb):
     """Modified Pdb class, does not load readline."""
 
-    # Ugly hack: we can't call the parent constructor, because it binds
-    # readline and breaks tab-completion.  This means we have to COPY the
-    # constructor here, and that requires tracking various python versions.
-
-    if sys.version[:3] == '2.5':
+    if sys.version[:3] >= '2.5':
         def __init__(self,color_scheme='NoColor',completekey=None,
                      stdin=None, stdout=None):
-            bdb.Bdb.__init__(self)
-
-            # IPython change
-            # don't load readline
-            cmd.Cmd.__init__(self,completekey,stdin,stdout)
-            #cmd.Cmd.__init__(self, completekey, stdin, stdout)
-            # /IPython change
-
-            if stdout:
-                self.use_rawinput = 0
-            self.prompt = '(Pdb) '
-            self.aliases = {}
-            self.mainpyfile = ''
-            self._wait_for_mainpyfile = 0
-            # Try to load readline if it exists
-            try:
-                import readline
-            except ImportError:
-                pass
-
-            # Read $HOME/.pdbrc and ./.pdbrc
-            self.rcLines = []
-            if 'HOME' in os.environ:
-                envHome = os.environ['HOME']
-                try:
-                    rcFile = open(os.path.join(envHome, ".pdbrc"))
-                except IOError:
-                    pass
-                else:
-                    for line in rcFile.readlines():
-                        self.rcLines.append(line)
-                    rcFile.close()
-            try:
-                rcFile = open(".pdbrc")
-            except IOError:
-                pass
-            else:
-                for line in rcFile.readlines():
-                    self.rcLines.append(line)
-                rcFile.close()
-
-            self.commands = {} # associates a command list to breakpoint numbers
-            self.commands_doprompt = {} # for each bp num, tells if the prompt must be disp. after execing the cmd list
-            self.commands_silent = {} # for each bp num, tells if the stack trace must be disp. after execing the cmd list
-            self.commands_defining = False # True while in the process of defining a command list
-            self.commands_bnum = None # The breakpoint number for which we are defining a list
-
 
+            # Parent constructor:
+            pdb.Pdb.__init__(self,completekey,stdin,stdout)
+            
             # IPython changes...
-
             self.prompt = 'ipdb> ' # The default prompt is '(Pdb)'
             self.aliases = {}
 
             # 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()
 
             # shorthands 
             C = ColorANSI.TermColors
             cst = self.color_scheme_table
 
             cst['NoColor'].colors.breakpoint_enabled = C.NoColor
             cst['NoColor'].colors.breakpoint_disabled = C.NoColor
 
             cst['Linux'].colors.breakpoint_enabled = C.LightRed
             cst['Linux'].colors.breakpoint_disabled = C.Red
 
             cst['LightBG'].colors.breakpoint_enabled = C.LightRed
             cst['LightBG'].colors.breakpoint_disabled = C.Red
 
             self.set_colors(color_scheme)
-            
 
     else:
-    
+        # Ugly hack: for Python 2.3-2.4, we can't call the parent constructor,
+        # because it binds readline and breaks tab-completion.  This means we
+        # have to COPY the constructor here.
         def __init__(self,color_scheme='NoColor'):
             bdb.Bdb.__init__(self)
             cmd.Cmd.__init__(self,completekey=None) # don't load readline
             self.prompt = 'ipdb> ' # The default prompt is '(Pdb)'
             self.aliases = {}
 
             # These two lines are part of the py2.4 constructor, let's put them
             # unconditionally here as they won't cause any problems in 2.3.
             self.mainpyfile = ''
             self._wait_for_mainpyfile = 0
 
             # Read $HOME/.pdbrc and ./.pdbrc
             try:
                 self.rcLines = _file_lines(os.path.join(os.environ['HOME'],
                                                         ".pdbrc"))
             except KeyError:
                 self.rcLines = []
             self.rcLines.extend(_file_lines(".pdbrc"))
 
             # 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()
 
             # shorthands 
             C = ColorANSI.TermColors
             cst = self.color_scheme_table
 
             cst['NoColor'].colors.breakpoint_enabled = C.NoColor
             cst['NoColor'].colors.breakpoint_disabled = C.NoColor
 
             cst['Linux'].colors.breakpoint_enabled = C.LightRed
             cst['Linux'].colors.breakpoint_disabled = C.Red
 
             cst['LightBG'].colors.breakpoint_enabled = C.LightRed
             cst['LightBG'].colors.breakpoint_disabled = C.Red
 
             self.set_colors(color_scheme)
         
     def set_colors(self, scheme):
         """Shorthand access to the color table scheme selector method."""
         self.color_scheme_table.set_active_scheme(scheme)
 
     def interaction(self, frame, traceback):
         __IPYTHON__.set_completer_frame(frame)
         pdb.Pdb.interaction(self, frame, traceback)
 
     def do_up(self, arg):
         pdb.Pdb.do_up(self, arg)
         __IPYTHON__.set_completer_frame(self.curframe)
     do_u = do_up
 
     def do_down(self, arg):
         pdb.Pdb.do_down(self, arg)
         __IPYTHON__.set_completer_frame(self.curframe)
     do_d = do_down
 
     def postloop(self):
         __IPYTHON__.set_completer_frame(None)
 
     def print_stack_trace(self):
         try:
             for frame_lineno in self.stack:
                 self.print_stack_entry(frame_lineno, context = 5)
         except KeyboardInterrupt:
             pass
 
     def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
                           context = 3):
         frame, lineno = frame_lineno
         print >>Term.cout, self.format_stack_entry(frame_lineno, '', context)
 
     def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
         import linecache, repr
         
         ret = []
         
         Colors = self.color_scheme_table.active_colors
         ColorsNormal = Colors.Normal
         tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
         tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
         tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
         tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
                                             ColorsNormal)
         
         frame, lineno = frame_lineno
         
         return_value = ''
         if '__return__' in frame.f_locals:
             rv = frame.f_locals['__return__']
             #return_value += '->'
             return_value += repr.repr(rv) + '\n'
         ret.append(return_value)
 
         #s = filename + '(' + `lineno` + ')'
         filename = self.canonic(frame.f_code.co_filename)
         link = tpl_link % filename
         
         if frame.f_code.co_name:
             func = frame.f_code.co_name
         else:
             func = "<lambda>"
             
         call = ''
         if func != '?':         
             if '__args__' in frame.f_locals:
                 args = repr.repr(frame.f_locals['__args__'])
             else:
                 args = '()'
             call = tpl_call % (func, args)
 
         # The level info should be generated in the same format pdb uses, to
         # avoid breaking the pdbtrack functionality of python-mode in *emacs.
         ret.append('> %s(%s)%s\n' % (link,lineno,call))
             
         start = lineno - 1 - context//2
         lines = linecache.getlines(filename)
         start = max(start, 0)
         start = min(start, len(lines) - context)
         lines = lines[start : start + context]
             
         for i,line in enumerate(lines):
             show_arrow = (start + 1 + i == lineno)
             ret.append(self.__format_line(tpl_line_em, filename,
                                           start + 1 + i, line,
                                           arrow = show_arrow) )
 
         return ''.join(ret)
 
     def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
         bp_mark = ""
         bp_mark_color = ""
 
         bp = None
         if lineno in self.get_file_breaks(filename):
             bps = self.get_breaks(filename, lineno)
             bp = bps[-1]
         
         if bp:
             Colors = self.color_scheme_table.active_colors
             bp_mark = str(bp.number)
             bp_mark_color = Colors.breakpoint_enabled
             if not bp.enabled:
                 bp_mark_color = Colors.breakpoint_disabled
 
         numbers_width = 7
         if arrow:
             # This is the line with the error
             pad = numbers_width - len(str(lineno)) - len(bp_mark)
             if pad >= 3:
                 marker = '-'*(pad-3) + '-> '
             elif pad == 2:
                  marker = '> '
             elif pad == 1:
                  marker = '>'
             else:
                  marker = ''
             num = '%s%s' % (marker, str(lineno))
             line = tpl_line % (bp_mark_color + bp_mark, num, line)
         else:
             num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
             line = tpl_line % (bp_mark_color + bp_mark, num, line)
             
         return line
 
     def do_list(self, arg):
         self.lastcmd = 'list'
         last = None
         if arg:
             try:
                 x = eval(arg, {}, {})
                 if type(x) == type(()):
                     first, last = x
                     first = int(first)
                     last = int(last)
                     if last < first:
                         # Assume it's a count
                         last = first + last
                 else:
                     first = max(1, int(x) - 5)
             except:
                 print '*** Error in argument:', `arg`
                 return
         elif self.lineno is None:
             first = max(1, self.curframe.f_lineno - 5)
         else:
             first = self.lineno + 1
         if last is None:
             last = first + 10
         filename = self.curframe.f_code.co_filename
         try:
             Colors = self.color_scheme_table.active_colors
             ColorsNormal = Colors.Normal
             tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
             tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
             src = []
             for lineno in range(first, last+1):
                 line = linecache.getline(filename, lineno)
                 if not line:
                     break
 
                 if lineno == self.curframe.f_lineno:
                     line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
                 else:
                     line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
 
                 src.append(line)
                 self.lineno = lineno
 
             print >>Term.cout, ''.join(src)
 
         except KeyboardInterrupt:
             pass
 
     do_l = do_list

IPython/Magic.py

@@ -1,2990 +1,2991 b''
 # -*- coding: utf-8 -*-
 """Magic functions for InteractiveShell.
 
-$Id: Magic.py 1386 2006-07-08 09:32:30Z vivainio $"""
+$Id: Magic.py 1787 2006-09-27 06:56:29Z fperez $"""
 
 #*****************************************************************************
 #       Copyright (C) 2001 Janko Hauser <[e-mail]> and
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 #****************************************************************************
 # 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
 import inspect
 import os
 import pdb
 import pydoc
 import shlex
 import sys
 import re
 import tempfile
 import time
 import cPickle as pickle
 import textwrap
 from cStringIO import StringIO
 from getopt import getopt,GetoptError
 from pprint import pprint, pformat
 
 # profile isn't bundled by default in Debian for license reasons
 try:
     import profile,pstats
 except ImportError:
     profile = pstats = None
 
 # Homebrewed
 import IPython
 from IPython import Debugger, OInspect, wildcard
 from IPython.FakeModule import FakeModule
 from IPython.Itpl import Itpl, itpl, printpl,itplns
 from IPython.PyColorize import Parser
 from IPython.ipstruct import Struct
 from IPython.macro import Macro
 from IPython.genutils import *
 from IPython import platutils
 
 #***************************************************************************
 # Utility functions
 def on_off(tag):
     """Return an ON/OFF string for a 1/0 input. Simple utility function."""
     return ['OFF','ON'][tag]
 
 class Bunch: pass
 
 #***************************************************************************
 # Main class implementing Magic functionality
 class Magic:
     """Magic functions for InteractiveShell.
 
     Shell functions which can be reached as %function_name. All magic
     functions should accept a string, which they can parse for their own
     needs. This can make some functions easier to type, eg `%cd ../`
     vs. `%cd("../")`
 
     ALL definitions MUST begin with the prefix magic_. The user won't need it
     at the command line, but it is is needed in the definition. """
 
     # class globals
     auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
                    'Automagic is ON, % prefix NOT needed for magic functions.']
 
     #......................................................................
     # some utility functions
 
     def __init__(self,shell):
         
         self.options_table = {}
         if profile is None:
             self.magic_prun = self.profile_missing_notice
         self.shell = shell
 
         # namespace for holding state we may need
         self._magic_state = Bunch()
 
     def profile_missing_notice(self, *args, **kwargs):
         error("""\
 The profile module could not be found.  If you are a Debian user,
 it has been removed from the standard Debian package because of its non-free
 license. To use profiling, please install"python2.3-profiler" from non-free.""")
 
     def default_option(self,fn,optstr):
         """Make an entry in the options_table for fn, with value optstr"""
 
         if fn not in self.lsmagic():
             error("%s is not a magic function" % fn)
         self.options_table[fn] = optstr
 
     def lsmagic(self):
         """Return a list of currently available magic functions.
 
         Gives a list of the bare names after mangling (['ls','cd', ...], not
         ['magic_ls','magic_cd',...]"""
 
         # FIXME. This needs a cleanup, in the way the magics list is built.
         
         # magics in class definition
         class_magic = lambda fn: fn.startswith('magic_') and \
                       callable(Magic.__dict__[fn])
         # in instance namespace (run-time user additions)
         inst_magic =  lambda fn: fn.startswith('magic_') and \
                      callable(self.__dict__[fn])
         # and bound magics by user (so they can access self):
         inst_bound_magic =  lambda fn: fn.startswith('magic_') and \
                            callable(self.__class__.__dict__[fn])
         magics = filter(class_magic,Magic.__dict__.keys()) + \
                  filter(inst_magic,self.__dict__.keys()) + \
                  filter(inst_bound_magic,self.__class__.__dict__.keys())
         out = []
         for fn in magics:
             out.append(fn.replace('magic_','',1))
         out.sort()
         return out
     
     def extract_input_slices(self,slices,raw=False):
         """Return as a string a set of input history slices.
 
         Inputs:
 
           - slices: the set of slices is given as a list of strings (like
           ['1','4:8','9'], since this function is for use by magic functions
           which get their arguments as strings.
 
         Optional inputs:
 
           - raw(False): by default, the processed input is used.  If this is
           true, the raw input history is used instead.
 
         Note that slices can be called with two notations:
 
         N:M -> standard python form, means including items N...(M-1).
 
         N-M -> include items N..M (closed endpoint)."""
 
         if raw:
             hist = self.shell.input_hist_raw
         else:
             hist = self.shell.input_hist
 
         cmds = []
         for chunk in slices:
             if ':' in chunk:
                 ini,fin = map(int,chunk.split(':'))
             elif '-' in chunk:
                 ini,fin = map(int,chunk.split('-'))
                 fin += 1
             else:
                 ini = int(chunk)
                 fin = ini+1
             cmds.append(hist[ini:fin])
         return cmds
         
     def _ofind(self,oname):
         """Find an object in the available namespaces.
 
         self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
 
         Has special code to detect magic functions.
         """
         
         oname = oname.strip()
 
         # Namespaces to search in:
         user_ns        = self.shell.user_ns
         internal_ns    = self.shell.internal_ns
         builtin_ns     = __builtin__.__dict__
         alias_ns       = self.shell.alias_table
 
         # Put them in a list. The order is important so that we find things in
         # the same order that Python finds them.
         namespaces = [ ('Interactive',user_ns),
                        ('IPython internal',internal_ns),
                        ('Python builtin',builtin_ns),
                        ('Alias',alias_ns),
                        ]
 
         # initialize results to 'null'
         found = 0; obj = None;  ospace = None;  ds = None;
         ismagic = 0; isalias = 0; parent = None
 
         # Look for the given name by splitting it in parts.  If the head is
         # found, then we look for all the remaining parts as members, and only
         # declare success if we can find them all.
         oname_parts = oname.split('.')
         oname_head, oname_rest = oname_parts[0],oname_parts[1:]
         for nsname,ns in namespaces:
             try:
                 obj = ns[oname_head]
             except KeyError:
                 continue
             else:
                 for part in oname_rest:
                     try:
                         parent = obj
                         obj = getattr(obj,part)
                     except:
                         # Blanket except b/c some badly implemented objects
                         # allow __getattr__ to raise exceptions other than
                         # AttributeError, which then crashes IPython.
                         break
                 else:
                     # If we finish the for loop (no break), we got all members
                     found = 1
                     ospace = nsname
                     if ns == alias_ns:
                         isalias = 1
                     break  # namespace loop
 
         # Try to see if it's magic
         if not found:
             if oname.startswith(self.shell.ESC_MAGIC):
                 oname = oname[1:]
             obj = getattr(self,'magic_'+oname,None)
             if obj is not None:
                 found = 1
                 ospace = 'IPython internal'
                 ismagic = 1
 
         # Last try: special-case some literals like '', [], {}, etc:
         if not found and oname_head in ["''",'""','[]','{}','()']:
             obj = eval(oname_head)
             found = 1
             ospace = 'Interactive'
             
         return {'found':found, 'obj':obj, 'namespace':ospace,
                 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
     
     def arg_err(self,func):
         """Print docstring if incorrect arguments were passed"""
         print 'Error in arguments:'
         print OInspect.getdoc(func)
 
     def format_latex(self,strng):
         """Format a string for latex inclusion."""
 
         # Characters that need to be escaped for latex:
         escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
         # Magic command names as headers:
         cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
                                  re.MULTILINE)
         # Magic commands 
         cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
                             re.MULTILINE)
         # Paragraph continue
         par_re = re.compile(r'\\$',re.MULTILINE)
 
         # The "\n" symbol
         newline_re = re.compile(r'\\n')
 
         # Now build the string for output:
         #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
         strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
                                 strng)
         strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
         strng = par_re.sub(r'\\\\',strng)
         strng = escape_re.sub(r'\\\1',strng)
         strng = newline_re.sub(r'\\textbackslash{}n',strng)
         return strng
 
     def format_screen(self,strng):
         """Format a string for screen printing.
 
         This removes some latex-type format codes."""
         # Paragraph continue
         par_re = re.compile(r'\\$',re.MULTILINE)
         strng = par_re.sub('',strng)
         return strng
 
     def parse_options(self,arg_str,opt_str,*long_opts,**kw):
         """Parse options passed to an argument string.
 
         The interface is similar to that of getopt(), but it returns back a
         Struct with the options as keys and the stripped argument string still
         as a string.
 
         arg_str is quoted as a true sys.argv vector by using shlex.split.
         This allows us to easily expand variables, glob files, quote
         arguments, etc.
 
         Options:
           -mode: default 'string'. If given as 'list', the argument string is
           returned as a list (split on whitespace) instead of a string.
 
           -list_all: put all option values in lists. Normally only options
           appearing more than once are put in a list."""
 
         # inject default options at the beginning of the input line
         caller = sys._getframe(1).f_code.co_name.replace('magic_','')
         arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
         
         mode = kw.get('mode','string')
         if mode not in ['string','list']:
             raise ValueError,'incorrect mode given: %s' % mode
         # Get options
         list_all = kw.get('list_all',0)
 
         # Check if we have more than one argument to warrant extra processing:
         odict = {}  # Dictionary with options
         args = arg_str.split()
         if len(args) >= 1:
             # If the list of inputs only has 0 or 1 thing in it, there's no
             # need to look for options
             argv = shlex.split(arg_str)
             # Do regular option processing
             try:
                 opts,args = getopt(argv,opt_str,*long_opts)
             except GetoptError,e:
                 raise GetoptError('%s ( allowed: "%s" %s)' % (e.msg,opt_str, 
                                         " ".join(long_opts)))
             for o,a in opts:
                 if o.startswith('--'):
                     o = o[2:]
                 else:
                     o = o[1:]
                 try:
                     odict[o].append(a)
                 except AttributeError:
                     odict[o] = [odict[o],a]
                 except KeyError:
                     if list_all:
                         odict[o] = [a]
                     else:
                         odict[o] = a
 
         # Prepare opts,args for return
         opts = Struct(odict)
         if mode == 'string':
             args = ' '.join(args)
 
         return opts,args
     
     #......................................................................
     # And now the actual magic functions
 
     # Functions for IPython shell work (vars,funcs, config, etc)
     def magic_lsmagic(self, parameter_s = ''):
         """List currently available magic functions."""
         mesc = self.shell.ESC_MAGIC
         print 'Available magic functions:\n'+mesc+\
               ('  '+mesc).join(self.lsmagic())
         print '\n' + Magic.auto_status[self.shell.rc.automagic]
         return None
         
     def magic_magic(self, parameter_s = ''):
         """Print information about the magic function system."""
 
         mode = ''
         try:
             if parameter_s.split()[0] == '-latex':
                 mode = 'latex'
             if parameter_s.split()[0] == '-brief':
                 mode = 'brief'
         except:
             pass
 
         magic_docs = []
         for fname in self.lsmagic():
             mname = 'magic_' + fname
             for space in (Magic,self,self.__class__):
                 try:
                     fn = space.__dict__[mname]
                 except KeyError:
                     pass
                 else:
                     break
             if mode == 'brief':
                 # only first line
                 fndoc = fn.__doc__.split('\n',1)[0]
             else:
                 fndoc = fn.__doc__
                 
             magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
                                                 fname,fndoc))
         magic_docs = ''.join(magic_docs)
 
         if mode == 'latex':
             print self.format_latex(magic_docs)
             return
         else:
             magic_docs = self.format_screen(magic_docs)
         if mode == 'brief':
             return magic_docs
         
         outmsg = """
 IPython's 'magic' functions
 ===========================
 
 The magic function system provides a series of functions which allow you to
 control the behavior of IPython itself, plus a lot of system-type
 features. All these functions are prefixed with a % character, but parameters
 are given without parentheses or quotes.
 
 NOTE: If you have 'automagic' enabled (via the command line option or with the
 %automagic function), you don't need to type in the % explicitly.  By default,
 IPython ships with automagic on, so you should only rarely need the % escape.
 
 Example: typing '%cd mydir' (without the quotes) changes you working directory
 to 'mydir', if it exists.
 
 You can define your own magic functions to extend the system. See the supplied
 ipythonrc and example-magic.py files for details (in your ipython
 configuration directory, typically $HOME/.ipython/).
 
 You can also define your own aliased names for magic functions. In your
 ipythonrc file, placing a line like:
 
   execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
 
 will define %pf as a new name for %profile.
 
 You can also call magics in code using the ipmagic() function, which IPython
 automatically adds to the builtin namespace.  Type 'ipmagic?' for details.
 
 For a list of the available magic functions, use %lsmagic. For a description
 of any of them, type %magic_name?, e.g. '%cd?'.
 
 Currently the magic system has the following functions:\n"""
 
         mesc = self.shell.ESC_MAGIC
         outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
                   "\n\n%s%s\n\n%s" % (outmsg,
                                      magic_docs,mesc,mesc,
                                      ('  '+mesc).join(self.lsmagic()),
                                      Magic.auto_status[self.shell.rc.automagic] ) )
 
         page(outmsg,screen_lines=self.shell.rc.screen_length)
   
     def magic_automagic(self, parameter_s = ''):
         """Make magic functions callable without having to type the initial %.
         
         Toggles on/off (when off, you must call it as %automagic, of
         course). 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."""
 
         rc = self.shell.rc
         rc.automagic = not rc.automagic
         print '\n' + Magic.auto_status[rc.automagic]
 
     def magic_autocall(self, parameter_s = ''):
         """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)."""
         
         rc = self.shell.rc
 
         if parameter_s:
             arg = int(parameter_s)
         else:
             arg = 'toggle'
 
         if not arg in (0,1,2,'toggle'):
             error('Valid modes: (0->Off, 1->Smart, 2->Full')
             return
 
         if arg in (0,1,2):
             rc.autocall = arg
         else: # toggle
             if rc.autocall:
                 self._magic_state.autocall_save = rc.autocall
                 rc.autocall = 0
             else:
                 try:
                     rc.autocall = self._magic_state.autocall_save
                 except AttributeError:
                     rc.autocall = self._magic_state.autocall_save = 1
                 
         print "Automatic calling is:",['OFF','Smart','Full'][rc.autocall]
 
     def magic_autoindent(self, parameter_s = ''):
         """Toggle autoindent on/off (if available)."""
 
         self.shell.set_autoindent()
         print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
 
     def magic_system_verbose(self, parameter_s = ''):
         """Toggle verbose printing of system calls on/off."""
 
         self.shell.rc_set_toggle('system_verbose')
         print "System verbose printing is:",\
               ['OFF','ON'][self.shell.rc.system_verbose]
 
     def magic_history(self, parameter_s = ''):
         """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.
 
           -r: print the 'raw' history.  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 unfiltered history
           instead of the filtered version: '%cd /' will be seen as '%cd /'
           instead of '_ip.magic("%cd /")'.
         """
 
         shell = self.shell
         if not shell.outputcache.do_full_cache:
             print 'This feature is only available if numbered prompts are in use.'
             return
         opts,args = self.parse_options(parameter_s,'nr',mode='list')
 
         if opts.has_key('r'):
             input_hist = shell.input_hist_raw
         else:
             input_hist = shell.input_hist
         
         default_length = 40
         if len(args) == 0:
             final = len(input_hist)
             init = max(1,final-default_length)
         elif len(args) == 1:
             final = len(input_hist)
             init = max(1,final-int(args[0]))
         elif len(args) == 2:
             init,final = map(int,args)
         else:
             warn('%hist takes 0, 1 or 2 arguments separated by spaces.')
             print self.magic_hist.__doc__
             return
         width = len(str(final))
         line_sep = ['','\n']
         print_nums = not opts.has_key('n')
         for in_num in range(init,final):
             inline = input_hist[in_num]
             multiline = int(inline.count('\n') > 1)
             if print_nums:
                 print '%s:%s' % (str(in_num).ljust(width),line_sep[multiline]),
             print inline,
 
     def magic_hist(self, parameter_s=''):
         """Alternate name for %history."""
         return self.magic_history(parameter_s)
 
     def magic_p(self, parameter_s=''):
         """Just a short alias for Python's 'print'."""
         exec 'print ' + parameter_s in self.shell.user_ns
 
     def magic_r(self, parameter_s=''):
         """Repeat previous input.
 
         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.
         """
 
         start = parameter_s.strip()
         esc_magic = self.shell.ESC_MAGIC
         # Identify magic commands even if automagic is on (which means
         # the in-memory version is different from that typed by the user).
         if self.shell.rc.automagic:
             start_magic = esc_magic+start
         else:
             start_magic = start
         # Look through the input history in reverse
         for n in range(len(self.shell.input_hist)-2,0,-1):
             input = self.shell.input_hist[n]
             # skip plain 'r' lines so we don't recurse to infinity
             if input != '_ip.magic("r")\n' and \
                    (input.startswith(start) or input.startswith(start_magic)):
                 #print 'match',`input`  # dbg
                 print 'Executing:',input,
                 self.shell.runlines(input)
                 return
         print 'No previous input matching `%s` found.' % start
 
     def magic_page(self, parameter_s=''):
         """Pretty print the object and display it through a pager.
         
         If no parameter is given, use _ (last output)."""
         # After a function contributed by Olivier Aubert, slightly modified.
 
         oname = parameter_s and parameter_s or '_' 
         info = self._ofind(oname)
         if info['found']:
             page(pformat(info['obj']))
         else:
             print 'Object `%s` not found' % oname
 
     def magic_profile(self, parameter_s=''):
         """Print your currently active IPyhton profile."""
         if self.shell.rc.profile:
             printpl('Current IPython profile: $self.shell.rc.profile.')
         else:
             print 'No profile active.'
         
     def _inspect(self,meth,oname,**kw):
         """Generic interface to the inspector system.
 
         This function is meant to be called by pdef, pdoc & friends."""
         
         oname = oname.strip()
         info = Struct(self._ofind(oname))
         
         if info.found:
             # Get the docstring of the class property if it exists.
             path = oname.split('.')
             root = '.'.join(path[:-1])
             if info.parent is not None:
                 try:
                     target = getattr(info.parent, '__class__') 
                     # The object belongs to a class instance. 
                     try: 
                         target = getattr(target, path[-1])
                         # The class defines the object. 
                         if isinstance(target, property):
                             oname = root + '.__class__.' + path[-1]
                             info = Struct(self._ofind(oname))
                     except AttributeError: pass
                 except AttributeError: pass
                         
             pmethod = getattr(self.shell.inspector,meth)
             formatter = info.ismagic and self.format_screen or None
             if meth == 'pdoc':
                 pmethod(info.obj,oname,formatter)
             elif meth == 'pinfo':
                 pmethod(info.obj,oname,formatter,info,**kw)
             else:
                 pmethod(info.obj,oname)
         else:
             print 'Object `%s` not found.' % oname
             return 'not found'  # so callers can take other action
         
     def magic_pdef(self, parameter_s=''):
         """Print the definition header for any callable object.
 
         If the object is a class, print the constructor information."""
         self._inspect('pdef',parameter_s)
         
     def magic_pdoc(self, parameter_s=''):
         """Print the docstring for an object.
 
         If the given object is a class, it will print both the class and the
         constructor docstrings."""
         self._inspect('pdoc',parameter_s)
 
     def magic_psource(self, parameter_s=''):
         """Print (or run through pager) the source code for an object."""
         self._inspect('psource',parameter_s)
 
     def magic_pfile(self, parameter_s=''):
         """Print (or run through pager) the file where an object is defined.
 
         The file opens at the line where the object definition begins. IPython
         will honor the environment variable PAGER if set, and otherwise will
         do its best to print the file in a convenient form.
 
         If the given argument is not an object currently defined, IPython will
         try to interpret it as a filename (automatically adding a .py extension
         if needed). You can thus use %pfile as a syntax highlighting code
         viewer."""
 
         # first interpret argument as an object name
         out = self._inspect('pfile',parameter_s)
         # if not, try the input as a filename
         if out == 'not found':
             try:
                 filename = get_py_filename(parameter_s)
             except IOError,msg:
                 print msg
                 return
             page(self.shell.inspector.format(file(filename).read()))
             
     def magic_pinfo(self, parameter_s=''):
         """Provide detailed information about an object.
 
         '%pinfo object' is just a synonym for object? or ?object."""
 
         #print 'pinfo par: <%s>' % parameter_s  # dbg
 
         # detail_level: 0 -> obj? , 1 -> obj??
         detail_level = 0
         # We need to detect if we got called as 'pinfo pinfo foo', which can
         # happen if the user types 'pinfo foo?' at the cmd line.
         pinfo,qmark1,oname,qmark2 = \
                re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
         if pinfo or qmark1 or qmark2:
             detail_level = 1
         if "*" in oname:
             self.magic_psearch(oname)
         else:
             self._inspect('pinfo',oname,detail_level=detail_level)
 
     def magic_psearch(self, parameter_s=''):
         """Search for object in namespaces by wildcard.
 
         %psearch [options] PATTERN [OBJECT TYPE]
 
         Note: ? can be used as a synonym for %psearch, at the beginning or at
         the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the
         rest of the command line must be unchanged (options come first), so
         for example the following forms are equivalent
 
         %psearch -i a* function
         -i a* function?
         ?-i a* function
 
         Arguments:
         
           PATTERN
 
           where PATTERN is a string containing * as a wildcard similar to its
           use in a shell.  The pattern is matched in all namespaces on the
           search path. By default objects starting with a single _ are not
           matched, many IPython generated objects have a single
           underscore. The default is case insensitive matching. Matching is
           also done on the attributes of objects and not only on the objects
           in a module.
 
           [OBJECT TYPE]
 
           Is the name of a python type from the types module. The name is
           given in lowercase without the ending type, ex. StringType is
           written string. By adding a type here only objects matching the
           given type are matched. Using all here makes the pattern match all
           types (this is the default).
 
         Options:
 
           -a: makes the pattern match even objects whose names start with a
           single underscore.  These names are normally 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"""
 
         # default namespaces to be searched
         def_search = ['user','builtin']
 
         # Process options/args
         opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
         opt = opts.get
         shell = self.shell
         psearch = shell.inspector.psearch
         
         # select case options
         if opts.has_key('i'):
             ignore_case = True
         elif opts.has_key('c'):
             ignore_case = False
         else:
             ignore_case = not shell.rc.wildcards_case_sensitive
 
         # Build list of namespaces to search from user options
         def_search.extend(opt('s',[]))
         ns_exclude = ns_exclude=opt('e',[])
         ns_search = [nm for nm in def_search if nm not in ns_exclude]
         
         # Call the actual search
         try:
             psearch(args,shell.ns_table,ns_search,
                     show_all=opt('a'),ignore_case=ignore_case)
         except:
             shell.showtraceback()
 
     def magic_who_ls(self, parameter_s=''):
         """Return a sorted list of all interactive variables.
 
         If arguments are given, only variables of types matching these
         arguments are returned."""
 
         user_ns = self.shell.user_ns
         internal_ns = self.shell.internal_ns
         user_config_ns = self.shell.user_config_ns
         out = []
         typelist = parameter_s.split()
 
         for i in user_ns:
             if not (i.startswith('_') or i.startswith('_i')) \
                    and not (i in internal_ns or i in user_config_ns):
                 if typelist:
                     if type(user_ns[i]).__name__ in typelist:
                         out.append(i)
                 else:
                     out.append(i)
         out.sort()
         return out
         
     def magic_who(self, parameter_s=''):
         """Print all interactive variables, with some minimal formatting.
 
         If any arguments are given, only variables whose type matches one of
         these are printed.  For example:
 
           %who function str
 
         will only list functions and strings, excluding all other types of
         variables.  To find the proper type names, simply use type(var) at a
         command line to see how python prints type names.  For example:
 
           In [1]: type('hello')\\
           Out[1]: <type 'str'>
 
         indicates that the type name for strings is 'str'.
 
         %who always excludes executed names loaded through your configuration
         file and things which are internal to IPython.
 
         This is deliberate, as typically you may load many modules and the
         purpose of %who is to show you only what you've manually defined."""
 
         varlist = self.magic_who_ls(parameter_s)
         if not varlist:
             print 'Interactive namespace is empty.'
             return
 
         # if we have variables, move on...
 
         # stupid flushing problem: when prompts have no separators, stdout is
         # getting lost. I'm starting to think this is a python bug. I'm having
         # to force a flush with a print because even a sys.stdout.flush
         # doesn't seem to do anything!
 
         count = 0
         for i in varlist:
             print i+'\t',
             count += 1
             if count > 8:
                 count = 0
                 print
             sys.stdout.flush()  # FIXME. Why the hell isn't this flushing???
             
         print # well, this does force a flush at the expense of an extra \n
 
     def magic_whos(self, parameter_s=''):
         """Like %who, but gives some extra information about each variable.
 
         The same type filtering of %who can be applied here.
 
         For all variables, the type is printed. Additionally it prints:
         
           - For {},[],(): their length.
 
           - For 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."""
         
         varnames = self.magic_who_ls(parameter_s)
         if not varnames:
             print 'Interactive namespace is empty.'
             return
 
         # if we have variables, move on...
 
         # for these types, show len() instead of data:
         seq_types = [types.DictType,types.ListType,types.TupleType]
 
         # for Numeric arrays, display summary info
         try:
             import Numeric
         except ImportError:
             array_type = None
         else:
             array_type = Numeric.ArrayType.__name__
         
         # Find all variable names and types so we can figure out column sizes
         get_vars = lambda i: self.shell.user_ns[i]
         type_name = lambda v: type(v).__name__
         varlist = map(get_vars,varnames)
 
         typelist = []
         for vv in varlist:
             tt = type_name(vv)
             if tt=='instance':
                 typelist.append(str(vv.__class__))
             else:
                 typelist.append(tt)
 
         # column labels and # of spaces as separator
         varlabel = 'Variable'
         typelabel = 'Type'
         datalabel = 'Data/Info'
         colsep = 3
         # variable format strings
         vformat    = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
         vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
         aformat    = "%s: %s elems, type `%s`, %s bytes"
         # find the size of the columns to format the output nicely
         varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
         typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
         # table header
         print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
               ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
         # and the table itself
         kb = 1024
         Mb = 1048576  # kb**2
         for vname,var,vtype in zip(varnames,varlist,typelist):
             print itpl(vformat),
             if vtype in seq_types:
                 print len(var)
             elif vtype==array_type:
                 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
                 vsize  = Numeric.size(var)
                 vbytes = vsize*var.itemsize()
                 if vbytes < 100000:
                     print aformat % (vshape,vsize,var.typecode(),vbytes)
                 else:
                     print aformat % (vshape,vsize,var.typecode(),vbytes),
                     if vbytes < Mb:
                         print '(%s kb)' % (vbytes/kb,)
                     else:
                         print '(%s Mb)' % (vbytes/Mb,)
             else:
                 vstr = str(var).replace('\n','\\n')
                 if len(vstr) < 50:
                     print vstr
                 else:
                     printpl(vfmt_short)
                 
     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."""
 
         ans = self.shell.ask_yes_no(
           "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
         if not ans:
             print 'Nothing done.'
             return
         user_ns = self.shell.user_ns
         for i in self.magic_who_ls():
             del(user_ns[i])
 
     def magic_config(self,parameter_s=''):
         """Show IPython's internal configuration."""
         
         page('Current configuration structure:\n'+
              pformat(self.shell.rc.dict()))
 
     def magic_logstart(self,parameter_s=''):
         """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)."""
         
         opts,par = self.parse_options(parameter_s,'ort')
         log_output = 'o' in opts
         log_raw_input = 'r' in opts
         timestamp = 't' in opts
 
         rc = self.shell.rc
         logger = self.shell.logger
 
         # if no args are given, the defaults set in the logger constructor by
         # ipytohn remain valid
         if par:
             try:
                 logfname,logmode = par.split()
             except:
                 logfname = par
                 logmode = 'backup'
         else:
             logfname = logger.logfname
             logmode = logger.logmode
         # put logfname into rc struct as if it had been called on the command
         # line, so it ends up saved in the log header Save it in case we need
         # to restore it...
         old_logfile = rc.opts.get('logfile','')  
         if logfname:
             logfname = os.path.expanduser(logfname)
         rc.opts.logfile = logfname
         loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
         try:
             started  = logger.logstart(logfname,loghead,logmode,
                                        log_output,timestamp,log_raw_input)
         except:
             rc.opts.logfile = old_logfile
             warn("Couldn't start log: %s" % sys.exc_info()[1])
         else:
             # log input history up to this point, optionally interleaving
             # output if requested
 
             if timestamp:
                 # disable timestamping for the previous history, since we've
                 # lost those already (no time machine here).
                 logger.timestamp = False
 
             if log_raw_input:
                 input_hist = self.shell.input_hist_raw
             else:
                 input_hist = self.shell.input_hist
                 
             if log_output:
                 log_write = logger.log_write
                 output_hist = self.shell.output_hist
                 for n in range(1,len(input_hist)-1):
                     log_write(input_hist[n].rstrip())
                     if n in output_hist:
                         log_write(repr(output_hist[n]),'output')
             else:
                 logger.log_write(input_hist[1:])
             if timestamp:
                 # re-enable timestamping
                 logger.timestamp = True
                 
             print ('Activating auto-logging. '
                    'Current session state plus future input saved.')
             logger.logstate()
 
     def magic_logoff(self,parameter_s=''):
         """Temporarily stop logging.
 
         You must have previously started logging."""
         self.shell.logger.switch_log(0)
         
     def magic_logon(self,parameter_s=''):
         """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."""
         
         self.shell.logger.switch_log(1)
     
     def magic_logstate(self,parameter_s=''):
         """Print the status of the logging system."""
 
         self.shell.logger.logstate()
         
     def magic_pdb(self, parameter_s=''):
         """Control the 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."""
 
         par = parameter_s.strip().lower()
 
         if par:
             try:
                 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
             except KeyError:
                 print ('Incorrect argument. Use on/1, off/0, '
                        'or nothing for a toggle.')
                 return
         else:
             # toggle
             new_pdb = not self.shell.InteractiveTB.call_pdb
 
         # set on the shell
         self.shell.call_pdb = new_pdb
         print 'Automatic pdb calling has been turned',on_off(new_pdb)
 
     def magic_prun(self, parameter_s ='',user_mode=1,
                    opts=None,arg_lst=None,prog_ns=None):
 
         """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.
 
         Since magic functions have a particular form of calling which prevents
         you from writing something like:\\
           In [1]: p = %prun -r print 4  # invalid!\\
         you must instead use IPython's automatic variables to assign this:\\
           In [1]: %prun -r print 4  \\
           Out[1]: <pstats.Stats instance at 0x8222cec>\\
           In [2]: stats = _
 
         If you really need to assign this value via an explicit function call,
         you can always tap directly into the true name of the magic function
         by using the _ip.magic function:\\
           In [3]: stats = _ip.magic('prun','-r print 4')
 
         You can type _ip.magic? for more details.
 
        -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() """
 
         opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
         # protect user quote marks
         parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
         
         if user_mode:  # regular user call
             opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
                                               list_all=1)
             namespace = self.shell.user_ns
         else:  # called to run a program by %run -p
             try:
                 filename = get_py_filename(arg_lst[0])
             except IOError,msg:
                 error(msg)
                 return
 
             arg_str = 'execfile(filename,prog_ns)'
             namespace = locals()
 
         opts.merge(opts_def)
         
         prof = profile.Profile()
         try:
             prof = prof.runctx(arg_str,namespace,namespace)
             sys_exit = ''
         except SystemExit:
             sys_exit = """*** SystemExit exception caught in code being profiled."""
 
         stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
 
         lims = opts.l
         if lims:
             lims = []  # rebuild lims with ints/floats/strings
             for lim in opts.l:
                 try:
                     lims.append(int(lim))
                 except ValueError:
                     try:
                         lims.append(float(lim))
                     except ValueError:
                         lims.append(lim)
                     
         # trap output
         sys_stdout = sys.stdout
         stdout_trap = StringIO()
         try:
             sys.stdout = stdout_trap
             stats.print_stats(*lims)
         finally:
             sys.stdout = sys_stdout
         output = stdout_trap.getvalue()
         output = output.rstrip()
 
         page(output,screen_lines=self.shell.rc.screen_length)
         print sys_exit,
 
         dump_file = opts.D[0]
         text_file = opts.T[0]
         if dump_file:
             prof.dump_stats(dump_file)
             print '\n*** Profile stats marshalled to file',\
                   `dump_file`+'.',sys_exit
         if text_file:
             file(text_file,'w').write(output)
             print '\n*** Profile printout saved to text file',\
                   `text_file`+'.',sys_exit
 
         if opts.has_key('r'):
             return stats
         else:
             return None
 
     def magic_run(self, parameter_s ='',runner=None):
         """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. 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."""
 
         # get arguments and set sys.argv for program to be run.
         opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
                                           mode='list',list_all=1)
 
         try:
             filename = get_py_filename(arg_lst[0])
         except IndexError:
             warn('you must provide at least a filename.')
             print '\n%run:\n',OInspect.getdoc(self.magic_run)
             return
         except IOError,msg:
             error(msg)
             return
 
         # Control the response to exit() calls made by the script being run
         exit_ignore = opts.has_key('e')
         
         # Make sure that the running script gets a proper sys.argv as if it
         # were run from a system shell.
         save_argv = sys.argv # save it for later restoring
         sys.argv = [filename]+ arg_lst[1:]  # put in the proper filename
 
         if opts.has_key('i'):
             prog_ns = self.shell.user_ns
             __name__save = self.shell.user_ns['__name__']
             prog_ns['__name__'] = '__main__'
         else:
             if opts.has_key('n'):
                 name = os.path.splitext(os.path.basename(filename))[0]
             else:
                 name = '__main__'
             prog_ns = {'__name__':name}
 
         # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
         # set the __file__ global in the script's namespace
         prog_ns['__file__'] = filename
         
         # pickle fix.  See iplib for an explanation.  But we need to make sure
         # that, if we overwrite __main__, we replace it at the end
         if prog_ns['__name__'] == '__main__':
             restore_main = sys.modules['__main__']
         else:
             restore_main = False
             
         sys.modules[prog_ns['__name__']] = FakeModule(prog_ns)
         
         stats = None
         try:
             if opts.has_key('p'):
                 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
             else:
                 if opts.has_key('d'):
                     deb = Debugger.Pdb(self.shell.rc.colors)
                     # reset Breakpoint state, which is moronically kept
                     # in a class
                     bdb.Breakpoint.next = 1
                     bdb.Breakpoint.bplist = {}
                     bdb.Breakpoint.bpbynumber = [None]
                     # Set an initial breakpoint to stop execution
                     maxtries = 10
                     bp = int(opts.get('b',[1])[0])
                     checkline = deb.checkline(filename,bp)
                     if not checkline:
                         for bp in range(bp+1,bp+maxtries+1):
                             if deb.checkline(filename,bp):
                                 break
                         else:
                             msg = ("\nI failed to find a valid line to set "
                                    "a breakpoint\n"
                                    "after trying up to line: %s.\n"
                                    "Please set a valid breakpoint manually "
                                    "with the -b option." % bp)
                             error(msg)
                             return
                     # if we find a good linenumber, set the breakpoint
                     deb.do_break('%s:%s' % (filename,bp))
                     # Start file run
                     print "NOTE: Enter 'c' at the",
                     print "ipdb> prompt to start your script."
                     try:
                         deb.run('execfile("%s")' % filename,prog_ns)
                     except:
                         etype, value, tb = sys.exc_info()
                         # Skip three frames in the traceback: the %run one,
                         # one inside bdb.py, and the command-line typed by the
                         # user (run by exec in pdb itself).
                         self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
                 else:
                     if runner is None:
                         runner = self.shell.safe_execfile
                     if opts.has_key('t'):
                         try:
                             nruns = int(opts['N'][0])
                             if nruns < 1:
                                 error('Number of runs must be >=1')
                                 return
                         except (KeyError):
                             nruns = 1
                         if nruns == 1:
                             t0 = clock2()
                             runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
                             t1 = clock2()
                             t_usr = t1[0]-t0[0]
                             t_sys = t1[1]-t1[1]
                             print "\nIPython CPU timings (estimated):"
                             print "  User  : %10s s." % t_usr
                             print "  System: %10s s." % t_sys
                         else:
                             runs = range(nruns)
                             t0 = clock2()
                             for nr in runs:
                                 runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
                             t1 = clock2()
                             t_usr = t1[0]-t0[0]
                             t_sys = t1[1]-t1[1]
                             print "\nIPython CPU timings (estimated):"
                             print "Total runs performed:",nruns
                             print "  Times : %10s    %10s" % ('Total','Per run')
                             print "  User  : %10s s, %10s s." % (t_usr,t_usr/nruns)
                             print "  System: %10s s, %10s s." % (t_sys,t_sys/nruns)
                             
                     else:
                         runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
                 if opts.has_key('i'):
                     self.shell.user_ns['__name__'] = __name__save
                 else:
                     # update IPython interactive namespace
                     del prog_ns['__name__']
                     self.shell.user_ns.update(prog_ns)
         finally:
             sys.argv = save_argv
             if restore_main:
                 sys.modules['__main__'] = restore_main
         return stats
 
     def magic_runlog(self, parameter_s =''):
         """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."""
 
         for f in parameter_s.split():
             self.shell.safe_execfile(f,self.shell.user_ns,
                                      self.shell.user_ns,islog=1)
 
     def magic_timeit(self, parameter_s =''):
         """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."""
         import timeit
         import math
 
         units = ["s", "ms", "\xc2\xb5s", "ns"]
         scaling = [1, 1e3, 1e6, 1e9]
 
         opts, stmt = self.parse_options(parameter_s,'n:r:tcp:')
         if stmt == "":
             return
         timefunc = timeit.default_timer
         number = int(getattr(opts, "n", 0))
         repeat = int(getattr(opts, "r", timeit.default_repeat))
         precision = int(getattr(opts, "p", 3))
         if hasattr(opts, "t"):
             timefunc = time.time
         if hasattr(opts, "c"):
             timefunc = clock
 
         timer = timeit.Timer(timer=timefunc)
         # this code has tight coupling to the inner workings of timeit.Timer,
         # but is there a better way to achieve that the code stmt has access
         # to the shell namespace?
 
         src = timeit.template % {'stmt': timeit.reindent(stmt, 8), 'setup': "pass"}
         code = compile(src, "<magic-timeit>", "exec")
         ns = {}
         exec code in self.shell.user_ns, ns
         timer.inner = ns["inner"]
         
         if number == 0:
             # determine number so that 0.2 <= total time < 2.0
             number = 1
             for i in range(1, 10):
                 number *= 10
                 if timer.timeit(number) >= 0.2:
                     break
         
         best = min(timer.repeat(repeat, number)) / number
 
         if best > 0.0:
             order = min(-int(math.floor(math.log10(best)) // 3), 3)
         else:
             order = 3
         print "%d loops, best of %d: %.*g %s per loop" % (number, repeat,
                                                           precision,
                                                           best * scaling[order],
                                                           units[order])
         
     def magic_time(self,parameter_s = ''):
         """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
           """
         
         # fail immediately if the given expression can't be compiled
         try:
             mode = 'eval'
             code = compile(parameter_s,'<timed eval>',mode)
         except SyntaxError:
             mode = 'exec'
             code = compile(parameter_s,'<timed exec>',mode)
         # skew measurement as little as possible
         glob = self.shell.user_ns
         clk = clock2
         wtime = time.time
         # time execution
         wall_st = wtime()
         if mode=='eval':
             st = clk()
             out = eval(code,glob)
             end = clk()
         else:
             st = clk()
             exec code in glob
             end = clk()
             out = None
         wall_end = wtime()
         # Compute actual times and report
         wall_time = wall_end-wall_st
         cpu_user = end[0]-st[0]
         cpu_sys = end[1]-st[1]
         cpu_tot = cpu_user+cpu_sys
         print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
               (cpu_user,cpu_sys,cpu_tot)
         print "Wall time: %.2f" % wall_time
         return out
 
     def magic_macro(self,parameter_s = ''):
         """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]"""
 
         opts,args = self.parse_options(parameter_s,'r',mode='list')
         name,ranges = args[0], args[1:]
         #print 'rng',ranges  # dbg
         lines = self.extract_input_slices(ranges,opts.has_key('r'))
         macro = Macro(lines)
         self.shell.user_ns.update({name:macro})
         print 'Macro `%s` created. To execute, type its name (without quotes).' % name
         print 'Macro contents:'
         print macro,
 
     def magic_save(self,parameter_s = ''):
         """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."""
 
         opts,args = self.parse_options(parameter_s,'r',mode='list')
         fname,ranges = args[0], args[1:]
         if not fname.endswith('.py'):
             fname += '.py'
         if os.path.isfile(fname):
             ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
             if ans.lower() not in ['y','yes']:
                 print 'Operation cancelled.'
                 return
         cmds = ''.join(self.extract_input_slices(ranges,opts.has_key('r')))
         f = file(fname,'w')
         f.write(cmds)
         f.close()
         print 'The following commands were written to file `%s`:' % fname
         print cmds
 
     def _edit_macro(self,mname,macro):
         """open an editor with the macro data in a file"""
         filename = self.shell.mktempfile(macro.value)
         self.shell.hooks.editor(filename)
 
         # and make a new macro object, to replace the old one
         mfile = open(filename)
         mvalue = mfile.read()
         mfile.close()
         self.shell.user_ns[mname] = Macro(mvalue)
 
     def magic_ed(self,parameter_s=''):
         """Alias to %edit."""
         return self.magic_edit(parameter_s)
 
     def magic_edit(self,parameter_s='',last_call=['','']):
         """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."""
         
         # FIXME: This function has become a convoluted mess.  It needs a
         # ground-up rewrite with clean, simple logic.
 
         def make_filename(arg):
             "Make a filename from the given args"
             try:
                 filename = get_py_filename(arg)
             except IOError:
                 if args.endswith('.py'):
                     filename = arg
                 else:
                     filename = None
             return filename
 
         # custom exceptions
         class DataIsObject(Exception): pass
 
         opts,args = self.parse_options(parameter_s,'prxn:')
         # Set a few locals from the options for convenience:
         opts_p = opts.has_key('p')
         opts_r = opts.has_key('r')
         
         # Default line number value
         lineno = opts.get('n',None)
 
         if opts_p:
             args = '_%s' % last_call[0]
             if not self.shell.user_ns.has_key(args):
                 args = last_call[1]
             
         # use last_call to remember the state of the previous call, but don't
         # let it be clobbered by successive '-p' calls.
         try:
             last_call[0] = self.shell.outputcache.prompt_count
             if not opts_p:
                 last_call[1] = parameter_s
         except:
             pass
 
         # by default this is done with temp files, except when the given
         # arg is a filename
         use_temp = 1
 
         if re.match(r'\d',args):
             # Mode where user specifies ranges of lines, like in %macro.
             # This means that you can't edit files whose names begin with
             # numbers this way. Tough.
             ranges = args.split()
             data = ''.join(self.extract_input_slices(ranges,opts_r))
         elif args.endswith('.py'):
             filename = make_filename(args)
             data = ''
             use_temp = 0
         elif args:
             try:
                 # Load the parameter given as a variable. If not a string,
                 # process it as an object instead (below)
 
                 #print '*** args',args,'type',type(args)  # dbg
                 data = eval(args,self.shell.user_ns)
                 if not type(data) in StringTypes:
                     raise DataIsObject
 
             except (NameError,SyntaxError):
                 # given argument is not a variable, try as a filename
                 filename = make_filename(args)
                 if filename is None:
                     warn("Argument given (%s) can't be found as a variable "
                          "or as a filename." % args)
                     return
 
                 data = ''
                 use_temp = 0
             except DataIsObject:
 
                 # macros have a special edit function
                 if isinstance(data,Macro):
                     self._edit_macro(args,data)
                     return
                 
                 # For objects, try to edit the file where they are defined
                 try:
                     filename = inspect.getabsfile(data)
                     datafile = 1
                 except TypeError:
                     filename = make_filename(args)
                     datafile = 1
                     warn('Could not find file where `%s` is defined.\n'
                          'Opening a file named `%s`' % (args,filename))
                 # Now, make sure we can actually read the source (if it was in
                 # a temp file it's gone by now).
                 if datafile:
                     try:
                         if lineno is None:
                             lineno = inspect.getsourcelines(data)[1]
                     except IOError:
                         filename = make_filename(args)
                         if filename is None:
                             warn('The file `%s` where `%s` was defined cannot '
                                  'be read.' % (filename,data))
                             return
                 use_temp = 0
         else:
             data = ''
 
         if use_temp:
             filename = self.shell.mktempfile(data)
             print 'IPython will make a temporary file named:',filename
 
         # do actual editing here
         print 'Editing...',
         sys.stdout.flush()
         self.shell.hooks.editor(filename,lineno)
         if opts.has_key('x'):  # -x prevents actual execution
             print
         else:
             print 'done. Executing edited code...'
             if opts_r:
                 self.shell.runlines(file_read(filename))
             else:
                 self.shell.safe_execfile(filename,self.shell.user_ns)
         if use_temp:
             try:
                 return open(filename).read()
             except IOError,msg:
                 if msg.filename == filename:
                     warn('File not found. Did you forget to save?')
                     return
                 else:
                     self.shell.showtraceback()
 
     def magic_xmode(self,parameter_s = ''):
         """Switch modes for the exception handlers.
 
         Valid modes: Plain, Context and Verbose.
 
         If called without arguments, acts as a toggle."""
 
         def xmode_switch_err(name):
             warn('Error changing %s exception modes.\n%s' %
                  (name,sys.exc_info()[1]))
 
         shell = self.shell
         new_mode = parameter_s.strip().capitalize()
         try:
             shell.InteractiveTB.set_mode(mode=new_mode)
             print 'Exception reporting mode:',shell.InteractiveTB.mode
         except:
             xmode_switch_err('user')
 
         # threaded shells use a special handler in sys.excepthook
         if shell.isthreaded:
             try:
                 shell.sys_excepthook.set_mode(mode=new_mode)
             except:
                 xmode_switch_err('threaded')
             
     def magic_colors(self,parameter_s = ''):
         """Switch color scheme for prompts, info system and exception handlers.
 
         Currently implemented schemes: NoColor, Linux, LightBG.
 
         Color scheme names are not case-sensitive."""
 
         def color_switch_err(name):
             warn('Error changing %s color schemes.\n%s' %
                  (name,sys.exc_info()[1]))
             
         
         new_scheme = parameter_s.strip()
         if not new_scheme:
             print 'You must specify a color scheme.'
             return
         import IPython.rlineimpl as readline
         if not readline.have_readline:
             msg = """\
-Proper color support under MS Windows requires Gary Bishop's readline library.
+Proper color support under MS Windows requires the pyreadline library.
 You can find it at:
-http://sourceforge.net/projects/uncpythontools
+http://ipython.scipy.org/moin/PyReadline/Intro
 Gary's readline needs the ctypes module, from:
 http://starship.python.net/crew/theller/ctypes
+(Note that ctypes is already part of Python versions 2.5 and newer).
 
 Defaulting color scheme to 'NoColor'"""
             new_scheme = 'NoColor'
             warn(msg)
         # local shortcut
         shell = self.shell
         
         # Set prompt colors
         try:
             shell.outputcache.set_colors(new_scheme)
         except:
             color_switch_err('prompt')
         else:
             shell.rc.colors = \
                        shell.outputcache.color_table.active_scheme_name
         # Set exception colors
         try:
             shell.InteractiveTB.set_colors(scheme = new_scheme)
             shell.SyntaxTB.set_colors(scheme = new_scheme)
         except:
             color_switch_err('exception')
 
         # threaded shells use a verbose traceback in sys.excepthook
         if shell.isthreaded:
             try:
                 shell.sys_excepthook.set_colors(scheme=new_scheme)
             except:
                 color_switch_err('system exception handler')
         
         # Set info (for 'object?') colors
         if shell.rc.color_info:
             try:
                 shell.inspector.set_active_scheme(new_scheme)
             except:
                 color_switch_err('object inspector')
         else:
             shell.inspector.set_active_scheme('NoColor')
                 
     def magic_color_info(self,parameter_s = ''):
         """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."""
         
         self.shell.rc.color_info = 1 - self.shell.rc.color_info
         self.magic_colors(self.shell.rc.colors)
         print 'Object introspection functions have now coloring:',
         print ['OFF','ON'][self.shell.rc.color_info]
 
     def magic_Pprint(self, parameter_s=''):
         """Toggle pretty printing on/off."""
         
         self.shell.rc.pprint = 1 - self.shell.rc.pprint
         print 'Pretty printing has been turned', \
               ['OFF','ON'][self.shell.rc.pprint]
         
     def magic_exit(self, parameter_s=''):
         """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."""
 
         self.shell.exit()
 
     def magic_quit(self, parameter_s=''):
         """Exit IPython, confirming if configured to do so (like %exit)"""
 
         self.shell.exit()
         
     def magic_Exit(self, parameter_s=''):
         """Exit IPython without confirmation."""
 
         self.shell.exit_now = True
 
     def magic_Quit(self, parameter_s=''):
         """Exit IPython without confirmation (like %Exit)."""
 
         self.shell.exit_now = True
         
     #......................................................................
     # Functions to implement unix shell-type things
     
     def magic_alias(self, parameter_s = ''):
         """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."""
 
         par = parameter_s.strip()
         if not par:
             if self.shell.rc.automagic:
                 prechar = ''
             else:
                 prechar = self.shell.ESC_MAGIC
             #print 'Alias\t\tSystem Command\n'+'-'*30
             atab = self.shell.alias_table
             aliases = atab.keys()
             aliases.sort()
             res = []
             for alias in aliases:
                 res.append((alias, atab[alias][1]))                
             print "Total number of aliases:",len(aliases)
             return res
         try:
             alias,cmd = par.split(None,1)
         except:
             print OInspect.getdoc(self.magic_alias)
         else:
             nargs = cmd.count('%s')
             if nargs>0 and cmd.find('%l')>=0:
                 error('The %s and %l specifiers are mutually exclusive '
                       'in alias definitions.')
             else:  # all looks OK
                 self.shell.alias_table[alias] = (nargs,cmd)
                 self.shell.alias_table_validate(verbose=0)
     # end magic_alias
 
     def magic_unalias(self, parameter_s = ''):
         """Remove an alias"""
 
         aname = parameter_s.strip()
         if aname in self.shell.alias_table:
             del self.shell.alias_table[aname]
             
     def magic_rehash(self, parameter_s = ''):
         """Update the alias table with all entries in $PATH.
 
         This version does no checks on execute permissions or whether the
         contents of $PATH are truly files (instead of directories or something
         else).  For such a safer (but slower) version, use %rehashx."""
 
         # This function (and rehashx) manipulate the alias_table directly
         # rather than calling magic_alias, for speed reasons.  A rehash on a
         # typical Linux box involves several thousand entries, so efficiency
         # here is a top concern.
         
         path = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
         alias_table = self.shell.alias_table
         for pdir in path:
             for ff in os.listdir(pdir):
                 # each entry in the alias table must be (N,name), where
                 # N is the number of positional arguments of the alias.
                 alias_table[ff] = (0,ff)
         # Make sure the alias table doesn't contain keywords or builtins
         self.shell.alias_table_validate()
         # Call again init_auto_alias() so we get 'rm -i' and other modified
         # aliases since %rehash will probably clobber them
         self.shell.init_auto_alias()
 
     def magic_rehashx(self, parameter_s = ''):
         """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'. """
         
         path = [os.path.abspath(os.path.expanduser(p)) for p in 
             os.environ['PATH'].split(os.pathsep)]
         path = filter(os.path.isdir,path)
         
         alias_table = self.shell.alias_table
         syscmdlist = []
         if os.name == 'posix':
             isexec = lambda fname:os.path.isfile(fname) and \
                      os.access(fname,os.X_OK)
         else:
 
             try:
                 winext = os.environ['pathext'].replace(';','|').replace('.','')
             except KeyError:
                 winext = 'exe|com|bat'
     
             execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
             isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
         savedir = os.getcwd()
         try:
             # write the whole loop for posix/Windows so we don't have an if in
             # the innermost part
             if os.name == 'posix':
                 for pdir in path:
                     os.chdir(pdir)
                     for ff in os.listdir(pdir):
                         if isexec(ff) and ff not in self.shell.no_alias:
                             # each entry in the alias table must be (N,name),
                             # where N is the number of positional arguments of the
                             # alias.
                             alias_table[ff] = (0,ff)
                             syscmdlist.append(ff)
             else:
                 for pdir in path:
                     os.chdir(pdir)
                     for ff in os.listdir(pdir):
                         if isexec(ff) and os.path.splitext(ff)[0] not in self.shell.no_alias:
                             alias_table[execre.sub(r'\1',ff)] = (0,ff)
                             syscmdlist.append(ff)
             # Make sure the alias table doesn't contain keywords or builtins
             self.shell.alias_table_validate()
             # Call again init_auto_alias() so we get 'rm -i' and other
             # modified aliases since %rehashx will probably clobber them
             self.shell.init_auto_alias()
             db = self.getapi().db
             db['syscmdlist'] = syscmdlist
         finally:
             os.chdir(savedir)
         
     def magic_pwd(self, parameter_s = ''):
         """Return the current working directory path."""
         return os.getcwd()
 
     def magic_cd(self, parameter_s=''):
         """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.
 
         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.)
 
         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'."""
 
         parameter_s = parameter_s.strip()
         #bkms = self.shell.persist.get("bookmarks",{})
 
         numcd = re.match(r'(-)(\d+)$',parameter_s)
         # jump in directory history by number
         if numcd:
             nn = int(numcd.group(2))
             try:
                 ps = self.shell.user_ns['_dh'][nn]
             except IndexError:
                 print 'The requested directory does not exist in history.'
                 return
             else:
                 opts = {}
         else:
             #turn all non-space-escaping backslashes to slashes, 
             # for c:\windows\directory\names\
             parameter_s = re.sub(r'\\(?! )','/', parameter_s)            
             opts,ps = self.parse_options(parameter_s,'qb',mode='string')
         # jump to previous
         if ps == '-':
             try:
                 ps = self.shell.user_ns['_dh'][-2]
             except IndexError:
                 print 'No previous directory to change to.'
                 return
         # jump to bookmark if needed
         else:
             if not os.path.isdir(ps) or opts.has_key('b'):
                 bkms = self.db.get('bookmarks', {})
             
                 if bkms.has_key(ps):
                     target = bkms[ps]
                     print '(bookmark:%s) -> %s' % (ps,target)
                     ps = target
                 else:
                     if opts.has_key('b'):
                         error("Bookmark '%s' not found.  "
                               "Use '%%bookmark -l' to see your bookmarks." % ps)
                         return
             
         # at this point ps should point to the target dir
         if ps:
             try:
                 os.chdir(os.path.expanduser(ps))
                 ttitle = ("IPy:" + (
                     os.getcwd() == '/' and '/' or os.path.basename(os.getcwd())))
                 platutils.set_term_title(ttitle)
             except OSError:
                 print sys.exc_info()[1]
             else:
                 self.shell.user_ns['_dh'].append(os.getcwd())
         else:
             os.chdir(self.shell.home_dir)
             platutils.set_term_title("IPy:~")
             self.shell.user_ns['_dh'].append(os.getcwd())
         if not 'q' in opts:
             print self.shell.user_ns['_dh'][-1]
 
     def magic_dhist(self, parameter_s=''):
         """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>."""
 
         dh = self.shell.user_ns['_dh']
         if parameter_s:
             try:
                 args = map(int,parameter_s.split())
             except:
                 self.arg_err(Magic.magic_dhist)
                 return
             if len(args) == 1:
                 ini,fin = max(len(dh)-(args[0]),0),len(dh)
             elif len(args) == 2:
                 ini,fin = args
             else:
                 self.arg_err(Magic.magic_dhist)
                 return
         else:
             ini,fin = 0,len(dh)
         nlprint(dh,
                 header = 'Directory history (kept in _dh)',
                 start=ini,stop=fin)
 
     def magic_env(self, parameter_s=''):
         """List environment variables."""
         
         return os.environ.data
 
     def magic_pushd(self, parameter_s=''):
         """Place the current dir on stack and change directory.
         
         Usage:\\
           %pushd ['dirname']
 
         %pushd with no arguments does a %pushd to your home directory.
         """
         if parameter_s == '': parameter_s = '~'
         dir_s = self.shell.dir_stack
         if len(dir_s)>0 and os.path.expanduser(parameter_s) != \
            os.path.expanduser(self.shell.dir_stack[0]):
             try:
                 self.magic_cd(parameter_s)
                 dir_s.insert(0,os.getcwd().replace(self.home_dir,'~'))
                 self.magic_dirs()
             except:
                 print 'Invalid directory'
         else:
             print 'You are already there!'
 
     def magic_popd(self, parameter_s=''):
         """Change to directory popped off the top of the stack.
         """
         if len (self.shell.dir_stack) > 1:
             self.shell.dir_stack.pop(0)
             self.magic_cd(self.shell.dir_stack[0])
             print self.shell.dir_stack[0]
         else:
             print "You can't remove the starting directory from the stack:",\
                   self.shell.dir_stack
 
     def magic_dirs(self, parameter_s=''):
         """Return the current directory stack."""
 
         return self.shell.dir_stack[:]
 
     def magic_sc(self, parameter_s=''):
         """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\nwin32_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.
         """
 
         opts,args = self.parse_options(parameter_s,'lv')
         # Try to get a variable name and command to run
         try:
             # the variable name must be obtained from the parse_options
             # output, which uses shlex.split to strip options out.
             var,_ = args.split('=',1)
             var = var.strip()
             # But the the command has to be extracted from the original input
             # parameter_s, not on what parse_options returns, to avoid the
             # quote stripping which shlex.split performs on it.
             _,cmd = parameter_s.split('=',1)
         except ValueError:
             var,cmd = '',''
         # If all looks ok, proceed
         out,err = self.shell.getoutputerror(cmd)
         if err:
             print >> Term.cerr,err
         if opts.has_key('l'):
             out = SList(out.split('\n'))
         else:
             out = LSString(out)
         if opts.has_key('v'):
             print '%s ==\n%s' % (var,pformat(out))
         if var:
             self.shell.user_ns.update({var:out})
         else:
             return out
 
     def magic_sx(self, parameter_s=''):
         """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."""
 
         if parameter_s:
             out,err = self.shell.getoutputerror(parameter_s)
             if err:
                 print >> Term.cerr,err
             return SList(out.split('\n'))
 
     def magic_bg(self, parameter_s=''):
         """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"""
         
         self.shell.jobs.new(parameter_s,self.shell.user_ns)
         
     
     def magic_bookmark(self, parameter_s=''):
         """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."""
 
         opts,args = self.parse_options(parameter_s,'drl',mode='list')
         if len(args) > 2:
             error('You can only give at most two arguments')
             return
 
         bkms = self.db.get('bookmarks',{})
             
         if opts.has_key('d'):
             try:
                 todel = args[0]
             except IndexError:
                 error('You must provide a bookmark to delete')
             else:
                 try:
                     del bkms[todel]
                 except:
                     error("Can't delete bookmark '%s'" % todel)
         elif opts.has_key('r'):
             bkms = {}
         elif opts.has_key('l'):
             bks = bkms.keys()
             bks.sort()
             if bks:
                 size = max(map(len,bks))
             else:
                 size = 0
             fmt = '%-'+str(size)+'s -> %s'
             print 'Current bookmarks:'
             for bk in bks:
                 print fmt % (bk,bkms[bk])
         else:
             if not args:
                 error("You must specify the bookmark name")
             elif len(args)==1:
                 bkms[args[0]] = os.getcwd()
             elif len(args)==2:
                 bkms[args[0]] = args[1]
         self.db['bookmarks'] = bkms
 
     def magic_pycat(self, parameter_s=''):
         """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. """
         
         try:
             filename = get_py_filename(parameter_s)
             cont = file_read(filename)
         except IOError:
             try:
                 cont = eval(parameter_s,self.user_ns)
             except NameError:
                 cont = None
         if cont is None:
             print "Error: no such file or variable"
             return
             
         page(self.shell.pycolorize(cont),
              screen_lines=self.shell.rc.screen_length)
 
     def magic_cpaste(self, parameter_s=''):
         """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. '>' characters at the beginning of a line is
         ignored, to allow pasting directly from e-mails. 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).
         """
         opts,args = self.parse_options(parameter_s,'s:',mode='string')
         par = args.strip()
         sentinel = opts.get('s','--')
         
         from IPython import iplib
         lines = []
         print "Pasting code; enter '%s' alone on the line to stop." % sentinel
         while 1:
             l = iplib.raw_input_original(':')
             if l ==sentinel:
                 break
             lines.append(l.lstrip('>'))
         block = "\n".join(lines) + '\n'
         #print "block:\n",block
         if not par:
             b = textwrap.dedent(block)
             exec b in self.user_ns            
             self.user_ns['pasted_block'] = b
         else:
             self.user_ns[par] = block
             print "Block assigned to '%s'" % par
             
     def magic_quickref(self,arg):
         """ Show a quick reference sheet """
         import IPython.usage
         qr = IPython.usage.quick_reference + self.magic_magic('-brief')
         
         page(qr)
         
     def magic_upgrade(self,arg):
         """ 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)
 
         """
         ip = self.getapi()
         ipinstallation = path(IPython.__file__).dirname()
         upgrade_script = '%s "%s"' % (sys.executable,ipinstallation / 'upgrade_dir.py')
         src_config = ipinstallation / 'UserConfig'
         userdir = path(ip.options.ipythondir)
         cmd = '%s "%s" "%s"' % (upgrade_script, src_config, userdir)
         print ">",cmd
         shell(cmd)
         if arg == '-nolegacy':
             legacy = userdir.files('ipythonrc*')
             print "Nuking legacy files:",legacy
             
             [p.remove() for p in legacy]
             suffix = (sys.platform == 'win32' and '.ini' or '')
             (userdir / ('ipythonrc' + suffix)).write_text('# Empty, see ipy_user_conf.py\n')
 
 
 # end Magic

IPython/iplib.py

@@ -1,2356 +1,2354 b''
 # -*- coding: utf-8 -*-
 """
 IPython -- An enhanced Interactive Python
 
 Requires Python 2.3 or newer.
 
 This file contains all the classes and helper functions specific to IPython.
 
-$Id: iplib.py 1786 2006-09-27 05:47:28Z fperez $
+$Id: iplib.py 1787 2006-09-27 06:56:29Z fperez $
 """
 
 #*****************************************************************************
 #       Copyright (C) 2001 Janko Hauser <[e-mail]> and
 #       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #
 # Note: this code originally subclassed code.InteractiveConsole from the
 # Python standard library.  Over time, all of that class has been copied
 # verbatim here for modifications which could not be accomplished by
 # subclassing.  At this point, there are no dependencies at all on the code
 # module anymore (it is not even imported).  The Python License (sec. 2)
 # allows for this, but it's always nice to acknowledge credit where credit is
 # due.
 #*****************************************************************************
 
 #****************************************************************************
 # 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__
 import StringIO
 import bdb
 import cPickle as pickle
 import codeop
 import exceptions
 import glob
 import inspect
 import keyword
 import new
 import os
 import pdb
 import pydoc
 import re
 import shutil
 import string
 import sys
 import tempfile
 import traceback
 import types
 import pickleshare
 
 from pprint import pprint, pformat
 
 # IPython's own modules
 import IPython
 from IPython import OInspect,PyColorize,ultraTB
 from IPython.ColorANSI import ColorScheme,ColorSchemeTable  # too long names
 from IPython.FakeModule import FakeModule
 from IPython.Itpl import Itpl,itpl,printpl,ItplNS,itplns
 from IPython.Logger import Logger
 from IPython.Magic import Magic
 from IPython.Prompts import CachedOutput
 from IPython.ipstruct import Struct
 from IPython.background_jobs import BackgroundJobManager
 from IPython.usage import cmd_line_usage,interactive_usage
 from IPython.genutils import *
 import IPython.ipapi
 
 # Globals
 
 # store the builtin raw_input globally, and use this always, in case user code
 # overwrites it (like wx.py.PyShell does)
 raw_input_original = raw_input
 
 # compiled regexps for autoindent management
 dedent_re = re.compile(r'^\s+raise|^\s+return|^\s+pass')
 
 
 #****************************************************************************
 # Some utility function definitions
 
 ini_spaces_re = re.compile(r'^(\s+)')
 
 def num_ini_spaces(strng):
     """Return the number of initial spaces in a string"""
 
     ini_spaces = ini_spaces_re.match(strng)
     if ini_spaces:
         return ini_spaces.end()
     else:
         return 0
 
 def softspace(file, newvalue):
     """Copied from code.py, to remove the dependency"""
 
     oldvalue = 0
     try:
         oldvalue = file.softspace
     except AttributeError:
         pass
     try:
         file.softspace = newvalue
     except (AttributeError, TypeError):
         # "attribute-less object" or "read-only attributes"
         pass
     return oldvalue
 
 
 #****************************************************************************
 # Local use exceptions
 class SpaceInInput(exceptions.Exception): pass
 
 
 #****************************************************************************
 # Local use classes
 class Bunch: pass
 
 class Undefined: pass
 
 class InputList(list):
     """Class to store user input.
 
     It's basically a list, but slices return a string instead of a list, thus
     allowing things like (assuming 'In' is an instance):
 
     exec In[4:7]
 
     or
 
     exec In[5:9] + In[14] + In[21:25]"""
 
     def __getslice__(self,i,j):
         return ''.join(list.__getslice__(self,i,j))
 
 class SyntaxTB(ultraTB.ListTB):
     """Extension which holds some state: the last exception value"""
 
     def __init__(self,color_scheme = 'NoColor'):
         ultraTB.ListTB.__init__(self,color_scheme)
         self.last_syntax_error = None
 
     def __call__(self, etype, value, elist):
         self.last_syntax_error = value
         ultraTB.ListTB.__call__(self,etype,value,elist)
 
     def clear_err_state(self):
         """Return the current error state and clear it"""
         e = self.last_syntax_error
         self.last_syntax_error = None
         return e
 
 #****************************************************************************
 # Main IPython class
 
 # FIXME: the Magic class is a mixin for now, and will unfortunately remain so
 # until a full rewrite is made.  I've cleaned all cross-class uses of
 # attributes and methods, but too much user code out there relies on the
 # equlity %foo == __IP.magic_foo, so I can't actually remove the mixin usage.
 #
 # But at least now, all the pieces have been separated and we could, in
 # principle, stop using the mixin.  This will ease the transition to the
 # chainsaw branch.
 
 # For reference, the following is the list of 'self.foo' uses in the Magic
 # class as of 2005-12-28.  These are names we CAN'T use in the main ipython
 # class, to prevent clashes.
 
 # ['self.__class__', 'self.__dict__', 'self._inspect', 'self._ofind',
 #  'self.arg_err', 'self.extract_input', 'self.format_', 'self.lsmagic',
 #  'self.magic_', 'self.options_table', 'self.parse', 'self.shell',
 #  'self.value']
 
 class InteractiveShell(object,Magic):
     """An enhanced console for Python."""
 
     # class attribute to indicate whether the class supports threads or not.
     # Subclasses with thread support should override this as needed.
     isthreaded = False
 
     def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
                  user_ns = None,user_global_ns=None,banner2='',
                  custom_exceptions=((),None),embedded=False):
 
         # log system
         self.logger = Logger(self,logfname='ipython_log.py',logmode='rotate')
 
         # some minimal strict typechecks.  For some core data structures, I
         # want actual basic python types, not just anything that looks like
         # one.  This is especially true for namespaces.
         for ns in (user_ns,user_global_ns):
             if ns is not None and type(ns) != types.DictType:
                 raise TypeError,'namespace must be a dictionary'
 
         # Job manager (for jobs run as background threads)
         self.jobs = BackgroundJobManager()
 
         # Store the actual shell's name
         self.name = name
 
         # We need to know whether the instance is meant for embedding, since
         # global/local namespaces need to be handled differently in that case
         self.embedded = embedded
 
         # command compiler
         self.compile = codeop.CommandCompiler()
 
         # User input buffer
         self.buffer = []
 
         # Default name given in compilation of code
         self.filename = '<ipython console>'
 
+        # Install our own quitter instead of the builtins.  For python2.3-2.4,
+        # this brings in behavior more like 2.5, and for 2.5 it's almost
+        # identical to Python's official behavior (except we lack the message,
+        # but with autocall the need for that is much less).
+        __builtin__.exit = __builtin__.quit = self.exit
+
         # Make an empty namespace, which extension writers can rely on both
         # existing and NEVER being used by ipython itself.  This gives them a
         # convenient location for storing additional information and state
         # their extensions may require, without fear of collisions with other
         # ipython names that may develop later.
         self.meta = Struct()
 
         # Create the namespace where the user will operate.  user_ns is
         # normally the only one used, and it is passed to the exec calls as
         # the locals argument.  But we do carry a user_global_ns namespace
         # given as the exec 'globals' argument,  This is useful in embedding
         # situations where the ipython shell opens in a context where the
         # distinction between locals and globals is meaningful.
 
         # FIXME. For some strange reason, __builtins__ is showing up at user
         # level as a dict instead of a module. This is a manual fix, but I
         # should really track down where the problem is coming from. Alex
         # Schmolck reported this problem first.
 
         # A useful post by Alex Martelli on this topic:
         # Re: inconsistent value from __builtins__
         # Von: Alex Martelli <[e-mail]>
         # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
         # Gruppen: comp.lang.python
 
         # Michael Hohn <[e-mail]> wrote:
         # > >>> print type(builtin_check.get_global_binding('__builtins__'))
         # > <type 'dict'>
         # > >>> print type(__builtins__)
         # > <type 'module'>
         # > Is this difference in return value intentional?
 
         # Well, it's documented that '__builtins__' can be either a dictionary
         # or a module, and it's been that way for a long time. Whether it's
         # intentional (or sensible), I don't know. In any case, the idea is
         # that if you need to access the built-in namespace directly, you
         # should start with "import __builtin__" (note, no 's') which will
         # definitely give you a module. Yeah, it's somewhat confusing:-(.
 
         # These routines return properly built dicts as needed by the rest of
         # the code, and can also be used by extension writers to generate
         # properly initialized namespaces.
         user_ns = IPython.ipapi.make_user_ns(user_ns)
         user_global_ns = IPython.ipapi.make_user_global_ns(user_global_ns)
             
         # Assign namespaces
         # This is the namespace where all normal user variables live
         self.user_ns = user_ns
         # Embedded instances require a separate namespace for globals.
         # Normally this one is unused by non-embedded instances.
         self.user_global_ns = user_global_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 = {}
 
         # Namespace of system aliases.  Each entry in the alias
         # table must be a 2-tuple of the form (N,name), where N is the number
         # of positional arguments of the alias.
         self.alias_table = {}
 
         # A table holding all the namespaces IPython deals with, so that
         # introspection facilities can search easily.
         self.ns_table = {'user':user_ns,
                          'user_global':user_global_ns,
                          'alias':self.alias_table,
                          'internal':self.internal_ns,
                          'builtin':__builtin__.__dict__
                          }
 
         # The user namespace MUST have a pointer to the shell itself.
         self.user_ns[name] = self
 
         # 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
         # everything out of __main__, but for embedding purposes each IPython
         # instance has its own private namespace, so we can't go shoving
         # everything into __main__.
 
         # note, however, that we should only do this for non-embedded
         # ipythons, which really mimic the __main__.__dict__ with their own
         # namespace.  Embedded instances, on the other hand, should not do
         # this because they need to manage the user local/global namespaces
         # only, but they live within a 'normal' __main__ (meaning, they
         # shouldn't overtake the execution environment of the script they're
         # embedded in).
 
         if not embedded:
             try:
                 main_name = self.user_ns['__name__']
             except KeyError:
                 raise KeyError,'user_ns dictionary MUST have a "__name__" key'
             else:
                 #print "pickle hack in place"  # dbg
                 #print 'main_name:',main_name # dbg
                 sys.modules[main_name] = FakeModule(self.user_ns)
 
         # List of input with multi-line handling.
         # Fill its zero entry, user counter starts at 1
         self.input_hist = InputList(['\n'])
         # 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'])
 
         # list of visited directories
         try:
             self.dir_hist = [os.getcwd()]
         except IOError, e:
             self.dir_hist = []
 
         # dict of output history
         self.output_hist = {}
 
         # dict of things NOT to alias (keywords, builtins and some magics)
         no_alias = {}
         no_alias_magics = ['cd','popd','pushd','dhist','alias','unalias']
         for key in keyword.kwlist + no_alias_magics:
             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
 
         # 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
         # item which gets cleared once run.
         self.code_to_run = None
         
         # escapes for automatic behavior on the command line
         self.ESC_SHELL  = '!'
         self.ESC_HELP   = '?'
         self.ESC_MAGIC  = '%'
         self.ESC_QUOTE  = ','
         self.ESC_QUOTE2 = ';'
         self.ESC_PAREN  = '/'
 
         # And their associated handlers
         self.esc_handlers = {self.ESC_PAREN  : self.handle_auto,
                              self.ESC_QUOTE  : self.handle_auto,
                              self.ESC_QUOTE2 : self.handle_auto,
                              self.ESC_MAGIC  : self.handle_magic,
                              self.ESC_HELP   : self.handle_help,
                              self.ESC_SHELL  : self.handle_shell_escape,
                              }
 
         # class initializations
         Magic.__init__(self,self)
 
         # Python source parser/formatter for syntax highlighting
         pyformat = PyColorize.Parser().format
         self.pycolorize = lambda src: pyformat(src,'str',self.rc['colors'])
 
         # hooks holds pointers used for user-side customizations
         self.hooks = Struct()
         
         # Set all default hooks, defined in the IPython.hooks module.
         hooks = IPython.hooks
         for hook_name in hooks.__all__:
             # default hooks have priority 100, i.e. low; user hooks should have 0-100 priority
             self.set_hook(hook_name,getattr(hooks,hook_name), 100)
             #print "bound hook",hook_name
 
         # Flag to mark unconditional exit
         self.exit_now = False
 
         self.usage_min =  """\
         An enhanced console for Python.
         Some of its features are:
         - Readline support if the readline library is present.
         - Tab completion in the local namespace.
         - Logging of input, see command-line options.
         - System shell escape via ! , eg !ls.
         - Magic commands, starting with a % (like %ls, %pwd, %cd, etc.)
         - Keeps track of locally defined variables via %who, %whos.
         - Show object information with a ? eg ?x or x? (use ?? for more info).
         """
         if usage: self.usage = usage
         else: self.usage = self.usage_min
 
         # Storage
         self.rc = rc   # This will hold all configuration information
         self.pager = 'less'
         # temporary files used for various purposes.  Deleted at exit.
         self.tempfiles = []
 
         # Keep track of readline usage (later set by init_readline)
         self.has_readline = False
 
         # template for logfile headers.  It gets resolved at runtime by the
         # logstart method.
         self.loghead_tpl = \
 """#log# Automatic Logger file. *** THIS MUST BE THE FIRST LINE ***
 #log# DO NOT CHANGE THIS LINE OR THE TWO BELOW
 #log# opts = %s
 #log# args = %s
 #log# It is safe to make manual edits below here.
 #log#-----------------------------------------------------------------------
 """
         # for pushd/popd management
         try:
             self.home_dir = get_home_dir()
         except HomeDirError,msg:
             fatal(msg)
 
         self.dir_stack = [os.getcwd().replace(self.home_dir,'~')]
 
         # Functions to call the underlying shell.
 
         # utility to expand user variables via Itpl
         self.var_expand = lambda cmd: str(ItplNS(cmd.replace('#','\#'),
                                                  self.user_ns))
         # The first is similar to os.system, but it doesn't return a value,
         # and it allows interpolation of variables in the user's namespace.
         self.system = lambda cmd: shell(self.var_expand(cmd),
                                         header='IPython system call: ',
                                         verbose=self.rc.system_verbose)
         # These are for getoutput and getoutputerror:
         self.getoutput = lambda cmd: \
                          getoutput(self.var_expand(cmd),
                                    header='IPython system call: ',
                                    verbose=self.rc.system_verbose)
         self.getoutputerror = lambda cmd: \
                               getoutputerror(self.var_expand(cmd),
                                              header='IPython system call: ',
                                              verbose=self.rc.system_verbose)
  
         # RegExp for splitting line contents into pre-char//first
         # word-method//rest.  For clarity, each group in on one line.
 
         # WARNING: update the regexp if the above escapes are changed, as they
         # are hardwired in.
 
         # Don't get carried away with trying to make the autocalling catch too
         # much:  it's better to be conservative rather than to trigger hidden
         # evals() somewhere and end up causing side effects.
 
         self.line_split = re.compile(r'^([\s*,;/])'
                                      r'([\?\w\.]+\w*\s*)'
                                      r'(\(?.*$)')
 
         # Original re, keep around for a while in case changes break something
         #self.line_split = re.compile(r'(^[\s*!\?%,/]?)'
         #                             r'(\s*[\?\w\.]+\w*\s*)'
         #                             r'(\(?.*$)')
 
         # RegExp to identify potential function names
         self.re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
 
         # RegExp to exclude strings with this start from autocalling.  In
         # particular, all binary operators should be excluded, so that if foo
         # is callable, foo OP bar doesn't become foo(OP bar), which is
         # invalid.  The characters '!=()' don't need to be checked for, as the
         # _prefilter routine explicitely does so, to catch direct calls and
         # rebindings of existing names.
 
         # Warning: the '-' HAS TO BE AT THE END of the first group, otherwise
         # it affects the rest of the group in square brackets.
         self.re_exclude_auto = re.compile(r'^[<>,&^\|\*/\+-]'
                                           '|^is |^not |^in |^and |^or ')
 
         # try to catch also methods for stuff in lists/tuples/dicts: off
         # (experimental). For this to work, the line_split regexp would need
         # to be modified so it wouldn't break things at '['. That line is
         # nasty enough that I shouldn't change it until I can test it _well_.
         #self.re_fun_name = re.compile (r'[a-zA-Z_]([a-zA-Z0-9_.\[\]]*) ?$')
 
         # keep track of where we started running (mainly for crash post-mortem)
         self.starting_dir = os.getcwd()
 
         # Various switches which can be set
         self.CACHELENGTH = 5000  # this is cheap, it's just text
         self.BANNER = "Python %(version)s on %(platform)s\n" % sys.__dict__
         self.banner2 = banner2
 
         # TraceBack handlers:
 
         # Syntax error handler.
         self.SyntaxTB = SyntaxTB(color_scheme='NoColor')
         
         # The interactive one is initialized with an offset, meaning we always
         # want to remove the topmost item in the traceback, which is our own
         # internal code. Valid modes: ['Plain','Context','Verbose']
         self.InteractiveTB = ultraTB.AutoFormattedTB(mode = 'Plain',
                                                      color_scheme='NoColor',
                                                      tb_offset = 1)
 
         # IPython itself shouldn't crash. This will produce a detailed
         # post-mortem if it does.  But we only install the crash handler for
         # non-threaded shells, the threaded ones use a normal verbose reporter
         # and lose the crash handler.  This is because exceptions in the main
         # thread (such as in GUI code) propagate directly to sys.excepthook,
         # and there's no point in printing crash dumps for every user exception.
         if self.isthreaded:
             sys.excepthook = ultraTB.FormattedTB()
         else:
             from IPython import CrashHandler
             sys.excepthook = CrashHandler.CrashHandler(self)
 
         # The instance will store a pointer to this, so that runtime code
         # (such as magics) can access it.  This is because during the
         # read-eval loop, it gets temporarily overwritten (to deal with GUI
         # frameworks).
         self.sys_excepthook = sys.excepthook
 
         # and add any custom exception handlers the user may have specified
         self.set_custom_exc(*custom_exceptions)
 
         # indentation management
         self.autoindent = False
         self.indent_current_nsp = 0
 
         # Make some aliases automatically
         # Prepare list of shell aliases to auto-define
         if os.name == 'posix':
             auto_alias = ('mkdir mkdir', 'rmdir rmdir',
                           'mv mv -i','rm rm -i','cp cp -i',
                           'cat cat','less less','clear clear',
                           # a better ls
                           'ls ls -F',
                           # long ls
                           'll ls -lF')
             # Extra ls aliases with color, which need special treatment on BSD
             # variants
             ls_extra = ( # color ls
                          'lc ls -F -o --color',
                          # ls normal files only
                          'lf ls -F -o --color %l | grep ^-',
                          # ls symbolic links
                          'lk ls -F -o --color %l | grep ^l',
                          # directories or links to directories,
                          'ldir ls -F -o --color %l | grep /$',
                          # things which are executable
                          'lx ls -F -o --color %l | grep ^-..x',
                          )
             # The BSDs don't ship GNU ls, so they don't understand the
             # --color switch out of the box
             if 'bsd' in sys.platform:
                 ls_extra = ( # ls normal files only
                              'lf ls -lF | grep ^-',
                              # ls symbolic links
                              'lk ls -lF | grep ^l',
                              # directories or links to directories,
                              'ldir ls -lF | grep /$',
                              # things which are executable
                              'lx ls -lF | grep ^-..x',
                              )
             auto_alias = auto_alias + ls_extra
         elif os.name in ['nt','dos']:
             auto_alias = ('dir dir /on', 'ls dir /on',
                           'ddir dir /ad /on', 'ldir dir /ad /on',
                           'mkdir mkdir','rmdir rmdir','echo echo',
                           'ren ren','cls cls','copy copy')
         else:
             auto_alias = ()
         self.auto_alias = [s.split(None,1) for s in auto_alias]
         # Call the actual (public) initializer
         self.init_auto_alias()
 
         # Produce a public API instance
         self.api = IPython.ipapi.IPApi(self)
 
         # track which builtins we add, so we can clean up later
         self.builtins_added = {}
         # This method will add the necessary builtins for operation, but
         # tracking what it did via the builtins_added dict.
         self.add_builtins()
 
     # end __init__
 
     def pre_config_initialization(self):
         """Pre-configuration init method
 
         This is called before the configuration files are processed to
         prepare the services the config files might need.
         
         self.rc already has reasonable default values at this point.
         """
         rc = self.rc
         
         self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")
     
     def post_config_initialization(self):
         """Post configuration init method
 
         This is called after the configuration files have been processed to
         'finalize' the initialization."""
 
         rc = self.rc
 
         # Object inspector
         self.inspector = OInspect.Inspector(OInspect.InspectColors,
                                             PyColorize.ANSICodeColors,
                                             'NoColor',
                                             rc.object_info_string_level)
         
         # Load readline proper
         if rc.readline:
             self.init_readline()
 
         # local shortcut, this is used a LOT
         self.log = self.logger.log
 
         # Initialize cache, set in/out prompts and printing system
         self.outputcache = CachedOutput(self,
                                         rc.cache_size,
                                         rc.pprint,
                                         input_sep = rc.separate_in,
                                         output_sep = rc.separate_out,
                                         output_sep2 = rc.separate_out2,
                                         ps1 = rc.prompt_in1,
                                         ps2 = rc.prompt_in2,
                                         ps_out = rc.prompt_out,
                                         pad_left = rc.prompts_pad_left)
 
         # user may have over-ridden the default print hook:
         try:
             self.outputcache.__class__.display = self.hooks.display
         except AttributeError:
             pass
 
         # I don't like assigning globally to sys, because it means when embedding
         # instances, each embedded instance overrides the previous choice. But
         # sys.displayhook seems to be called internally by exec, so I don't see a
         # way around it.
         sys.displayhook = self.outputcache
 
         # Set user colors (don't do it in the constructor above so that it
         # doesn't crash if colors option is invalid)
         self.magic_colors(rc.colors)
 
         # Set calling of pdb on exceptions
         self.call_pdb = rc.pdb
 
         # Load user aliases
         for alias in rc.alias:
             self.magic_alias(alias)
         self.hooks.late_startup_hook()
         
         batchrun = False
         for batchfile in [path(arg) for arg in self.rc.args 
             if arg.lower().endswith('.ipy')]:
             if not batchfile.isfile():
                 print "No such batch file:", batchfile
                 continue
             self.api.runlines(batchfile.text())
             batchrun = True
         if batchrun:
             self.exit_now = True            
 
     def add_builtins(self):
         """Store ipython references into the builtin namespace.
 
         Some parts of ipython operate via builtins injected here, which hold a
         reference to IPython itself."""
 
         # TODO: deprecate all except _ip; 'jobs' should be installed 
         # by an extension and the rest are under _ip, ipalias is redundant
         builtins_new  = dict(__IPYTHON__ = self,
                              ip_set_hook = self.set_hook, 
                              jobs = self.jobs,
                              ipmagic = self.ipmagic,  
                              ipalias = self.ipalias,  
                              ipsystem = self.ipsystem,
                              _ip = self.api
                              )
         for biname,bival in builtins_new.items():
             try:
                 # store the orignal value so we can restore it
                 self.builtins_added[biname] =  __builtin__.__dict__[biname]
             except KeyError:
                 # or mark that it wasn't defined, and we'll just delete it at
                 # cleanup
                 self.builtins_added[biname] = Undefined
             __builtin__.__dict__[biname] = bival
             
         # Keep in the builtins a flag for when IPython is active.  We set it
         # with setdefault so that multiple nested IPythons don't clobber one
         # another.  Each will increase its value by one upon being activated,
         # which also gives us a way to determine the nesting level.
         __builtin__.__dict__.setdefault('__IPYTHON__active',0)
 
     def clean_builtins(self):
         """Remove any builtins which might have been added by add_builtins, or
         restore overwritten ones to their previous values."""
         for biname,bival in self.builtins_added.items():
             if bival is Undefined:
                 del __builtin__.__dict__[biname]
             else:
                 __builtin__.__dict__[biname] = bival
         self.builtins_added.clear()
     
     def set_hook(self,name,hook, priority = 50):
         """set_hook(name,hook) -> sets an internal IPython hook.
 
         IPython exposes some of its internal API as user-modifiable hooks.  By
         adding your function to one of these hooks, you can modify IPython's 
         behavior to call at runtime your own routines."""
 
         # At some point in the future, this should validate the hook before it
         # accepts it.  Probably at least check that the hook takes the number
         # of args it's supposed to.
         dp = getattr(self.hooks, name, None)
         if name not in IPython.hooks.__all__:
             print "Warning! Hook '%s' is not one of %s" % (name, IPython.hooks.__all__ )
         if not dp:
             dp = IPython.hooks.CommandChainDispatcher()
         
         f = new.instancemethod(hook,self,self.__class__)
         try:
             dp.add(f,priority)
         except AttributeError:
             # it was not commandchain, plain old func - replace
             dp = f
 
         setattr(self.hooks,name, dp)
         
         
         #setattr(self.hooks,name,new.instancemethod(hook,self,self.__class__))
 
     def set_custom_exc(self,exc_tuple,handler):
         """set_custom_exc(exc_tuple,handler)
 
         Set a custom exception handler, which will be called if any of the
         exceptions in exc_tuple occur in the mainloop (specifically, in the
         runcode() method.
 
         Inputs:
 
           - exc_tuple: a *tuple* of valid exceptions to call the defined
           handler for.  It is very important that you use a tuple, and NOT A
           LIST here, because of the way Python's except statement works.  If
           you only want to trap a single exception, use a singleton tuple:
 
             exc_tuple == (MyCustomException,)
 
           - handler: this must be defined as a function with the following
           basic interface: def my_handler(self,etype,value,tb).
 
           This will be made into an instance method (via new.instancemethod)
           of IPython itself, and it will be called if any of the exceptions
           listed in the exc_tuple are caught.  If the handler is None, an
           internal basic one is used, which just prints basic info.
 
         WARNING: by putting in your own exception handler into IPython's main
         execution loop, you run a very good chance of nasty crashes.  This
         facility should only be used if you really know what you are doing."""
 
         assert type(exc_tuple)==type(()) , \
                "The custom exceptions must be given AS A TUPLE."
 
         def dummy_handler(self,etype,value,tb):
             print '*** Simple custom exception handler ***'
             print 'Exception type :',etype
             print 'Exception value:',value
             print 'Traceback      :',tb
             print 'Source code    :','\n'.join(self.buffer)
 
         if handler is None: handler = dummy_handler
 
         self.CustomTB = new.instancemethod(handler,self,self.__class__)
         self.custom_exceptions = exc_tuple
 
     def set_custom_completer(self,completer,pos=0):
         """set_custom_completer(completer,pos=0)
 
         Adds a new custom completer function.
 
         The position argument (defaults to 0) is the index in the completers
         list where you want the completer to be inserted."""
 
         newcomp = new.instancemethod(completer,self.Completer,
                                      self.Completer.__class__)
         self.Completer.matchers.insert(pos,newcomp)
 
     def _get_call_pdb(self):
         return self._call_pdb
 
     def _set_call_pdb(self,val):
 
         if val not in (0,1,False,True):
             raise ValueError,'new call_pdb value must be boolean'
 
         # store value in instance
         self._call_pdb = val
 
         # notify the actual exception handlers
         self.InteractiveTB.call_pdb = val
         if self.isthreaded:
             try:
                 self.sys_excepthook.call_pdb = val
             except:
                 warn('Failed to activate pdb for threaded exception handler')
 
     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.
 
     # We are basically exposing, via normal python functions, the three
     # mechanisms in which ipython offers special call modes (magics for
     # internal control, aliases for direct system access via pre-selected
     # names, and !cmd for calling arbitrary system commands).
 
     def ipmagic(self,arg_s):
         """Call a magic function by name.
 
         Input: a string containing the name of the magic function to call and any
         additional arguments to be passed to the magic.
 
         ipmagic('name -opt foo bar') is equivalent to typing at the ipython
         prompt:
 
         In[1]: %name -opt foo bar
 
         To call a magic without arguments, simply use ipmagic('name').
 
         This provides a proper Python function to call IPython's magics in any
         valid Python code you can type at the interpreter, including loops and
         compound statements.  It is added by IPython to the Python builtin
         namespace upon initialization."""
 
         args = arg_s.split(' ',1)
         magic_name = args[0]
         magic_name = magic_name.lstrip(self.ESC_MAGIC)
 
         try:
             magic_args = args[1]
         except IndexError:
             magic_args = ''
         fn = getattr(self,'magic_'+magic_name,None)
         if fn is None:
             error("Magic function `%s` not found." % magic_name)
         else:
             magic_args = self.var_expand(magic_args)
             return fn(magic_args)
 
     def ipalias(self,arg_s):
         """Call an alias by name.
 
         Input: a string containing the name of the alias to call and any
         additional arguments to be passed to the magic.
 
         ipalias('name -opt foo bar') is equivalent to typing at the ipython
         prompt:
 
         In[1]: name -opt foo bar
 
         To call an alias without arguments, simply use ipalias('name').
 
         This provides a proper Python function to call IPython's aliases in any
         valid Python code you can type at the interpreter, including loops and
         compound statements.  It is added by IPython to the Python builtin
         namespace upon initialization."""
 
         args = arg_s.split(' ',1)
         alias_name = args[0]
         try:
             alias_args = args[1]
         except IndexError:
             alias_args = ''
         if alias_name in self.alias_table:
             self.call_alias(alias_name,alias_args)
         else:
             error("Alias `%s` not found." % alias_name)
 
     def ipsystem(self,arg_s):
         """Make a system call, using IPython."""
 
         self.system(arg_s)
 
     def complete(self,text):
         """Return a sorted list of all possible completions on text.
 
         Inputs:
 
           - text: a string of text to be completed on.
 
         This is a wrapper around the completion mechanism, similar to what
         readline does at the command line when the TAB key is hit.  By
         exposing it as a method, it can be used by other non-readline
         environments (such as GUIs) for text completion.
 
         Simple usage example:
 
         In [1]: x = 'hello'
 
         In [2]: __IP.complete('x.l')
         Out[2]: ['x.ljust', 'x.lower', 'x.lstrip']"""
         
         complete = self.Completer.complete
         state = 0
         # use a dict so we get unique keys, since ipyhton's multiple
         # completers can return duplicates.
         comps = {}
         while True:
             newcomp = complete(text,state)
             if newcomp is None:
                 break
             comps[newcomp] = 1
             state += 1
         outcomps = comps.keys()
         outcomps.sort()
         return outcomps
         
     def set_completer_frame(self, frame=None):
         if frame:
             self.Completer.namespace = frame.f_locals
             self.Completer.global_namespace = frame.f_globals
         else:
             self.Completer.namespace = self.user_ns
             self.Completer.global_namespace = self.user_global_ns
 
     def init_auto_alias(self):
         """Define some aliases automatically.
 
         These are ALL parameter-less aliases"""
 
         for alias,cmd in self.auto_alias:
             self.alias_table[alias] = (0,cmd)
 
     def alias_table_validate(self,verbose=0):
         """Update information about the alias table.
 
         In particular, make sure no Python keywords/builtins are in it."""
 
         no_alias = self.no_alias
         for k in self.alias_table.keys():
             if k in no_alias:
                 del self.alias_table[k]
                 if verbose:
                     print ("Deleting alias <%s>, it's a Python "
                            "keyword or builtin." % k)
     
     def set_autoindent(self,value=None):
         """Set the autoindent flag, checking for readline support.
 
         If called with no arguments, it acts as a toggle."""
 
         if not self.has_readline:
             if os.name == 'posix':
                 warn("The auto-indent feature requires the readline library")
             self.autoindent = 0
             return
         if value is None:
             self.autoindent = not self.autoindent
         else:
             self.autoindent = value
 
     def rc_set_toggle(self,rc_field,value=None):
         """Set or toggle a field in IPython's rc config. structure.
 
         If called with no arguments, it acts as a toggle.
 
         If called with a non-existent field, the resulting AttributeError
         exception will propagate out."""
 
         rc_val = getattr(self.rc,rc_field)
         if value is None:
             value = not rc_val
         setattr(self.rc,rc_field,value)
 
     def user_setup(self,ipythondir,rc_suffix,mode='install'):
         """Install the user configuration directory.
 
         Can be called when running for the first time or to upgrade the user's
         .ipython/ directory with the mode parameter. Valid modes are 'install'
         and 'upgrade'."""
 
         def wait():
             try:
                 raw_input("Please press <RETURN> to start IPython.")
             except EOFError:
                 print >> Term.cout
             print '*'*70
 
         cwd = os.getcwd()  # remember where we started
         glb = glob.glob
         print '*'*70
         if mode == 'install':
             print \
 """Welcome to IPython. I will try to create a personal configuration directory
 where you can customize many aspects of IPython's functionality in:\n"""
         else:
             print 'I am going to upgrade your configuration in:'
 
         print ipythondir
 
         rcdirend = os.path.join('IPython','UserConfig')
         cfg = lambda d: os.path.join(d,rcdirend)
         try:
             rcdir = filter(os.path.isdir,map(cfg,sys.path))[0]
         except IOError:
             warning = """
 Installation error. IPython's directory was not found.
 
 Check the following:
 
 The ipython/IPython directory should be in a directory belonging to your
 PYTHONPATH environment variable (that is, it should be in a directory
 belonging to sys.path). You can copy it explicitly there or just link to it.
 
 IPython will proceed with builtin defaults.
 """
             warn(warning)
             wait()
             return
 
         if mode == 'install':
             try:
                 shutil.copytree(rcdir,ipythondir)
                 os.chdir(ipythondir)
                 rc_files = glb("ipythonrc*")
                 for rc_file in rc_files:
                     os.rename(rc_file,rc_file+rc_suffix)
             except:
                 warning = """
 
 There was a problem with the installation:
 %s
 Try to correct it or contact the developers if you think it's a bug.
 IPython will proceed with builtin defaults.""" % sys.exc_info()[1]
                 warn(warning)
                 wait()
                 return
 
         elif mode == 'upgrade':
             try:
                 os.chdir(ipythondir)
             except:
                 print """
 Can not upgrade: changing to directory %s failed. Details:
 %s
 """ % (ipythondir,sys.exc_info()[1])
                 wait()
                 return
             else:
                 sources = glb(os.path.join(rcdir,'[A-Za-z]*'))
                 for new_full_path in sources:
                     new_filename = os.path.basename(new_full_path)
                     if new_filename.startswith('ipythonrc'):
                         new_filename = new_filename + rc_suffix
                     # The config directory should only contain files, skip any
                     # directories which may be there (like CVS)
                     if os.path.isdir(new_full_path):
                         continue
                     if os.path.exists(new_filename):
                         old_file = new_filename+'.old'
                         if os.path.exists(old_file):
                             os.remove(old_file)
                         os.rename(new_filename,old_file)
                     shutil.copy(new_full_path,new_filename)
         else:
             raise ValueError,'unrecognized mode for install:',`mode`
 
         # Fix line-endings to those native to each platform in the config
         # directory.
         try:
             os.chdir(ipythondir)
         except:
             print """
 Problem: changing to directory %s failed.
 Details:
 %s
 
 Some configuration files may have incorrect line endings.  This should not
 cause any problems during execution.  """ % (ipythondir,sys.exc_info()[1])
             wait()
         else:
             for fname in glb('ipythonrc*'):
                 try:
                     native_line_ends(fname,backup=0)
                 except IOError:
                     pass
 
         if mode == 'install':
             print """
 Successful installation!
 
 Please read the sections 'Initial Configuration' and 'Quick Tips' in the
 IPython manual (there are both HTML and PDF versions supplied with the
 distribution) to make sure that your system environment is properly configured
 to take advantage of IPython's features.
 
 Important note: the configuration system has changed! The old system is
 still in place, but its setting may be partly overridden by the settings in 
 "~/.ipython/ipy_user_conf.py" config file. Please take a look at the file 
 if some of the new settings bother you. 
 
 """
         else:
             print """
 Successful upgrade!
 
 All files in your directory:
 %(ipythondir)s
 which would have been overwritten by the upgrade were backed up with a .old
 extension.  If you had made particular customizations in those files you may
 want to merge them back into the new files.""" % locals()
         wait()
         os.chdir(cwd)
         # end user_setup()
 
     def atexit_operations(self):
         """This will be executed at the time of exit.
 
         Saving of persistent data should be performed here. """
 
         #print '*** IPython exit cleanup ***' # dbg
         # input history
         self.savehist()
 
         # Cleanup all tempfiles left around
         for tfile in self.tempfiles:
             try:
                 os.unlink(tfile)
             except OSError:
                 pass
 
         # save the "persistent data" catch-all dictionary
         self.hooks.shutdown_hook()
         
     def savehist(self):
         """Save input history to a file (via readline library)."""
         try:
             self.readline.write_history_file(self.histfile)
         except:
             print 'Unable to save IPython command history to file: ' + \
                   `self.histfile`
 
     def pre_readline(self):
         """readline hook to be used at the start of each line.
 
         Currently it handles auto-indent only."""
 
         #debugx('self.indent_current_nsp','pre_readline:')
         self.readline.insert_text(self.indent_current_str())
 
     def init_readline(self):
         """Command history completion/saving/reloading."""
 
         import IPython.rlineimpl as readline
         if not readline.have_readline:
             self.has_readline = 0
             self.readline = None
             # no point in bugging windows users with this every time:
             warn('Readline services not available on this platform.')
         else:
             sys.modules['readline'] = readline
             import atexit
             from IPython.completer import IPCompleter
             self.Completer = IPCompleter(self,
                                             self.user_ns,
                                             self.user_global_ns,
                                             self.rc.readline_omit__names,
                                             self.alias_table)
 
             # Platform-specific configuration
             if os.name == 'nt':
                 self.readline_startup_hook = readline.set_pre_input_hook
             else:
                 self.readline_startup_hook = readline.set_startup_hook
 
             # Load user's initrc file (readline config)
             inputrc_name = os.environ.get('INPUTRC')
             if inputrc_name is None:
                 home_dir = get_home_dir()
                 if home_dir is not None:
                     inputrc_name = os.path.join(home_dir,'.inputrc')
             if os.path.isfile(inputrc_name):
                 try:
                     readline.read_init_file(inputrc_name)
                 except:
                     warn('Problems reading readline initialization file <%s>'
                          % inputrc_name)
             
             self.has_readline = 1
             self.readline = readline
             # save this in sys so embedded copies can restore it properly
             sys.ipcompleter = self.Completer.complete
             readline.set_completer(self.Completer.complete)
 
             # Configure readline according to user's prefs
             for rlcommand in self.rc.readline_parse_and_bind:
                 readline.parse_and_bind(rlcommand)
 
             # remove some chars from the delimiters list
             delims = readline.get_completer_delims()
             delims = delims.translate(string._idmap,
                                       self.rc.readline_remove_delims)
             readline.set_completer_delims(delims)
             # otherwise we end up with a monster history after a while:
             readline.set_history_length(1000)
             try:
                 #print '*** Reading readline history'  # dbg
                 readline.read_history_file(self.histfile)
             except IOError:
                 pass  # It doesn't exist yet.
 
             atexit.register(self.atexit_operations)
             del atexit
 
         # Configure auto-indent for all platforms
         self.set_autoindent(self.rc.autoindent)
 
     def ask_yes_no(self,prompt,default=True):
         if self.rc.quiet:
             return True
         return ask_yes_no(prompt,default)
     
     def _should_recompile(self,e):
         """Utility routine for edit_syntax_error"""
 
         if e.filename in ('<ipython console>','<input>','<string>',
                           '<console>','<BackgroundJob compilation>',
                           None):
                               
             return False
         try:
             if (self.rc.autoedit_syntax and 
                 not self.ask_yes_no('Return to editor to correct syntax error? '
                               '[Y/n] ','y')):
                 return False
         except EOFError:
             return False
 
         def int0(x):
             try:
                 return int(x)
             except TypeError:
                 return 0
         # always pass integer line and offset values to editor hook
         self.hooks.fix_error_editor(e.filename,
             int0(e.lineno),int0(e.offset),e.msg)
         return True
         
     def edit_syntax_error(self):
         """The bottom half of the syntax error handler called in the main loop.
 
         Loop until syntax error is fixed or user cancels.
         """
 
         while self.SyntaxTB.last_syntax_error:
             # copy and clear last_syntax_error
             err = self.SyntaxTB.clear_err_state()
             if not self._should_recompile(err):
                 return
             try:
                 # may set last_syntax_error again if a SyntaxError is raised
                 self.safe_execfile(err.filename,self.user_ns)
             except:
                 self.showtraceback()
             else:
                 try:
                     f = file(err.filename)
                     try:
                         sys.displayhook(f.read())
                     finally:
                         f.close()
                 except:
                     self.showtraceback()
 
     def showsyntaxerror(self, filename=None):
         """Display the syntax error that just occurred.
 
         This doesn't display a stack trace because there isn't one.
 
         If a filename is given, it is stuffed in the exception instead
         of what was there before (because Python's parser always uses
         "<string>" when reading from a string).
         """
         etype, value, last_traceback = sys.exc_info()
 
         # See note about these variables in showtraceback() below
         sys.last_type = etype
         sys.last_value = value
         sys.last_traceback = last_traceback
         
         if filename and etype is SyntaxError:
             # Work hard to stuff the correct filename in the exception
             try:
                 msg, (dummy_filename, lineno, offset, line) = value
             except:
                 # Not the format we expect; leave it alone
                 pass
             else:
                 # Stuff in the right filename
                 try:
                     # Assume SyntaxError is a class exception
                     value = SyntaxError(msg, (filename, lineno, offset, line))
                 except:
                     # If that failed, assume SyntaxError is a string
                     value = msg, (filename, lineno, offset, line)
         self.SyntaxTB(etype,value,[])
 
     def debugger(self):
         """Call the pdb debugger."""
 
         if not self.rc.pdb:
             return
         pdb.pm()
 
     def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None):
         """Display the exception that just occurred.
 
         If nothing is known about the exception, this is the method which
         should be used throughout the code for presenting user tracebacks,
         rather than directly invoking the InteractiveTB object.
 
         A specific showsyntaxerror() also exists, but this method can take
         care of calling it if needed, so unless you are explicitly catching a
         SyntaxError exception, don't try to analyze the stack manually and
         simply call this method."""
 
         # Though this won't be called by syntax errors in the input line,
         # there may be SyntaxError cases whith imported code.
         if exc_tuple is None:
             etype, value, tb = sys.exc_info()
         else:
             etype, value, tb = exc_tuple
         if etype is SyntaxError:
             self.showsyntaxerror(filename)
         else:
             # WARNING: these variables are somewhat deprecated and not
             # necessarily safe to use in a threaded environment, but tools
             # like pdb depend on their existence, so let's set them.  If we
             # find problems in the field, we'll need to revisit their use.
             sys.last_type = etype
             sys.last_value = value
             sys.last_traceback = tb
             
             self.InteractiveTB(etype,value,tb,tb_offset=tb_offset)
             if self.InteractiveTB.call_pdb and self.has_readline:
                 # pdb mucks up readline, fix it back
                 self.readline.set_completer(self.Completer.complete)
 
     def mainloop(self,banner=None):
         """Creates the local namespace and starts the mainloop.
 
         If an optional banner argument is given, it will override the
         internally created default banner."""
 
         if self.rc.c:  # Emulate Python's -c option
             self.exec_init_cmd()
         if banner is None:
             if not self.rc.banner:
                 banner = ''
             # banner is string? Use it directly!
             elif isinstance(self.rc.banner,basestring):
                 banner = self.rc.banner
             else:                
                 banner = self.BANNER+self.banner2
 
         self.interact(banner)
 
     def exec_init_cmd(self):
         """Execute a command given at the command line.
 
         This emulates Python's -c option."""
 
         #sys.argv = ['-c']
         self.push(self.rc.c)
 
     def embed_mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
         """Embeds IPython into a running python program.
 
         Input:
 
           - header: An optional header message can be specified.
 
           - local_ns, global_ns: working namespaces. If given as None, the
           IPython-initialized one is updated with __main__.__dict__, so that
           program variables become visible but user-specific configuration
           remains possible.
 
           - stack_depth: specifies how many levels in the stack to go to
           looking for namespaces (when local_ns and global_ns are None).  This
           allows an intermediate caller to make sure that this function gets
           the namespace from the intended level in the stack.  By default (0)
           it will get its locals and globals from the immediate caller.
 
         Warning: it's possible to use this in a program which is being run by
         IPython itself (via %run), but some funny things will happen (a few
         globals get overwritten). In the future this will be cleaned up, as
         there is no fundamental reason why it can't work perfectly."""
 
         # Get locals and globals from caller
         if local_ns is None or global_ns is None:
             call_frame = sys._getframe(stack_depth).f_back
 
             if local_ns is None:
                 local_ns = call_frame.f_locals
             if global_ns is None:
                 global_ns = call_frame.f_globals
 
         # Update namespaces and fire up interpreter
 
         # The global one is easy, we can just throw it in
         self.user_global_ns = global_ns
 
         # but the user/local one is tricky: ipython needs it to store internal
         # data, but we also need the locals.  We'll copy locals in the user
         # one, but will track what got copied so we can delete them at exit.
         # This is so that a later embedded call doesn't see locals from a
         # previous call (which most likely existed in a separate scope).
         local_varnames = local_ns.keys()
         self.user_ns.update(local_ns)
 
         # Patch for global embedding to make sure that things don't overwrite
         # user globals accidentally. Thanks to Richard <[e-mail]>
         # FIXME. Test this a bit more carefully (the if.. is new)
         if local_ns is None and global_ns is None:
             self.user_global_ns.update(__main__.__dict__)
 
         # make sure the tab-completer has the correct frame information, so it
         # actually completes using the frame's locals/globals
         self.set_completer_frame()
 
         # before activating the interactive mode, we need to make sure that
         # all names in the builtin namespace needed by ipython point to
         # ourselves, and not to other instances.
         self.add_builtins()
         
         self.interact(header)
         
         # now, purge out the user namespace from anything we might have added
         # from the caller's local namespace
         delvar = self.user_ns.pop
         for var in local_varnames:
             delvar(var,None)
         # and clean builtins we may have overridden
         self.clean_builtins()
 
     def interact(self, banner=None):
         """Closely emulate the interactive Python console.
 
         The optional banner argument specify the banner to print
         before the first interaction; by default it prints a banner
         similar to the one printed by the real Python interpreter,
         followed by the current class name in parentheses (so as not
         to confuse this with the real interpreter -- since it's so
         close!).
 
         """
         
         if self.exit_now:
             # batch run -> do not interact
             return
         cprt = 'Type "copyright", "credits" or "license" for more information.'
         if banner is None:
             self.write("Python %s on %s\n%s\n(%s)\n" %
                        (sys.version, sys.platform, cprt,
                         self.__class__.__name__))
         else:
             self.write(banner)
 
         more = 0
         
         # Mark activity in the builtins
         __builtin__.__dict__['__IPYTHON__active'] += 1
 
         # exit_now is set by a call to %Exit or %Quit
         while not self.exit_now:
             if more:
                 prompt = self.hooks.generate_prompt(True)
                 if self.autoindent:
                     self.readline_startup_hook(self.pre_readline)
             else:
                 prompt = self.hooks.generate_prompt(False)
             try:
                 line = self.raw_input(prompt,more)
                 if self.autoindent:
                     self.readline_startup_hook(None)
             except KeyboardInterrupt:
                 self.write('\nKeyboardInterrupt\n')
                 self.resetbuffer()
                 # keep cache in sync with the prompt counter:
                 self.outputcache.prompt_count -= 1
 
                 if self.autoindent:
                     self.indent_current_nsp = 0
                 more = 0
             except EOFError:
                 if self.autoindent:
                     self.readline_startup_hook(None)
                 self.write('\n')
                 self.exit()
             except bdb.BdbQuit:
                 warn('The Python debugger has exited with a BdbQuit exception.\n'
                      'Because of how pdb handles the stack, it is impossible\n'
                      'for IPython to properly format this particular exception.\n'
                      'IPython will resume normal operation.')
             except:
                 # exceptions here are VERY RARE, but they can be triggered
                 # asynchronously by signal handlers, for example.
                 self.showtraceback()
             else:
                 more = self.push(line)
                 if (self.SyntaxTB.last_syntax_error and
                     self.rc.autoedit_syntax):
                     self.edit_syntax_error()
             
         # We are off again...
         __builtin__.__dict__['__IPYTHON__active'] -= 1
 
     def excepthook(self, etype, value, tb):
       """One more defense for GUI apps that call sys.excepthook.
 
       GUI frameworks like wxPython trap exceptions and call
       sys.excepthook themselves.  I guess this is a feature that
       enables them to keep running after exceptions that would
       otherwise kill their mainloop. This is a bother for IPython
       which excepts to catch all of the program exceptions with a try:
       except: statement.
 
       Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
       any app directly invokes sys.excepthook, it will look to the user like
       IPython crashed.  In order to work around this, we can disable the
       CrashHandler and replace it with this excepthook instead, which prints a
       regular traceback using our InteractiveTB.  In this fashion, apps which
       call sys.excepthook will generate a regular-looking exception from
       IPython, and the CrashHandler will only be triggered by real IPython
       crashes.
 
       This hook should be used sparingly, only in places which are not likely
       to be true IPython errors.
       """
       self.showtraceback((etype,value,tb),tb_offset=0)
 
     def transform_alias(self, alias,rest=''):
         """ Transform alias to system command string.
         """
         nargs,cmd = self.alias_table[alias]
         if ' ' in cmd and os.path.isfile(cmd):
             cmd = '"%s"' % cmd
 
         # Expand the %l special to be the user's input line
         if cmd.find('%l') >= 0:
             cmd = cmd.replace('%l',rest)
             rest = ''
         if nargs==0:
             # Simple, argument-less aliases
             cmd = '%s %s' % (cmd,rest)
         else:
             # Handle aliases with positional arguments
             args = rest.split(None,nargs)
             if len(args)< nargs:
                 error('Alias <%s> requires %s arguments, %s given.' %
                       (alias,nargs,len(args)))
                 return None
             cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
         # Now call the macro, evaluating in the user's namespace
         #print 'new command: <%r>' % cmd  # dbg
         return cmd
         
     def call_alias(self,alias,rest=''):
         """Call an alias given its name and the rest of the line.
 
         This is only used to provide backwards compatibility for users of
         ipalias(), use of which is not recommended for anymore."""
 
         # Now call the macro, evaluating in the user's namespace
         cmd = self.transform_alias(alias, rest)
         try:
             self.system(cmd)
         except:
             self.showtraceback()
 
     def indent_current_str(self):
         """return the current level of indentation as a string"""
         return self.indent_current_nsp * ' '
 
     def autoindent_update(self,line):
         """Keep track of the indent level."""
 
         #debugx('line')
         #debugx('self.indent_current_nsp')
         if self.autoindent:
             if line:
                 inisp = num_ini_spaces(line)
                 if inisp < self.indent_current_nsp:
                     self.indent_current_nsp = inisp
 
                 if line[-1] == ':':
                     self.indent_current_nsp += 4
                 elif dedent_re.match(line):
                     self.indent_current_nsp -= 4
             else:
                 self.indent_current_nsp = 0
 
     def runlines(self,lines):
         """Run a string of one or more lines of source.
 
         This method is capable of running a string containing multiple source
         lines, as if they had been entered at the IPython prompt.  Since it
         exposes IPython's processing machinery, the given strings can contain
         magic calls (%magic), special shell access (!cmd), etc."""
 
         # We must start with a clean buffer, in case this is run from an
         # interactive IPython session (via a magic, for example).
         self.resetbuffer()
         lines = lines.split('\n')
         more = 0
         for line in lines:
             # skip blank lines so we don't mess up the prompt counter, but do
             # NOT skip even a blank line if we are in a code block (more is
             # true)
             if line or more:
                 more = self.push(self.prefilter(line,more))
                 # IPython's runsource returns None if there was an error
                 # compiling the code.  This allows us to stop processing right
                 # away, so the user gets the error message at the right place.
                 if more is None:
                     break
         # final newline in case the input didn't have it, so that the code
         # actually does get executed
         if more:
             self.push('\n')
 
     def runsource(self, source, filename='<input>', symbol='single'):
         """Compile and run some source in the interpreter.
 
         Arguments are as for compile_command().
 
         One several things can happen:
 
         1) The input is incorrect; compile_command() raised an
         exception (SyntaxError or OverflowError).  A syntax traceback
         will be printed by calling the showsyntaxerror() method.
 
         2) The input is incomplete, and more input is required;
         compile_command() returned None.  Nothing happens.
 
         3) The input is complete; compile_command() returned a code
         object.  The code is executed by calling self.runcode() (which
         also handles run-time exceptions, except for SystemExit).
 
         The return value is:
 
           - True in case 2
 
           - False in the other cases, unless an exception is raised, where
           None is returned instead.  This can be used by external callers to
           know whether to continue feeding input or not.
 
         The return value can be used to decide whether to use sys.ps1 or
         sys.ps2 to prompt the next line."""
 
         try:
             code = self.compile(source,filename,symbol)
         except (OverflowError, SyntaxError, ValueError):
             # Case 1
             self.showsyntaxerror(filename)
             return None
 
         if code is None:
             # Case 2
             return True
 
         # Case 3
         # We store the code object so that threaded shells and
         # custom exception handlers can access all this info if needed.
         # The source corresponding to this can be obtained from the
         # buffer attribute as '\n'.join(self.buffer).
         self.code_to_run = code
         # now actually execute the code object
         if self.runcode(code) == 0:
             return False
         else:
             return None
 
     def runcode(self,code_obj):
         """Execute a code object.
 
         When an exception occurs, self.showtraceback() is called to display a
         traceback.
 
         Return value: a flag indicating whether the code to be run completed
         successfully:
 
           - 0: successful execution.
           - 1: an error occurred.
         """
 
         # Set our own excepthook in case the user code tries to call it
         # directly, so that the IPython crash handler doesn't get triggered
         old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
 
         # we save the original sys.excepthook in the instance, in case config
         # code (such as magics) needs access to it.
         self.sys_excepthook = old_excepthook
         outflag = 1  # happens in more places, so it's easier as default
         try:
             try:
                 # Embedded instances require separate global/local namespaces
                 # so they can see both the surrounding (local) namespace and
                 # the module-level globals when called inside another function.
                 if self.embedded:
                     exec code_obj in self.user_global_ns, self.user_ns
                 # Normal (non-embedded) instances should only have a single
                 # namespace for user code execution, otherwise functions won't
                 # see interactive top-level globals.
                 else:
                     exec code_obj in self.user_ns
             finally:
                 # Reset our crash handler in place
                 sys.excepthook = old_excepthook
         except SystemExit:
             self.resetbuffer()
             self.showtraceback()
             warn("Type %exit or %quit to exit IPython "
                  "(%Exit or %Quit do so unconditionally).",level=1)
         except self.custom_exceptions:
             etype,value,tb = sys.exc_info()
             self.CustomTB(etype,value,tb)
         except:
             self.showtraceback()
         else:
             outflag = 0
             if softspace(sys.stdout, 0):
                 print
         # Flush out code object which has been run (and source)
         self.code_to_run = None
         return outflag
         
     def push(self, line):
         """Push a line to the interpreter.
 
         The line should not have a trailing newline; it may have
         internal newlines.  The line is appended to a buffer and the
         interpreter's runsource() method is called with the
         concatenated contents of the buffer as source.  If this
         indicates that the command was executed or invalid, the buffer
         is reset; otherwise, the command is incomplete, and the buffer
         is left as it was after the line was appended.  The return
         value is 1 if more input is required, 0 if the line was dealt
         with in some way (this is the same as runsource()).
         """
 
         # autoindent management should be done here, and not in the
         # interactive loop, since that one is only seen by keyboard input.  We
         # need this done correctly even for code run via runlines (which uses
         # push).
 
         #print 'push line: <%s>' % line  # dbg
         for subline in line.splitlines():
             self.autoindent_update(subline)
         self.buffer.append(line)
         more = self.runsource('\n'.join(self.buffer), self.filename)
         if not more:
             self.resetbuffer()
         return more
 
     def resetbuffer(self):
         """Reset the input buffer."""
         self.buffer[:] = []
         
     def raw_input(self,prompt='',continue_prompt=False):
         """Write a prompt and read a line.
 
         The returned line does not include the trailing newline.
         When the user enters the EOF key sequence, EOFError is raised.
 
         Optional inputs:
 
           - prompt(''): a string to be printed to prompt the user.
 
           - continue_prompt(False): whether this line is the first one or a
           continuation in a sequence of inputs.
         """
 
-        try:
-            line = raw_input_original(prompt)
-        except ValueError:
-            # python 2.5 closes stdin on exit -> ValueError
-            # xxx should we delete 'exit' and 'quit' from builtin?
-            self.exit_now = True
-            return ''
-            
+        line = raw_input_original(prompt)
 
         # Try to be reasonably smart about not re-indenting pasted input more
         # than necessary.  We do this by trimming out the auto-indent initial
         # spaces, if the user's actual input started itself with whitespace.
         #debugx('self.buffer[-1]')
 
         if self.autoindent:
             if num_ini_spaces(line) > self.indent_current_nsp:
                 line = line[self.indent_current_nsp:]
                 self.indent_current_nsp = 0
             
         # store the unfiltered input before the user has any chance to modify
         # it.
         if line.strip():
             if continue_prompt:
                 self.input_hist_raw[-1] += '%s\n' % line
                 if self.has_readline: # and some config option is set?
                     try:
                         histlen = self.readline.get_current_history_length()
                         newhist = self.input_hist_raw[-1].rstrip()
                         self.readline.remove_history_item(histlen-1)
                         self.readline.replace_history_item(histlen-2,newhist)
                     except AttributeError:
                         pass # re{move,place}_history_item are new in 2.4.                
             else:
                 self.input_hist_raw.append('%s\n' % line)
 
         try:
             lineout = self.prefilter(line,continue_prompt)
         except:
             # blanket except, in case a user-defined prefilter crashes, so it
             # can't take all of ipython with it.
             self.showtraceback()
             return ''
         else:
             return lineout
         
     def split_user_input(self,line):
         """Split user input into pre-char, function part and rest."""
 
         lsplit = self.line_split.match(line)
         if lsplit is None:  # no regexp match returns None
             try:
                 iFun,theRest = line.split(None,1)
             except ValueError:
                 iFun,theRest = line,''
             pre = re.match('^(\s*)(.*)',line).groups()[0]
         else:
             pre,iFun,theRest = lsplit.groups()
 
         #print 'line:<%s>' % line # dbg
         #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun.strip(),theRest) # dbg
         return pre,iFun.strip(),theRest
 
     def _prefilter(self, line, continue_prompt):
         """Calls different preprocessors, depending on the form of line."""
 
         # All handlers *must* return a value, even if it's blank ('').
 
         # Lines are NOT logged here. Handlers should process the line as
         # needed, update the cache AND log it (so that the input cache array
         # stays synced).
 
         # This function is _very_ delicate, and since it's also the one which
         # determines IPython's response to user input, it must be as efficient
         # as possible.  For this reason it has _many_ returns in it, trying
         # always to exit as quickly as it can figure out what it needs to do.
 
         # This function is the main responsible for maintaining IPython's
         # behavior respectful of Python's semantics.  So be _very_ careful if
         # making changes to anything here.
 
         #.....................................................................
         # Code begins
 
         #if line.startswith('%crash'): raise RuntimeError,'Crash now!'  # dbg
 
         # save the line away in case we crash, so the post-mortem handler can
         # record it
         self._last_input_line = line
 
         #print '***line: <%s>' % line # dbg
         
         # the input history needs to track even empty lines
         stripped = line.strip()
         
         if not stripped:
             if not continue_prompt:
                 self.outputcache.prompt_count -= 1
             return self.handle_normal(line,continue_prompt)
             #return self.handle_normal('',continue_prompt)
 
         # print '***cont',continue_prompt  # dbg
         # special handlers are only allowed for single line statements
         if continue_prompt and not self.rc.multi_line_specials:
             return self.handle_normal(line,continue_prompt)
 
 
         # For the rest, we need the structure of the input
         pre,iFun,theRest = self.split_user_input(line)
 
         # See whether any pre-existing handler can take care of it
         
         rewritten = self.hooks.input_prefilter(stripped)
         if rewritten != stripped: # ok, some prefilter did something
             rewritten = pre + rewritten  # add indentation
             return self.handle_normal(rewritten)
             
         #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest)  # dbg
 
         # First check for explicit escapes in the last/first character
         handler = None
         if line[-1] == self.ESC_HELP:
             handler = self.esc_handlers.get(line[-1])  # the ? can be at the end
         if handler is None:
             # look at the first character of iFun, NOT of line, so we skip
             # leading whitespace in multiline input
             handler = self.esc_handlers.get(iFun[0:1])
         if handler is not None:
             return handler(line,continue_prompt,pre,iFun,theRest)
         # Emacs ipython-mode tags certain input lines
         if line.endswith('# PYTHON-MODE'):
             return self.handle_emacs(line,continue_prompt)
 
         # Next, check if we can automatically execute this thing
 
         # Allow ! in multi-line statements if multi_line_specials is on:
         if continue_prompt and self.rc.multi_line_specials and \
                iFun.startswith(self.ESC_SHELL):
             return self.handle_shell_escape(line,continue_prompt,
                                             pre=pre,iFun=iFun,
                                             theRest=theRest)
 
         # Let's try to find if the input line is a magic fn
         oinfo = None
         if hasattr(self,'magic_'+iFun):
             # WARNING: _ofind uses getattr(), so it can consume generators and
             # cause other side effects.
             oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
             if oinfo['ismagic']:
                 # Be careful not to call magics when a variable assignment is
                 # being made (ls='hi', for example)
                 if self.rc.automagic and \
                        (len(theRest)==0 or theRest[0] not in '!=()<>,') and \
                        (self.rc.multi_line_specials or not continue_prompt):
                     return self.handle_magic(line,continue_prompt,
                                              pre,iFun,theRest)
                 else:
                     return self.handle_normal(line,continue_prompt)
 
         # If the rest of the line begins with an (in)equality, assginment or
         # function call, we should not call _ofind but simply execute it.
         # This avoids spurious geattr() accesses on objects upon assignment.
         #
         # It also allows users to assign to either alias or magic names true
         # python variables (the magic/alias systems always take second seat to
         # true python code).
         if theRest and theRest[0] in '!=()':
             return self.handle_normal(line,continue_prompt)
 
         if oinfo is None:
             # let's try to ensure that _oinfo is ONLY called when autocall is
             # on.  Since it has inevitable potential side effects, at least
             # having autocall off should be a guarantee to the user that no
             # weird things will happen.
 
             if self.rc.autocall:
                 oinfo = self._ofind(iFun) # FIXME - _ofind is part of Magic
             else:
                 # in this case, all that's left is either an alias or
                 # processing the line normally.
                 if iFun in self.alias_table:
                     # if autocall is off, by not running _ofind we won't know
                     # whether the given name may also exist in one of the
                     # user's namespace.  At this point, it's best to do a
                     # quick check just to be sure that we don't let aliases
                     # shadow variables.
                     head = iFun.split('.',1)[0]
                     if head in self.user_ns or head in self.internal_ns \
                        or head in __builtin__.__dict__:
                         return self.handle_normal(line,continue_prompt)
                     else:
                         return self.handle_alias(line,continue_prompt,
                                                  pre,iFun,theRest)
                  
                 else:
                     return self.handle_normal(line,continue_prompt)
         
         if not oinfo['found']:
             return self.handle_normal(line,continue_prompt)
         else:
             #print 'pre<%s> iFun <%s> rest <%s>' % (pre,iFun,theRest) # dbg
             if oinfo['isalias']:
                 return self.handle_alias(line,continue_prompt,
                                              pre,iFun,theRest)
 
             if (self.rc.autocall 
                  and
                    (
                    #only consider exclusion re if not "," or ";" autoquoting
                    (pre == self.ESC_QUOTE or pre == self.ESC_QUOTE2
                      or pre == self.ESC_PAREN) or 
                    (not self.re_exclude_auto.match(theRest)))
                  and 
                    self.re_fun_name.match(iFun) and 
                    callable(oinfo['obj'])) :
                 #print 'going auto'  # dbg
                 return self.handle_auto(line,continue_prompt,
                                         pre,iFun,theRest,oinfo['obj'])
             else:
                 #print 'was callable?', callable(oinfo['obj'])  # dbg
                 return self.handle_normal(line,continue_prompt)
 
         # If we get here, we have a normal Python line. Log and return.
         return self.handle_normal(line,continue_prompt)
 
     def _prefilter_dumb(self, line, continue_prompt):
         """simple prefilter function, for debugging"""
         return self.handle_normal(line,continue_prompt)
 
     
     def multiline_prefilter(self, line, continue_prompt):
         """ Run _prefilter for each line of input
         
         Covers cases where there are multiple lines in the user entry,
         which is the case when the user goes back to a multiline history
         entry and presses enter.
         
         """
         out = []
         for l in line.rstrip('\n').split('\n'):
             out.append(self._prefilter(l, continue_prompt))
         return '\n'.join(out)
     
     # Set the default prefilter() function (this can be user-overridden)
     prefilter = multiline_prefilter
 
     def handle_normal(self,line,continue_prompt=None,
                       pre=None,iFun=None,theRest=None):
         """Handle normal input lines. Use as a template for handlers."""
 
         # With autoindent on, we need some way to exit the input loop, and I
         # don't want to force the user to have to backspace all the way to
         # clear the line.  The rule will be in this case, that either two
         # lines of pure whitespace in a row, or a line of pure whitespace but
         # of a size different to the indent level, will exit the input loop.
         
         if (continue_prompt and self.autoindent and line.isspace() and
             (0 < abs(len(line) - self.indent_current_nsp) <= 2 or
              (self.buffer[-1]).isspace() )):
             line = ''
 
         self.log(line,line,continue_prompt)
         return line
 
     def handle_alias(self,line,continue_prompt=None,
                      pre=None,iFun=None,theRest=None):
         """Handle alias input lines. """
 
         # pre is needed, because it carries the leading whitespace.  Otherwise
         # aliases won't work in indented sections.
         transformed = self.transform_alias(iFun, theRest)        
         line_out = '%s_ip.system(%s)' % (pre, make_quoted_expr( transformed ))        
         self.log(line,line_out,continue_prompt)
         #print 'line out:',line_out # dbg
         return line_out
 
     def handle_shell_escape(self, line, continue_prompt=None,
                             pre=None,iFun=None,theRest=None):
         """Execute the line in a shell, empty return value"""
 
         #print 'line in :', `line` # dbg
         # Example of a special handler. Others follow a similar pattern.
         if line.lstrip().startswith('!!'):
             # rewrite iFun/theRest to properly hold the call to %sx and
             # the actual command to be executed, so handle_magic can work
             # correctly
             theRest = '%s %s' % (iFun[2:],theRest)
             iFun = 'sx'
             return self.handle_magic('%ssx %s' % (self.ESC_MAGIC,
                                      line.lstrip()[2:]),
                                      continue_prompt,pre,iFun,theRest)
         else:
             cmd=line.lstrip().lstrip('!')
             line_out = '%s_ip.system(%s)' % (pre,make_quoted_expr(cmd))
         # update cache/log and return
         self.log(line,line_out,continue_prompt)
         return line_out
 
     def handle_magic(self, line, continue_prompt=None,
                      pre=None,iFun=None,theRest=None):
         """Execute magic functions."""
 
 
         cmd = '%s_ip.magic(%s)' % (pre,make_quoted_expr(iFun + " " + theRest))
         self.log(line,cmd,continue_prompt)
         #print 'in handle_magic, cmd=<%s>' % cmd  # dbg
         return cmd
 
     def handle_auto(self, line, continue_prompt=None,
                     pre=None,iFun=None,theRest=None,obj=None):
         """Hande lines which can be auto-executed, quoting if requested."""
 
         #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest)  # dbg
         
         # This should only be active for single-line input!
         if continue_prompt:
             self.log(line,line,continue_prompt)
             return line
 
         auto_rewrite = True
         
         if pre == self.ESC_QUOTE:
             # Auto-quote splitting on whitespace
             newcmd = '%s("%s")' % (iFun,'", "'.join(theRest.split()) )
         elif pre == self.ESC_QUOTE2:
             # Auto-quote whole string
             newcmd = '%s("%s")' % (iFun,theRest)
         elif pre == self.ESC_PAREN:
             newcmd = '%s(%s)' % (iFun,",".join(theRest.split()))
         else:
             # Auto-paren.
             # We only apply it to argument-less calls if the autocall
             # parameter is set to 2.  We only need to check that autocall is <
             # 2, since this function isn't called unless it's at least 1.
             if not theRest and (self.rc.autocall < 2):
                 newcmd = '%s %s' % (iFun,theRest)
                 auto_rewrite = False
             else:
                 if theRest.startswith('['):
                     if hasattr(obj,'__getitem__'):
                         # Don't autocall in this case: item access for an object
                         # which is BOTH callable and implements __getitem__.
                         newcmd = '%s %s' % (iFun,theRest)
                         auto_rewrite = False
                     else:
                         # if the object doesn't support [] access, go ahead and
                         # autocall
                         newcmd = '%s(%s)' % (iFun.rstrip(),theRest)
                 elif theRest.endswith(';'):
                     newcmd = '%s(%s);' % (iFun.rstrip(),theRest[:-1])
                 else:
                     newcmd = '%s(%s)' % (iFun.rstrip(), theRest)
 
         if auto_rewrite:
             print >>Term.cout, self.outputcache.prompt1.auto_rewrite() + newcmd
         # log what is now valid Python, not the actual user input (without the
         # final newline)
         self.log(line,newcmd,continue_prompt)
         return newcmd
 
     def handle_help(self, line, continue_prompt=None,
                     pre=None,iFun=None,theRest=None):
         """Try to get some help for the object.
 
         obj? or ?obj   -> basic information.
         obj?? or ??obj -> more details.
         """
 
         # We need to make sure that we don't process lines which would be
         # otherwise valid python, such as "x=1 # what?"
         try:
             codeop.compile_command(line)
         except SyntaxError:
             # We should only handle as help stuff which is NOT valid syntax
             if line[0]==self.ESC_HELP:
                 line = line[1:]
             elif line[-1]==self.ESC_HELP:
                 line = line[:-1]
             self.log(line,'#?'+line,continue_prompt)
             if line:
                 self.magic_pinfo(line)
             else:
                 page(self.usage,screen_lines=self.rc.screen_length)
             return '' # Empty string is needed here!
         except:
             # Pass any other exceptions through to the normal handler
             return self.handle_normal(line,continue_prompt)
         else:
             # If the code compiles ok, we should handle it normally
             return self.handle_normal(line,continue_prompt)
 
     def getapi(self):
         """ Get an IPApi object for this shell instance
         
         Getting an IPApi object is always preferable to accessing the shell
         directly, but this holds true especially for extensions.
         
         It should always be possible to implement an extension with IPApi
         alone. If not, contact maintainer to request an addition.
         
         """
         return self.api
     
     def handle_emacs(self,line,continue_prompt=None,
                     pre=None,iFun=None,theRest=None):
         """Handle input lines marked by python-mode."""
 
         # Currently, nothing is done.  Later more functionality can be added
         # here if needed.
 
         # The input cache shouldn't be updated
 
         return line
 
     def mktempfile(self,data=None):
         """Make a new tempfile and return its filename.
 
         This makes a call to tempfile.mktemp, but it registers the created
         filename internally so ipython cleans it up at exit time.
 
         Optional inputs:
 
           - data(None): if data is given, it gets written out to the temp file
           immediately, and the file is closed again."""
 
         filename = tempfile.mktemp('.py','ipython_edit_')
         self.tempfiles.append(filename)
         
         if data:
             tmp_file = open(filename,'w')
             tmp_file.write(data)
             tmp_file.close()
         return filename
 
     def write(self,data):
         """Write a string to the default output"""
         Term.cout.write(data)
 
     def write_err(self,data):
         """Write a string to the default error output"""
         Term.cerr.write(data)
 
     def exit(self):
         """Handle interactive exit.
 
         This method sets the exit_now attribute."""
 
         if self.rc.confirm_exit:
             if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
                 self.exit_now = True
         else:
             self.exit_now = True
-        return self.exit_now
 
     def safe_execfile(self,fname,*where,**kw):
         fname = os.path.expanduser(fname)
 
         # find things also in current directory
         dname = os.path.dirname(fname)
         if not sys.path.count(dname):
             sys.path.append(dname)
 
         try:
             xfile = open(fname)
         except:
             print >> Term.cerr, \
                   'Could not open file <%s> for safe execution.' % fname
             return None
 
         kw.setdefault('islog',0)
         kw.setdefault('quiet',1)
         kw.setdefault('exit_ignore',0)
         first = xfile.readline()
         loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
         xfile.close()
         # line by line execution
         if first.startswith(loghead) or kw['islog']:
             print 'Loading log file <%s> one line at a time...' % fname
             if kw['quiet']:
                 stdout_save = sys.stdout
                 sys.stdout = StringIO.StringIO()
             try:
                 globs,locs = where[0:2]
             except:
                 try:
                     globs = locs = where[0]
                 except:
                     globs = locs = globals()
             badblocks = []
 
             # we also need to identify indented blocks of code when replaying
             # logs and put them together before passing them to an exec
             # statement. This takes a bit of regexp and look-ahead work in the
             # file. It's easiest if we swallow the whole thing in memory
             # first, and manually walk through the lines list moving the
             # counter ourselves.
             indent_re = re.compile('\s+\S')
             xfile = open(fname)
             filelines = xfile.readlines()
             xfile.close()
             nlines = len(filelines)
             lnum = 0
             while lnum < nlines:
                 line = filelines[lnum]
                 lnum += 1
                 # don't re-insert logger status info into cache
                 if line.startswith('#log#'):
                     continue
                 else:
                     # build a block of code (maybe a single line) for execution
                     block = line
                     try:
                         next = filelines[lnum] # lnum has already incremented
                     except:
                         next = None
                     while next and indent_re.match(next):
                         block += next
                         lnum += 1
                         try:
                             next = filelines[lnum]
                         except:
                             next = None
                     # now execute the block of one or more lines
                     try:
                         exec block in globs,locs
                     except SystemExit:
                         pass
                     except:
                         badblocks.append(block.rstrip())
             if kw['quiet']:  # restore stdout
                 sys.stdout.close()
                 sys.stdout = stdout_save
             print 'Finished replaying log file <%s>' % fname
             if badblocks:
                 print >> sys.stderr, ('\nThe following lines/blocks in file '
                                       '<%s> reported errors:' % fname)
                     
                 for badline in badblocks:
                     print >> sys.stderr, badline
         else:  # regular file execution
             try:
                 execfile(fname,*where)
             except SyntaxError:
                 self.showsyntaxerror()
                 warn('Failure executing file: <%s>' % fname)
             except SystemExit,status:
                 if not kw['exit_ignore']:
                     self.showtraceback()
                     warn('Failure executing file: <%s>' % fname)
             except:
                 self.showtraceback()
                 warn('Failure executing file: <%s>' % fname)
 
 #************************* end of file <iplib.py> *****************************

IPython/irunner.py

@@ -1,319 +1,297 b''
 #!/usr/bin/env python
 """Module for interactively running scripts.
 
 This module implements classes for interactively running scripts written for
 any system with a prompt which can be matched by a regexp suitable for
 pexpect.  It can be used to run as if they had been typed up interactively, an
 arbitrary series of commands for the target system.
 
 The module includes classes ready for IPython (with the default prompts),
 plain Python and SAGE, but making a new one is trivial.  To see how to use it,
 simply run the module as a script:
 
 ./irunner.py --help
 
 
 This is an extension of Ken Schutte <kschutte-AT-csail.mit.edu>'s script
 contributed on the ipython-user list:
 
 http://scipy.net/pipermail/ipython-user/2006-May/001705.html
 
 
 NOTES:
 
  - This module requires pexpect, available in most linux distros, or which can
  be downloaded from
 
     http://pexpect.sourceforge.net
 
  - Because pexpect only works under Unix or Windows-Cygwin, this has the same
  limitations.  This means that it will NOT work under native windows Python.
 """
 
 # Stdlib imports
 import optparse
 import os
 import sys
 
 # Third-party modules.
 import pexpect
 
 # Global usage strings, to avoid indentation issues when typing it below.
 USAGE = """
 Interactive script runner, type: %s
 
 runner [opts] script_name
 """
 
 # The generic runner class
 class InteractiveRunner(object):
     """Class to run a sequence of commands through an interactive program."""
     
     def __init__(self,program,prompts,args=None):
         """Construct a runner.
 
         Inputs:
 
           - program: command to execute the given program.
 
           - prompts: a list of patterns to match as valid prompts, in the
           format used by pexpect.  This basically means that it can be either
           a string (to be compiled as a regular expression) or a list of such
           (it must be a true list, as pexpect does type checks).
 
           If more than one prompt is given, the first is treated as the main
           program prompt and the others as 'continuation' prompts, like
           python's.  This means that blank lines in the input source are
           ommitted when the first prompt is matched, but are NOT ommitted when
           the continuation one matches, since this is how python signals the
           end of multiline input interactively.
 
         Optional inputs:
 
           - args(None): optional list of strings to pass as arguments to the
           child program.
 
         Public members not parameterized in the constructor:
 
           - delaybeforesend(0): Newer versions of pexpect have a delay before
           sending each new input.  For our purposes here, it's typically best
           to just set this to zero, but if you encounter reliability problems
           or want an interactive run to pause briefly at each prompt, just
           increase this value (it is measured in seconds).  Note that this
           variable is not honored at all by older versions of pexpect.
         """
         
         self.program = program
         self.prompts = prompts
         if args is None: args = []
         self.args = args
         # Other public members which we don't make as parameters, but which
         # users may occasionally want to tweak
         self.delaybeforesend = 0
         
     def run_file(self,fname,interact=False):
         """Run the given file interactively.
 
         Inputs:
 
           -fname: name of the file to execute.
 
         See the run_source docstring for the meaning of the optional
         arguments."""
 
         fobj = open(fname,'r')
         try:
             self.run_source(fobj,interact)
         finally:
             fobj.close()
 
     def run_source(self,source,interact=False):
         """Run the given source code interactively.
 
         Inputs:
 
           - source: a string of code to be executed, or an open file object we
           can iterate over.
 
         Optional inputs:
 
           - interact(False): if true, start to interact with the running
           program at the end of the script.  Otherwise, just exit.
           """
 
         # if the source is a string, chop it up in lines so we can iterate
         # over it just as if it were an open file.
         if not isinstance(source,file):
             source = source.splitlines(True)
 
         # grab the true write method of stdout, in case anything later
         # reassigns sys.stdout, so that we really are writing to the true
         # stdout and not to something else.  We also normalize all strings we
         # write to use the native OS line separators.
         linesep  = os.linesep
         stdwrite = sys.stdout.write
         write    = lambda s: stdwrite(s.replace('\r\n',linesep))
 
         c = pexpect.spawn(self.program,self.args,timeout=None)
         c.delaybeforesend = self.delaybeforesend
             
         prompts = c.compile_pattern_list(self.prompts)
 
         prompt_idx = c.expect_list(prompts)
         # Flag whether the script ends normally or not, to know whether we can
         # do anything further with the underlying process.
         end_normal = True
         for cmd in source:
             # skip blank lines for all matches to the 'main' prompt, while the
             # secondary prompts do not
             if prompt_idx==0 and \
                    (cmd.isspace() or cmd.lstrip().startswith('#')):
                 print cmd,
                 continue
 
             write(c.after)
             c.send(cmd)
             try:
                 prompt_idx = c.expect_list(prompts)
             except pexpect.EOF:
                 # this will happen if the child dies unexpectedly
                 write(c.before)
                 end_normal = False
                 break
             write(c.before)
         
         if end_normal:
             if interact:
                 c.send('\n')
                 print '<< Starting interactive mode >>',
                 try:
                     c.interact()
                 except OSError:
                     # This is what fires when the child stops.  Simply print a
                     # newline so the system prompt is aligned.  The extra
                     # space is there to make sure it gets printed, otherwise
                     # OS buffering sometimes just suppresses it.
                     write(' \n')
                     sys.stdout.flush()
             else:
                 c.close()
         else:
             if interact:
                 e="Further interaction is not possible: child process is dead."
                 print >> sys.stderr, e
                 
     def main(self,argv=None):
         """Run as a command-line script."""
 
         parser = optparse.OptionParser(usage=USAGE % self.__class__.__name__)
         newopt = parser.add_option
         newopt('-i','--interact',action='store_true',default=False,
                help='Interact with the program after the script is run.')
 
         opts,args = parser.parse_args(argv)
 
         if len(args) != 1:
             print >> sys.stderr,"You must supply exactly one file to run."
             sys.exit(1)
 
         self.run_file(args[0],opts.interact)
 
 
 # Specific runners for particular programs
 class IPythonRunner(InteractiveRunner):
     """Interactive IPython runner.
 
     This initalizes IPython in 'nocolor' mode for simplicity.  This lets us
     avoid having to write a regexp that matches ANSI sequences, though pexpect
     does support them.  If anyone contributes patches for ANSI color support,
     they will be welcome.
 
     It also sets the prompts manually, since the prompt regexps for
     pexpect need to be matched to the actual prompts, so user-customized
     prompts would break this.
     """
     
     def __init__(self,program = 'ipython',args=None):
         """New runner, optionally passing the ipython command to use."""
         
         args0 = ['-colors','NoColor',
                  '-pi1','In [\\#]: ',
                  '-pi2','   .\\D.: ']
         if args is None: args = args0
         else: args = args0 + args
         prompts = [r'In \[\d+\]: ',r'   \.*: ']
         InteractiveRunner.__init__(self,program,prompts,args)
 
 
 class PythonRunner(InteractiveRunner):
     """Interactive Python runner."""
 
     def __init__(self,program='python',args=None):
         """New runner, optionally passing the python command to use."""
 
         prompts = [r'>>> ',r'\.\.\. ']
         InteractiveRunner.__init__(self,program,prompts,args)
 
 
-class DocTestRunner(PythonRunner):
-    """A python runner customized for doctest usage."""
-
-    def run_source(self,source,interact=False):
-        """Run the given source code interactively.
-
-        See the parent docstring for details.
-        """
-
-        # if the source is a string, chop it up in lines so we can iterate
-        # over it just as if it were an open file.
-        if not isinstance(source,file):
-            source = source.splitlines(True)
-
-        
-        for line in source:
-            pass
-        # finish by calling the parent run_source method
-        super(DocTestRunner,self).run_source(dsource,interact)
-
-
-
 class SAGERunner(InteractiveRunner):
     """Interactive SAGE runner.
     
     WARNING: this runner only works if you manually configure your SAGE copy
     to use 'colors NoColor' in the ipythonrc config file, since currently the
     prompt matching regexp does not identify color sequences."""
 
     def __init__(self,program='sage',args=None):
         """New runner, optionally passing the sage command to use."""
 
         prompts = ['sage: ',r'\s*\.\.\. ']
         InteractiveRunner.__init__(self,program,prompts,args)
 
 # Global usage string, to avoid indentation issues if typed in a function def.
 MAIN_USAGE = """
 %prog [options] file_to_run
 
 This is an interface to the various interactive runners available in this
 module.  If you want to pass specific options to one of the runners, you need
 to first terminate the main options with a '--', and then provide the runner's
 options.  For example:
 
 irunner.py --python -- --help
 
 will pass --help to the python runner.  Similarly,
 
 irunner.py --ipython -- --interact script.ipy
 
 will run the script.ipy file under the IPython runner, and then will start to
 interact with IPython at the end of the script (instead of exiting).
 
 The already implemented runners are listed below; adding one for a new program
 is a trivial task, see the source for examples.
 
 WARNING: the SAGE runner only works if you manually configure your SAGE copy
 to use 'colors NoColor' in the ipythonrc config file, since currently the
 prompt matching regexp does not identify color sequences.
 """
 
 def main():
     """Run as a command-line script."""
 
     parser = optparse.OptionParser(usage=MAIN_USAGE)
     newopt = parser.add_option
     parser.set_defaults(mode='ipython')
     newopt('--ipython',action='store_const',dest='mode',const='ipython',
            help='IPython interactive runner (default).')
     newopt('--python',action='store_const',dest='mode',const='python',
            help='Python interactive runner.')
     newopt('--sage',action='store_const',dest='mode',const='sage',
            help='SAGE interactive runner.')
 
     opts,args = parser.parse_args()
     runners = dict(ipython=IPythonRunner,
                    python=PythonRunner,
                    sage=SAGERunner)
     runners[opts.mode]().main(args)
 
 if __name__ == '__main__':
     main()

IPython/ultraTB.py

@@ -1,883 +1,887 b''
 # -*- coding: utf-8 -*-
 """
 ultraTB.py -- Spice up your tracebacks!
 
 * ColorTB
 I've always found it a bit hard to visually parse tracebacks in Python.  The
 ColorTB class is a solution to that problem.  It colors the different parts of a
 traceback in a manner similar to what you would expect from a syntax-highlighting
 text editor.
 
 Installation instructions for ColorTB:
     import sys,ultraTB
     sys.excepthook = ultraTB.ColorTB()
 
 * VerboseTB  
 I've also included a port of Ka-Ping Yee's "cgitb.py" that produces all kinds
 of useful info when a traceback occurs.  Ping originally had it spit out HTML
 and intended it for CGI programmers, but why should they have all the fun?  I
 altered it to spit out colored text to the terminal.  It's a bit overwhelming,
 but kind of neat, and maybe useful for long-running programs that you believe
 are bug-free.  If a crash *does* occur in that type of program you want details.
 Give it a shot--you'll love it or you'll hate it.
 
 Note:
 
   The Verbose mode prints the variables currently visible where the exception
   happened (shortening their strings if too long). This can potentially be
   very slow, if you happen to have a huge data structure whose string
   representation is complex to compute. Your computer may appear to freeze for
   a while with cpu usage at 100%. If this occurs, you can cancel the traceback
   with Ctrl-C (maybe hitting it more than once).
 
   If you encounter this kind of situation often, you may want to use the
   Verbose_novars mode instead of the regular Verbose, which avoids formatting
   variables (but otherwise includes the information and context given by
   Verbose).
   
 
 Installation instructions for ColorTB:
     import sys,ultraTB
     sys.excepthook = ultraTB.VerboseTB()
 
 Note:  Much of the code in this module was lifted verbatim from the standard
 library module 'traceback.py' and Ka-Ping Yee's 'cgitb.py'.
 
 * Color schemes
 The colors are defined in the class TBTools through the use of the
 ColorSchemeTable class. Currently the following exist:
 
   - NoColor: allows all of this module to be used in any terminal (the color
   escapes are just dummy blank strings).
 
   - Linux: is meant to look good in a terminal like the Linux console (black
   or very dark background).
 
   - LightBG: similar to Linux but swaps dark/light colors to be more readable
   in light background terminals.
 
 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 1786 2006-09-27 05:47:28Z fperez $"""
+$Id: ultraTB.py 1787 2006-09-27 06:56:29Z fperez $"""
 
 #*****************************************************************************
 #       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.
 #*****************************************************************************
 
 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
 import linecache
 import os
 import pydoc
 import string
 import sys
 import time
 import tokenize
 import traceback
 import types
 
 # IPython's own modules
 # Modified pdb which doesn't damage IPython's readline handling
 from IPython import Debugger
 from IPython.ipstruct import Struct
 from IPython.excolors import ExceptionColors
 from IPython.genutils import Term,uniq_stable,error,info
 
 # Globals
 # amount of space to put line numbers before verbose tracebacks
 INDENT_SIZE = 8
 
 #---------------------------------------------------------------------------
 # Code begins
 
 # Utility functions
 def inspect_error():
     """Print a message about internal inspect errors.
 
     These are unfortunately quite common."""
     
     error('Internal Python error in the inspect module.\n'
           'Below is the traceback from this internal error.\n')
 
 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)
 
     # 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
     # console)
     rec_check = records[tb_offset:]
     try:
         rname = rec_check[0][1]
         if rname == '<ipython console>' or rname.endswith('<string>'):
             return rec_check
     except IndexError:
         pass
 
     aux = traceback.extract_tb(etb)
     assert len(records) == len(aux)
     for i, (file, lnum, _, _) in zip(range(len(records)), aux):
         maybeStart = lnum-1 - context//2
         start =  max(maybeStart, 0)
         end   = start + context
         lines = linecache.getlines(file)[start:end]
         # pad with empty lines if necessary
         if maybeStart < 0:
             lines = (['\n'] * -maybeStart) + lines
         if len(lines) < context:
             lines += ['\n'] * (context - len(lines))
         buf = list(records[i])
         buf[LNUM_POS] = lnum
         buf[INDEX_POS] = lnum - 1 - start
         buf[LINES_POS] = lines
         records[i] = tuple(buf)
     return records[tb_offset:]
 
 # Helper function -- largely belongs to VerboseTB, but we need the same
 # functionality to produce a pseudo verbose TB for SyntaxErrors, so that they
 # can be recognized properly by ipython.el's py-traceback-line-re
 # (SyntaxErrors have to be treated specially because they have no traceback)
 def _formatTracebackLines(lnum, index, lines, Colors, lvals=None):
     numbers_width = INDENT_SIZE - 1
     res = []
     i = lnum - index
     for line in lines:
         if i == lnum:
             # This is the line with the error
             pad = numbers_width - len(str(i))
             if pad >= 3:
                 marker = '-'*(pad-3) + '-> '
             elif pad == 2:
                 marker = '> '
             elif pad == 1:
                 marker = '>'
             else:
                 marker = ''
             num = marker + str(i)
             line = '%s%s%s %s%s' %(Colors.linenoEm, num, 
                                    Colors.line, line, Colors.Normal)
         else:
             num = '%*s' % (numbers_width,i)
             line = '%s%s%s %s' %(Colors.lineno, num, 
                                  Colors.Normal, line)
 
         res.append(line)
         if lvals and i == lnum:
             res.append(lvals + '\n')
         i = i + 1
     return res
 
 #---------------------------------------------------------------------------
 # Module classes
 class TBTools:
     """Basic tools used by all traceback printer classes."""
 
     def __init__(self,color_scheme = 'NoColor',call_pdb=False):
         # Whether to call the interactive pdb debugger after printing
         # tracebacks or not
         self.call_pdb = call_pdb
 
         # Create color table
         self.color_scheme_table = ExceptionColors 
 
         self.set_colors(color_scheme)
         self.old_scheme = color_scheme  # save initial value for toggles
 
         if call_pdb:
             self.pdb = Debugger.Pdb(self.color_scheme_table.active_scheme_name)
         else:
             self.pdb = None
 
     def set_colors(self,*args,**kw):
         """Shorthand access to the color table scheme selector method."""
-        
+
+        # Set own color table
         self.color_scheme_table.set_active_scheme(*args,**kw)
         # for convenience, set Colors to the active scheme
         self.Colors = self.color_scheme_table.active_colors
+        # Also set colors of debugger
+        if hasattr(self,'pdb') and self.pdb is not None:
+            self.pdb.set_colors(*args,**kw)
 
     def color_toggle(self):
         """Toggle between the currently active color scheme and NoColor."""
         
         if self.color_scheme_table.active_scheme_name == 'NoColor':
             self.color_scheme_table.set_active_scheme(self.old_scheme)
             self.Colors = self.color_scheme_table.active_colors
         else:
             self.old_scheme = self.color_scheme_table.active_scheme_name
             self.color_scheme_table.set_active_scheme('NoColor')
             self.Colors = self.color_scheme_table.active_colors
 
 #---------------------------------------------------------------------------
 class ListTB(TBTools):
     """Print traceback information from a traceback list, with optional color.
         
     Calling: requires 3 arguments:
       (etype, evalue, elist)
     as would be obtained by:
       etype, evalue, tb = sys.exc_info()
       if tb:
         elist = traceback.extract_tb(tb)
       else:
         elist = None
 
     It can thus be used by programs which need to process the traceback before
     printing (such as console replacements based on the code module from the
     standard library).
 
     Because they are meant to be called without a full traceback (only a
     list), instances of this class can't call the interactive pdb debugger."""
 
     def __init__(self,color_scheme = 'NoColor'):
         TBTools.__init__(self,color_scheme = color_scheme,call_pdb=0)
         
     def __call__(self, etype, value, elist):
         print >> Term.cerr, self.text(etype,value,elist)
 
     def text(self,etype, value, elist,context=5):
         """Return a color formatted string with the traceback info."""
 
         Colors = self.Colors
         out_string = ['%s%s%s\n' % (Colors.topline,'-'*60,Colors.Normal)]
         if elist:
             out_string.append('Traceback %s(most recent call last)%s:' % \
                                 (Colors.normalEm, Colors.Normal) + '\n')
             out_string.extend(self._format_list(elist))
         lines = self._format_exception_only(etype, value)
         for line in lines[:-1]:
             out_string.append(" "+line)
         out_string.append(lines[-1])
         return ''.join(out_string)
 
     def _format_list(self, extracted_list):
         """Format a list of traceback entry tuples for printing.
 
         Given a list of tuples as returned by extract_tb() or
         extract_stack(), return a list of strings ready for printing.
         Each string in the resulting list corresponds to the item with the
         same index in the argument list.  Each string ends in a newline;
         the strings may contain internal newlines as well, for those items
         whose source text line is not None.
         
         Lifted almost verbatim from traceback.py
         """
 
         Colors = self.Colors
         list = []
         for filename, lineno, name, line in extracted_list[:-1]:
             item = '  File %s"%s"%s, line %s%d%s, in %s%s%s\n' % \
                     (Colors.filename, filename, Colors.Normal, 
                      Colors.lineno, lineno, Colors.Normal,
                      Colors.name, name, Colors.Normal)
             if line:
                 item = item + '    %s\n' % line.strip()
             list.append(item)
         # Emphasize the last entry
         filename, lineno, name, line = extracted_list[-1]
         item = '%s  File %s"%s"%s, line %s%d%s, in %s%s%s%s\n' % \
                 (Colors.normalEm,
                  Colors.filenameEm, filename, Colors.normalEm,
                  Colors.linenoEm, lineno, Colors.normalEm,
                  Colors.nameEm, name, Colors.normalEm,
                  Colors.Normal)
         if line:
             item = item + '%s    %s%s\n' % (Colors.line, line.strip(),
                                             Colors.Normal)
         list.append(item)
         return list
         
     def _format_exception_only(self, etype, value):
         """Format the exception part of a traceback.
 
         The arguments are the exception type and value such as given by
         sys.exc_info()[:2]. The return value is a list of strings, each ending
         in a newline.  Normally, the list contains a single string; however,
         for SyntaxError exceptions, it contains several lines that (when
         printed) display detailed information about where the syntax error
         occurred.  The message indicating which exception occurred is the
         always last string in the list.
         
         Also lifted nearly verbatim from traceback.py
         """
         
         Colors = self.Colors
         list = []
         if type(etype) == types.ClassType:
             stype = Colors.excName + etype.__name__ + Colors.Normal
         else:
             stype = etype  # String exceptions don't get special coloring
         if value is None:
             list.append( str(stype) + '\n')
         else:
             if etype is SyntaxError:
                 try:
                     msg, (filename, lineno, offset, line) = value
                 except:
                     pass
                 else:
                     #print 'filename is',filename  # dbg
                     if not filename: filename = "<string>"
                     list.append('%s  File %s"%s"%s, line %s%d%s\n' % \
                             (Colors.normalEm,
                              Colors.filenameEm, filename, Colors.normalEm,
                              Colors.linenoEm, lineno, Colors.Normal  ))
                     if line is not None:
                         i = 0
                         while i < len(line) and line[i].isspace():
                             i = i+1
                         list.append('%s    %s%s\n' % (Colors.line,
                                                       line.strip(), 
                                                       Colors.Normal))
                         if offset is not None:
                             s = '    '
                             for c in line[i:offset-1]:
                                 if c.isspace():
                                     s = s + c
                                 else:
                                     s = s + ' '
                             list.append('%s%s^%s\n' % (Colors.caret, s,
                                                        Colors.Normal) )
                         value = msg
             s = self._some_str(value)
             if s:
                 list.append('%s%s:%s %s\n' % (str(stype), Colors.excName,
                                               Colors.Normal, s))
             else:
                 list.append('%s\n' % str(stype))
         return list
 
     def _some_str(self, value):
         # Lifted from traceback.py
         try:
             return str(value)
         except:
             return '<unprintable %s object>' % type(value).__name__
 
 #----------------------------------------------------------------------------
 class VerboseTB(TBTools):
     """A port of Ka-Ping Yee's cgitb.py module that outputs color text instead
     of HTML.  Requires inspect and pydoc.  Crazy, man.
 
     Modified version which optionally strips the topmost entries from the
     traceback, to be used with alternate interpreters (because their own code
     would appear in the traceback)."""
 
     def __init__(self,color_scheme = 'Linux',tb_offset=0,long_header=0,
                  call_pdb = 0, include_vars=1):
         """Specify traceback offset, headers and color scheme.
 
         Define how many frames to drop from the tracebacks. Calling it with
         tb_offset=1 allows use of this handler in interpreters which will have
         their own code at the top of the traceback (VerboseTB will first
         remove that frame before printing the traceback info)."""
         TBTools.__init__(self,color_scheme=color_scheme,call_pdb=call_pdb)
         self.tb_offset = tb_offset
         self.long_header = long_header
         self.include_vars = include_vars
 
     def text(self, etype, evalue, etb, context=5):
         """Return a nice text document describing the traceback."""
 
         # some locals
         Colors        = self.Colors   # just a shorthand + quicker name lookup
         ColorsNormal  = Colors.Normal  # used a lot
         indent        = ' '*INDENT_SIZE
         exc           = '%s%s%s' % (Colors.excName, str(etype), ColorsNormal)
         em_normal     = '%s\n%s%s' % (Colors.valEm, indent,ColorsNormal)
         undefined     = '%sundefined%s' % (Colors.em, ColorsNormal)
 
         # some internal-use functions
         def text_repr(value):
             """Hopefully pretty robust repr equivalent."""
             # this is pretty horrible but should always return *something*
             try:
                 return pydoc.text.repr(value)
             except KeyboardInterrupt:
                 raise
             except:
                 try:
                     return repr(value)
                 except KeyboardInterrupt:
                     raise
                 except:
                     try:
                         # all still in an except block so we catch
                         # getattr raising
                         name = getattr(value, '__name__', None)
                         if name:
                             # ick, recursion
                             return text_repr(name)
                         klass = getattr(value, '__class__', None)
                         if klass:
                             return '%s instance' % text_repr(klass)
                     except KeyboardInterrupt:
                         raise
                     except:
                         return 'UNRECOVERABLE REPR FAILURE'
         def eqrepr(value, repr=text_repr): return '=%s' % repr(value)
         def nullrepr(value, repr=text_repr): return ''
 
         # meat of the code begins
         if type(etype) is types.ClassType:
             etype = etype.__name__
 
         if self.long_header:
             # Header with the exception type, python version, and date
             pyver = 'Python ' + string.split(sys.version)[0] + ': ' + sys.executable
             date = time.ctime(time.time())
             
             head = '%s%s%s\n%s%s%s\n%s' % (Colors.topline, '-'*75, ColorsNormal,
                                            exc, ' '*(75-len(str(etype))-len(pyver)),
                                            pyver, string.rjust(date, 75) )
             head += "\nA problem occured executing Python code.  Here is the sequence of function"\
                     "\ncalls leading up to the error, with the most recent (innermost) call last."
         else:
             # Simplified header
             head = '%s%s%s\n%s%s' % (Colors.topline, '-'*75, ColorsNormal,exc,
                                      string.rjust('Traceback (most recent call last)',
                                                   75 - len(str(etype)) ) )
         frames = []
         # Flush cache before calling inspect.  This helps alleviate some of the
         # problems with python 2.3's inspect.py.
         linecache.checkcache()
         # Drop topmost frames if requested
         try:
             # Try the default getinnerframes and Alex's: Alex's fixes some
             # problems, but it generates empty tracebacks for console errors
             # (5 blanks lines) where none should be returned.
             #records = inspect.getinnerframes(etb, context)[self.tb_offset:]
             #print 'python records:', records # dbg
             records = _fixed_getinnerframes(etb, context,self.tb_offset)
             #print 'alex   records:', records # dbg
         except:
 
             # FIXME: I've been getting many crash reports from python 2.3
             # users, traceable to inspect.py.  If I can find a small test-case
             # to reproduce this, I should either write a better workaround or
             # file a bug report against inspect (if that's the real problem).
             # So far, I haven't been able to find an isolated example to
             # reproduce the problem.
             inspect_error()
             traceback.print_exc(file=Term.cerr)
             info('\nUnfortunately, your original traceback can not be constructed.\n')
             return ''
 
         # build some color string templates outside these nested loops
         tpl_link       = '%s%%s%s' % (Colors.filenameEm,ColorsNormal)
         tpl_call       = 'in %s%%s%s%%s%s' % (Colors.vName, Colors.valEm,
                                               ColorsNormal)
         tpl_call_fail  = 'in %s%%s%s(***failed resolving arguments***)%s' % \
                          (Colors.vName, Colors.valEm, ColorsNormal)
         tpl_local_var  = '%s%%s%s' % (Colors.vName, ColorsNormal)
         tpl_global_var = '%sglobal%s %s%%s%s' % (Colors.em, ColorsNormal,
                                                  Colors.vName, ColorsNormal)
         tpl_name_val   = '%%s %s= %%s%s' % (Colors.valEm, ColorsNormal)
         tpl_line       = '%s%%s%s %%s' % (Colors.lineno, ColorsNormal)
         tpl_line_em    = '%s%%s%s %%s%s' % (Colors.linenoEm,Colors.line,
                                             ColorsNormal)
 
         # now, loop over all records printing context and info
         abspath = os.path.abspath
         for frame, file, lnum, func, lines, index in records:
             #print '*** record:',file,lnum,func,lines,index  # dbg
             try:
                 file = file and abspath(file) or '?'
             except OSError:
                 # if file is '<console>' or something not in the filesystem,
                 # the abspath call will throw an OSError.  Just ignore it and
                 # keep the original file string.
                 pass
             link = tpl_link % file
             try:
                 args, varargs, varkw, locals = inspect.getargvalues(frame)
             except:
                 # This can happen due to a bug in python2.3.  We should be
                 # able to remove this try/except when 2.4 becomes a
                 # requirement.  Bug details at http://python.org/sf/1005466
                 inspect_error()
                 traceback.print_exc(file=Term.cerr)
                 info("\nIPython's exception reporting continues...\n")
                 
             if func == '?':
                 call = ''
             else:
                 # Decide whether to include variable details or not
                 var_repr = self.include_vars and eqrepr or nullrepr
                 try:
                     call = tpl_call % (func,inspect.formatargvalues(args,
                                                 varargs, varkw,
                                                 locals,formatvalue=var_repr))
                 except KeyError:
                     # Very odd crash from inspect.formatargvalues().  The
                     # scenario under which it appeared was a call to
                     # view(array,scale) in NumTut.view.view(), where scale had
                     # been defined as a scalar (it should be a tuple). Somehow
                     # inspect messes up resolving the argument list of view()
                     # and barfs out. At some point I should dig into this one
                     # and file a bug report about it.
                     inspect_error()
                     traceback.print_exc(file=Term.cerr)
                     info("\nIPython's exception reporting continues...\n")
                     call = tpl_call_fail % func
 
             # Initialize a list of names on the current line, which the
             # tokenizer below will populate.
             names = []
 
             def tokeneater(token_type, token, start, end, line):
                 """Stateful tokeneater which builds dotted names.
 
                 The list of names it appends to (from the enclosing scope) can
                 contain repeated composite names.  This is unavoidable, since
                 there is no way to disambguate partial dotted structures until
                 the full list is known.  The caller is responsible for pruning
                 the final list of duplicates before using it."""
                 
                 # build composite names
                 if token == '.':
                     try:
                         names[-1] += '.'
                         # store state so the next token is added for x.y.z names
                         tokeneater.name_cont = True
                         return
                     except IndexError:
                         pass
                 if token_type == tokenize.NAME and token not in keyword.kwlist:
                     if tokeneater.name_cont:
                         # Dotted names
                         names[-1] += token
                         tokeneater.name_cont = False
                     else:
                         # Regular new names.  We append everything, the caller
                         # will be responsible for pruning the list later.  It's
                         # very tricky to try to prune as we go, b/c composite
                         # names can fool us.  The pruning at the end is easy
                         # to do (or the caller can print a list with repeated
                         # names if so desired.
                         names.append(token)
                 elif token_type == tokenize.NEWLINE:
                     raise IndexError
             # we need to store a bit of state in the tokenizer to build
             # dotted names
             tokeneater.name_cont = False
 
             def linereader(file=file, lnum=[lnum], getline=linecache.getline):
                 line = getline(file, lnum[0])
                 lnum[0] += 1
                 return line
 
             # Build the list of names on this line of code where the exception
             # occurred.
             try:
                 # This builds the names list in-place by capturing it from the
                 # enclosing scope.
                 tokenize.tokenize(linereader, tokeneater)
             except IndexError:
                 # signals exit of tokenizer
                 pass
             except tokenize.TokenError,msg:
                 _m = ("An unexpected error occurred while tokenizing input\n"
                       "The following traceback may be corrupted or invalid\n"
                       "The error message is: %s\n" % msg)
                 error(_m)
             
             # prune names list of duplicates, but keep the right order
             unique_names = uniq_stable(names)
 
             # Start loop over vars
             lvals = []
             if self.include_vars:
                 for name_full in unique_names:
                     name_base = name_full.split('.',1)[0]
                     if name_base in frame.f_code.co_varnames:
                         if locals.has_key(name_base):
                             try:
                                 value = repr(eval(name_full,locals))
                             except:
                                 value = undefined
                         else:
                             value = undefined
                         name = tpl_local_var % name_full
                     else:
                         if frame.f_globals.has_key(name_base):
                             try:
                                 value = repr(eval(name_full,frame.f_globals))
                             except:
                                 value = undefined
                         else:
                             value = undefined
                         name = tpl_global_var % name_full
                     lvals.append(tpl_name_val % (name,value))
             if lvals:
                 lvals = '%s%s' % (indent,em_normal.join(lvals))
             else:
                 lvals = ''
 
             level = '%s %s\n' % (link,call)
 
             if index is None:
                 frames.append(level)
             else:
                 frames.append('%s%s' % (level,''.join(
                     _formatTracebackLines(lnum,index,lines,self.Colors,lvals))))
 
         # Get (safely) a string form of the exception info
         try:
             etype_str,evalue_str = map(str,(etype,evalue))
         except:
             # User exception is improperly defined.
             etype,evalue = str,sys.exc_info()[:2]
             etype_str,evalue_str = map(str,(etype,evalue))
         # ... and format it
         exception = ['%s%s%s: %s' % (Colors.excName, etype_str,
                                      ColorsNormal, evalue_str)]
         if type(evalue) is types.InstanceType:
             try:
                 names = [w for w in dir(evalue) if isinstance(w, basestring)]
             except:
                 # Every now and then, an object with funny inernals blows up
                 # when dir() is called on it.  We do the best we can to report
                 # the problem and continue
                 _m = '%sException reporting error (object with broken dir())%s:'
                 exception.append(_m % (Colors.excName,ColorsNormal))
                 etype_str,evalue_str = map(str,sys.exc_info()[:2])
                 exception.append('%s%s%s: %s' % (Colors.excName,etype_str,
                                      ColorsNormal, evalue_str))
                 names = []
             for name in names:
                 value = text_repr(getattr(evalue, name))
                 exception.append('\n%s%s = %s' % (indent, name, value))
         # return all our info assembled as a single string
         return '%s\n\n%s\n%s' % (head,'\n'.join(frames),''.join(exception[0]) )
 
     def debugger(self):
         """Call up the pdb debugger if desired, always clean up the tb reference.
 
         If the call_pdb flag is set, the pdb interactive debugger is
         invoked. In all cases, the self.tb reference to the current traceback
         is deleted to prevent lingering references which hamper memory
         management.
 
         Note that each call to pdb() does an 'import readline', so if your app
         requires a special setup for the readline completers, you'll have to
         fix that by hand after invoking the exception handler."""
 
         if self.call_pdb:
             if self.pdb is None:
                 self.pdb = Debugger.Pdb(
                     self.color_scheme_table.active_scheme_name)
             # the system displayhook may have changed, restore the original
             # for pdb
             dhook = sys.displayhook
             sys.displayhook = sys.__displayhook__
             self.pdb.reset()
             # Find the right frame so we don't pop up inside ipython itself
             etb = self.tb
             while self.tb.tb_next is not None:
                 self.tb = self.tb.tb_next
             try:
                 if etb and etb.tb_next:
                     etb = etb.tb_next
                 self.pdb.botframe = etb.tb_frame
                 self.pdb.interaction(self.tb.tb_frame, self.tb)
-            except 'ha':   # dbg
+            except:
                 print '*** ERROR ***'
                 print 'This version of pdb has a bug and crashed.'
                 print 'Returning to IPython...'
             sys.displayhook = dhook
         del self.tb
 
     def handler(self, info=None):
         (etype, evalue, etb) = info or sys.exc_info()
         self.tb = etb
         print >> Term.cerr, self.text(etype, evalue, etb)
 
     # Changed so an instance can just be called as VerboseTB_inst() and print
     # out the right info on its own.
     def __call__(self, etype=None, evalue=None, etb=None):
         """This hook can replace sys.excepthook (for Python 2.1 or higher)."""
         if etb is None:
             self.handler()
         else:
             self.handler((etype, evalue, etb))
         self.debugger()
 
 #----------------------------------------------------------------------------
 class FormattedTB(VerboseTB,ListTB):
     """Subclass ListTB but allow calling with a traceback.
 
     It can thus be used as a sys.excepthook for Python > 2.1.
 
     Also adds 'Context' and 'Verbose' modes, not available in ListTB.
 
     Allows a tb_offset to be specified. This is useful for situations where
     one needs to remove a number of topmost frames from the traceback (such as
     occurs with python programs that themselves execute other python code,
     like Python shells).  """
     
     def __init__(self, mode = 'Plain', color_scheme='Linux',
                  tb_offset = 0,long_header=0,call_pdb=0,include_vars=0):
 
         # NEVER change the order of this list. Put new modes at the end:
         self.valid_modes = ['Plain','Context','Verbose']
         self.verbose_modes = self.valid_modes[1:3]
 
         VerboseTB.__init__(self,color_scheme,tb_offset,long_header,
                            call_pdb=call_pdb,include_vars=include_vars)
         self.set_mode(mode)
         
     def _extract_tb(self,tb):
         if tb:
             return traceback.extract_tb(tb)
         else:
             return None
 
     def text(self, etype, value, tb,context=5,mode=None):
         """Return formatted traceback.
 
         If the optional mode parameter is given, it overrides the current
         mode."""
 
         if mode is None:
             mode = self.mode
         if mode in self.verbose_modes:
             # verbose modes need a full traceback
             return VerboseTB.text(self,etype, value, tb,context=5)
         else:
             # We must check the source cache because otherwise we can print
             # out-of-date source code.
             linecache.checkcache()
             # Now we can extract and format the exception
             elist = self._extract_tb(tb)
             if len(elist) > self.tb_offset:
                 del elist[:self.tb_offset]
             return ListTB.text(self,etype,value,elist)
 
     def set_mode(self,mode=None):
         """Switch to the desired mode.
 
         If mode is not specified, cycles through the available modes."""
 
         if not mode:
             new_idx = ( self.valid_modes.index(self.mode) + 1 ) % \
                       len(self.valid_modes)
             self.mode = self.valid_modes[new_idx]
         elif mode not in self.valid_modes:
             raise ValueError, 'Unrecognized mode in FormattedTB: <'+mode+'>\n'\
                   'Valid modes: '+str(self.valid_modes)
         else:
             self.mode = mode
         # include variable details only in 'Verbose' mode
         self.include_vars = (self.mode == self.valid_modes[2])
 
     # some convenient shorcuts
     def plain(self):
         self.set_mode(self.valid_modes[0])
 
     def context(self):
         self.set_mode(self.valid_modes[1])
 
     def verbose(self):
         self.set_mode(self.valid_modes[2])
 
 #----------------------------------------------------------------------------
 class AutoFormattedTB(FormattedTB):
     """A traceback printer which can be called on the fly.
 
     It will find out about exceptions by itself.
 
     A brief example:
     
     AutoTB = AutoFormattedTB(mode = 'Verbose',color_scheme='Linux')
     try:
       ...
     except:
       AutoTB()  # or AutoTB(out=logfile) where logfile is an open file object
     """
     def __call__(self,etype=None,evalue=None,etb=None,
                  out=None,tb_offset=None):
         """Print out a formatted exception traceback.
 
         Optional arguments:
           - out: an open file-like object to direct output to.
 
           - tb_offset: the number of frames to skip over in the stack, on a
           per-call basis (this overrides temporarily the instance's tb_offset
           given at initialization time.  """
         
         if out is None:
             out = Term.cerr
         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()
 
     def text(self,etype=None,value=None,tb=None,context=5,mode=None):
         if etype is None:
             etype,value,tb = sys.exc_info()
         self.tb = tb
         return FormattedTB.text(self,etype,value,tb,context=5,mode=mode)
 
 #---------------------------------------------------------------------------
 # A simple class to preserve Nathan's original functionality.
 class ColorTB(FormattedTB):
     """Shorthand to initialize a FormattedTB in Linux colors mode."""
     def __init__(self,color_scheme='Linux',call_pdb=0):
         FormattedTB.__init__(self,color_scheme=color_scheme,
                              call_pdb=call_pdb)
 
 #----------------------------------------------------------------------------
 # module testing (minimal)
 if __name__ == "__main__":
     def spam(c, (d, e)):
         x = c + d
         y = c * d
         foo(x, y)
 
     def foo(a, b, bar=1):
         eggs(a, b + bar)
 
     def eggs(f, g, z=globals()):
         h = f + g
         i = f - g
         return h / i
 
     print ''
     print '*** Before ***'
     try:
         print spam(1, (2, 3))
     except:
         traceback.print_exc()
     print ''
     
     handler = ColorTB()
     print '*** ColorTB ***'
     try:
         print spam(1, (2, 3))
     except:
         apply(handler, sys.exc_info() )
     print ''
     
     handler = VerboseTB()
     print '*** VerboseTB ***'
     try:
         print spam(1, (2, 3))
     except:
         apply(handler, sys.exc_info() )
     print ''
     

doc/ChangeLog

@@ -1,5735 +1,5753 b''
[phone]  Fernando Perez  <[e-mail]>
+
+	* IPython/irunner.py (InteractiveRunner.run_source): small fixes
+	to help in handling doctests.  irunner is now pretty useful for
+	running standalone scripts and simulate a full interactive session
+	in a format that can be then pasted as a doctest.
+
+	* IPython/iplib.py (InteractiveShell.__init__): Install exit/quit
+	on top of the default (useless) ones.  This also fixes the nasty
+	way in which 2.5's Quitter() exits (reverted [1785]).
+
+	* IPython/Debugger.py (Pdb.__init__): Fix ipdb to work with python
+	2.5.
+
+	* IPython/ultraTB.py (TBTools.set_colors): Make sure that ipdb
+	color scheme is updated as well when color scheme is changed
+	interactively. 
+
 2006-09-27  Ville Vainio  <[e-mail]>
 
 	* iplib.py (raw_input): python 2.5 closes stdin on quit -> avoid
     infinite loop and just exit. It's a hack, but will do for a while.
 
 2006-08-25  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ipipe.py (ils): Add arguments dirs and files to
 	the constructor, this makes it possible to get a list of only directories
 	or only files.
 
 2006-08-12  Ville Vainio  <[e-mail]>
 
 	* Fakemodule.py, OInspect.py: Reverted 2006-08-11 mods,
 	they broke unittest 
 
 2006-08-11  Ville Vainio  <[e-mail]>
 
 	* Fakemodule.py, OInspect.py: remove 2006-08-09 monkepatch
 	by resolving issue properly, i.e. by inheriting FakeModule
 	from types.ModuleType. Pickling ipython interactive data
 	should still work as usual (testing appreciated).
 
 2006-08-09  Fernando Perez  <[e-mail]>
 
 	* IPython/OInspect.py: monkeypatch inspect from the stdlib if
 	running under python 2.3 with code from 2.4 to fix a bug with
 	help().  Reported by the Debian maintainers, Norbert Tretkowski
 	<norbert-AT-tretkowski.de> and Alexandre Fayolle
 	<afayolle-AT-debian.org>.
 
 2006-08-04  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ibrowse.py: Fixed the help message in the footer
 	(which was displaying "quit" twice).
 
 2006-07-28  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ipipe.py: Fix isort.__iter__() (was still using
 	the mode argument).
 
 2006-07-27  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ipipe.py: Fix getglobals() if we're
 	not running under IPython.
 
 	* IPython/Extensions/ipipe.py: Rename XAttr to AttributeDetail
 	and make it iterable (iterating over the attribute itself). Add two new
 	magic strings for __xattrs__(): If the string starts with "-", the attribute
 	will not be displayed in ibrowse's detail view (but it can still be
 	iterated over). This makes it possible to add attributes that are large
 	lists or generator methods to the detail view. Replace magic attribute names
 	and _attrname() and _getattr() with "descriptors": For each type of magic
 	attribute name there's a subclass of Descriptor: None -> SelfDescriptor();
 	"foo" -> AttributeDescriptor("foo"); "foo()" -> MethodDescriptor("foo");
 	"-foo" -> IterAttributeDescriptor("foo"); "-foo()" -> IterMethodDescriptor("foo");
 	foo() -> FunctionDescriptor(foo). Magic strings returned from __xattrs__()
 	are still supported.
 
 	* IPython/Extensions/ibrowse.py: If fetching the next row from the input
 	fails in ibrowse.fetch(), the exception object is added as the last item
 	and item fetching is canceled. This prevents ibrowse from aborting if e.g.
 	a generator throws an exception midway through execution.
 
 	* IPython/Extensions/ipipe.py: Turn ifile's properties mimetype and
 	encoding into methods.
 
 2006-07-26  Ville Vainio  <[e-mail]>
 
 	* iplib.py: history now stores multiline input as single
 	history entries. Patch by Jorgen Cederlof.
 
 2006-07-18  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ibrowse.py: Make cursor visible over
 	non existing attributes.
 
 2006-07-14  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ipipe.py (ix): Use os.popen4() so that the
 	error output of the running command doesn't mess up the screen.
 
 2006-07-13  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ipipe.py (isort): Make isort usable without
 	argument. This sorts the items themselves.
 
 2006-07-12  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ipipe.py (eval, ifilter, isort, ieval):
 	Compile expression strings into code objects. This should speed
 	up ifilter and friends somewhat.
 
 2006-07-08  Ville Vainio  <[e-mail]>
 
 	* Magic.py: %cpaste now strips > from the beginning of lines
 	to ease pasting quoted code from emails. Contributed by 
 	Stefan van der Walt.
 
 2006-06-29  Ville Vainio  <[e-mail]>
 
 	* ipmaker.py, Shell.py: qt4agg matplotlib backend support for pylab
 	mode, patch contributed by Darren Dale. NEEDS TESTING! 
 
 2006-06-28  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ibrowse.py: Give the ibrowse cursor row
 	a blue background. Fix fetching new display rows when the browser
 	scrolls more than a screenful (e.g. by using the goto command).
 
 2006-06-27  Ville Vainio  <[e-mail]>
 
 	* Magic.py (_inspect, _ofind) Apply David Huard's 
 	patch for displaying the correct docstring for 'property' 
 	attributes.
 
 2006-06-23  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ibrowse.py: Put the documentation of the keyboard
 	commands into the methods implementing them.
 
 2006-06-22  Fernando Perez  <[e-mail]>
 
 	* ipython.el (ipython-indentation-hook): cleanup patch, submitted
 	by Kov Chai <tchaikov-AT-gmail.com>.  He notes that the original
 	autoindent support was authored by Jin Liu.
 
 2006-06-22  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ibrowse.py: Replace the plain dictionaries used
 	for keymaps with a custom class that simplifies handling.
 
 2006-06-19  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ibrowse.py: ibrowse now properly handles terminal
 	resizing. This requires Python 2.5 to work.
 
 2006-06-16  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ibrowse.py: Add two new commands to
 	ibrowse: "hideattr" (mapped to "h") hides the attribute under
 	the cursor. "unhiderattrs" (mapped to "H") reveals all hidden
 	attributes again. Remapped the help command to "?". Display
 	keycodes in the range 0x01-0x1F as CTRL-xx. Add CTRL-a and CTRL-e
 	as keys for the "home" and "end" commands. Add three new commands
 	to the input mode for "find" and friends: "delend" (CTRL-K)
 	deletes to the end of line. "incsearchup" searches upwards in the
 	command history for an input that starts with the text before the cursor.
 	"incsearchdown" does the same downwards. Removed a bogus mapping of
 	the x key to "delete".
 
 2006-06-15  Ville Vainio  <[e-mail]>
 
 	* iplib.py, hooks.py: Added new generate_prompt hook that can be
 	used to create prompts dynamically, instead of the "old" way of
 	assigning "magic" strings to prompt_in1 and prompt_in2. The old
 	way still works (it's invoked by the default hook), of course.
 	
 	* Prompts.py: added generate_output_prompt hook for altering output
 	prompt
 
 	* Release.py: Changed version string to 0.7.3.svn.
 	
 2006-06-15  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ibrowse.py: Change _BrowserLevel.moveto() so that
 	the call to fetch() always tries to fetch enough data for at least one
 	full screen. This makes it possible to simply call moveto(0,0,True) in
 	the constructor. Fix typos and removed the obsolete goto attribute.
 
 2006-06-12  Ville Vainio  <[e-mail]>
 
 	* ipy_profile_sh.py: applied Krisha Mohan Gundu's patch for
 	allowing $variable interpolation within multiline statements,
 	though so far only with "sh" profile for a testing period.
 	The patch also enables splitting long commands with \ but it
 	doesn't work properly yet.
 
 2006-06-12  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ibrowse.py (_dodisplay): Display the length of the
 	input history and the position of the cursor in the input history for
 	the find, findbackwards and goto command.
 
 2006-06-10  Walter Doerwald  <[e-mail]>
 
 	* IPython/Extensions/ibrowse.py: Add a class _CommandInput that
 	implements the basic functionality of browser commands that require
 	input. Reimplement the goto, find and findbackwards commands as
 	subclasses of _CommandInput. Add an input history and keymaps to those
 	commands. Add "\r" as a keyboard shortcut for the enterdefault and
 	execute commands.
 
 2006-06-07  Ville Vainio  <[e-mail]>
 
 	* iplib.py: ipython mybatch.ipy exits ipython immediately after
 	running the batch files instead of leaving the session open.
 
 2006-06-07  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): update BSD fix, as
 	the original fix was incomplete.  Patch submitted by W. Maier.
 
 2006-06-07  Ville Vainio  <[e-mail]>
 
 	* iplib.py,Magic.py, ipmaker.py (magic_rehashx):
 	Confirmation prompts can be supressed by 'quiet' option.
 	_ip.options.quiet = 1 means "assume yes for all yes/no queries".
 
 2006-06-06  *** Released version 0.7.2
 
 2006-06-06  Fernando Perez  <[e-mail]>
 
 	* IPython/Release.py (version): Made 0.7.2 final for release.
 	Repo tagged and release cut.
 
 2006-06-05  Ville Vainio  <[e-mail]>
 
 	* Magic.py (magic_rehashx): Honor no_alias list earlier in
 	%rehashx, to avoid clobbering builtins in ipy_profile_sh.py
 	
 	* upgrade_dir.py: try import 'path' module a bit harder
 	(for %upgrade)
 
 2006-06-03  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (ask_yes_no): treat EOF as a default answer
 	instead of looping 20 times.
 
 	* IPython/ipmaker.py (make_IPython): honor -ipythondir flag
 	correctly at initialization time.  Bug reported by Krishna Mohan
 	Gundu <gkmohan-AT-gmail.com> on the user list.
 
 	* IPython/Release.py (version): Mark 0.7.2 version to start
 	testing for release on 06/06.
 
 2006-05-31  Fernando Perez  <[e-mail]>
 
 	* scripts/irunner: thin script interface so users don't have to
 	find the module and call it as an executable, since modules rarely
 	live in people's PATH.
 
 	* IPython/irunner.py (InteractiveRunner.__init__): added
 	delaybeforesend attribute to control delays with newer versions of
 	pexpect.  Thanks to detailed help from pexpect's author, Noah
 	Spurrier <noah-AT-noah.org>.  Noted how to use the SAGE runner
 	correctly (it works in NoColor mode).
 
 	* IPython/iplib.py (handle_normal): fix nasty crash reported on
 	SAGE list, from improper log() calls.
 
 2006-05-31  Ville Vainio  <[e-mail]>
 
 	* upgrade_dir.py, Magic.py (magic_upgrade): call upgrade_dir
 	with args in parens to work correctly with dirs that have spaces.
 
 2006-05-30  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.logstart): add option to log raw input
 	instead of the processed one.  A -r flag was added to the
 	%logstart magic used for controlling logging.
 
 2006-05-29  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): add check for the
 	*BSDs to omit --color from all 'ls' aliases, since *BSD ls doesn't
 	recognize the option.  After a bug report by Will Maier.  This
 	closes #64 (will do it after confirmation from W. Maier).
 
 	* IPython/irunner.py: New module to run scripts as if manually
 	typed into an interactive environment, based on pexpect.  After a
 	submission by Ken Schutte <kschutte-AT-csail.mit.edu> on the
 	ipython-user list.  Simple unittests in the tests/ directory.
 
 	* tools/release: add Will Maier, OpenBSD port maintainer, to
 	recepients list.  We are now officially part of the OpenBSD ports:
 	http://www.openbsd.org/ports.html !  Many thanks to Will for the
 	work.
 
 2006-05-26  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): modify sys.argv fix (below)
 	so that it doesn't break tkinter apps.
 	
 	* IPython/iplib.py (_prefilter): fix bug where aliases would
 	shadow variables when autocall was fully off.  Reported by SAGE
 	author William Stein.
 
 	* IPython/OInspect.py (Inspector.__init__): add a flag to control
 	at what detail level strings are computed when foo? is requested.
 	This allows users to ask for example that the string form of an
 	object is only computed when foo?? is called, or even never, by
 	setting the object_info_string_level >= 2 in the configuration
 	file.  This new option has been added and documented.  After a
 	request by SAGE to be able to control the printing of very large
 	objects more easily.
 
 2006-05-25  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): remove the ipython call path
 	from sys.argv, to be 100% consistent with how Python itself works
 	(as seen for example with python -i file.py).  After a bug report
 	by Jeffrey Collins.
 
 	* IPython/Shell.py (MatplotlibShellBase._matplotlib_config): Fix
 	nasty bug which was preventing custom namespaces with -pylab,
 	reported by M. Foord.  Minor cleanup, remove old matplotlib.matlab
 	compatibility (long gone from mpl).
 
 	* IPython/ipapi.py (make_session): name change: create->make.  We
 	use make in other places (ipmaker,...), it's shorter and easier to
 	type and say, etc.  I'm trying to clean things before 0.7.2 so
 	that I can keep things stable wrt to ipapi in the chainsaw branch.
 
 	* ipython.el: fix the py-pdbtrack-input-prompt variable so that
 	python-mode recognizes our debugger mode.  Add support for
 	autoindent inside (X)emacs.  After a patch sent in by Jin Liu
 	<m.liu.jin-AT-gmail.com> originally written by
 	doxgen-AT-newsmth.net (with minor modifications for xemacs
 	compatibility)
 
 	* IPython/Debugger.py (Pdb.format_stack_entry): fix formatting of
 	tracebacks when walking the stack so that the stack tracking system
 	in emacs' python-mode can identify the frames correctly.
 
 	* IPython/ipmaker.py (make_IPython): make the internal (and
 	default config) autoedit_syntax value false by default.  Too many
 	users have complained to me (both on and off-list) about problems
 	with this option being on by default, so I'm making it default to
 	off.  It can still be enabled by anyone via the usual mechanisms.
 
 	* IPython/completer.py (Completer.attr_matches): add support for
 	PyCrust-style _getAttributeNames magic method.  Patch contributed
 	by <mscott-AT-goldenspud.com>.  Closes #50.
 
 	* IPython/iplib.py (InteractiveShell.__init__): remove the
 	deletion of exit/quit from __builtin__, which can break
 	third-party tools like the Zope debugging console.  The
 	%exit/%quit magics remain.  In general, it's probably a good idea
 	not to delete anything from __builtin__, since we never know what
 	that will break.  In any case, python now (for 2.5) will support
 	'real' exit/quit, so this issue is moot.  Closes #55.
 
 	* IPython/genutils.py (with_obj): rename the 'with' function to
 	'withobj' to avoid incompatibilities with Python 2.5, where 'with'
 	becomes a language keyword.  Closes #53.
 
 	* IPython/FakeModule.py (FakeModule.__init__): add a proper
 	__file__ attribute to this so it fools more things into thinking
 	it is a real module.  Closes #59.
 
 	* IPython/Magic.py (magic_edit): add -n option to open the editor
 	at a specific line number.  After a patch by Stefan van der Walt.
 
 2006-05-23  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (edit_syntax_error): fix crash when for some
 	reason the file could not be opened.  After automatic crash
 	reports sent by James Graham <jgraham-AT-ast.cam.ac.uk> and
 	Charles Dolan <charlespatrickdolan-AT-yahoo.com>.
 	(_should_recompile): Don't fire editor if using %bg, since there
 	is no file in the first place.  From the same report as above.
 	(raw_input): protect against faulty third-party prefilters.  After
 	an automatic crash report sent by Dirk Laurie <dirk-AT-sun.ac.za>
 	while running under SAGE.
 
 2006-05-23  Ville Vainio  <[e-mail]>
 
 	* ipapi.py: Stripped down ip.to_user_ns() to work only as
 	ip.to_user_ns("x1 y1"), which exposes vars x1 and y1. ipapi.get()
 	now returns None (again), unless dummy is specifically allowed by
 	ipapi.get(allow_dummy=True).
 
 2006-05-18  Fernando Perez  <[e-mail]>
 
 	* IPython: remove all 2.2-compatibility objects and hacks from
 	everywhere, since we only support 2.3 at this point.  Docs
 	updated.
 
 	* IPython/ipapi.py (IPApi.__init__): Cleanup of all getters.
 	Anything requiring extra validation can be turned into a Python
 	property in the future.  I used a property for the db one b/c
 	there was a nasty circularity problem with the initialization
 	order, which right now I don't have time to clean up.
 
 	* IPython/Shell.py (MTInteractiveShell.runcode): Fix, I think,
 	another locking bug reported by Jorgen.  I'm not 100% sure though,
 	so more testing is needed...
 
 2006-05-17  Fernando Perez  <[e-mail]>
 
 	* IPython/ipapi.py (IPApi.to_user_ns): New function to inject
 	local variables from any routine in user code (typically executed
 	with %run) directly into the interactive namespace.  Very useful
 	when doing complex debugging.
 	(IPythonNotRunning): Changed the default None object to a dummy
 	whose attributes can be queried as well as called without
 	exploding, to ease writing code which works transparently both in
 	and out of ipython and uses some of this API.
 
 2006-05-16  Fernando Perez  <[e-mail]>
 
 	* IPython/hooks.py (result_display): Fix the fact that our display
 	hook was using str() instead of repr(), as the default python
 	console does.  This had gone unnoticed b/c it only happened if
 	%Pprint was off, but the inconsistency was there.
 
 2006-05-15  Ville Vainio  <[e-mail]>
 
 	* Oinspect.py: Only show docstring for nonexisting/binary files
 	when doing object??, closing ticket #62
 
 2006-05-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MTInteractiveShell.runsource): Fix threading
 	bug, closes http://www.scipy.net/roundup/ipython/issue55.  A lock
 	was being released in a routine which hadn't checked if it had
 	been the one to acquire it.
 
 2006-05-07  Fernando Perez  <[e-mail]>
 
 	* IPython/Release.py (version): put out 0.7.2.rc1 for testing.
 
 2006-04-11  Ville Vainio  <[e-mail]>
 
 	* iplib.py, ipmaker.py: .ipy extension now means "ipython batch file"
 	in command line. E.g. "ipython test.ipy" runs test.ipy with ipython
 	prefilters, allowing stuff like magics and aliases in the file.
 	
 	* Prompts.py, Extensions/clearcmd.py, ipy_system_conf.py: %clear magic
 	added. Supported now are "%clear in" and "%clear out" (clear input and
 	output history, respectively). Also fixed CachedOutput.flush to
 	properly flush the output cache.
 	
 	* Extensions/pspersistence.py: Fix %store to avoid "%store obj.attr"
 	half-success (and fail explicitly).
 
 2006-03-28  Ville Vainio  <[e-mail]>
 
 	* iplib.py: Fix quoting of aliases so that only argless ones
 	are quoted
 
 2006-03-28  Ville Vainio  <[e-mail]>
 
 	* iplib.py: Quote aliases with spaces in the name.
 	"c:\program files\blah\bin" is now legal alias target.
 	
 	* ext_rehashdir.py: Space no longer allowed as arg
 	separator, since space is legal in path names.
 	
 2006-03-16  Ville Vainio  <[e-mail]>
 
 	* upgrade_dir.py: Take path.py from Extensions, correcting
 	%upgrade magic
 	
 	* ipmaker.py: Suggest using %upgrade if ipy_user_conf.py isn't found.
 	
 	* hooks.py: Only enclose editor binary in quotes if legal and
 	necessary (space in the name, and is an existing file). Fixes a bug
 	reported by Zachary Pincus.
 
 2006-03-13  Fernando Perez  <[e-mail]>
 
 	* Manual: thanks to a tip on proper color handling for Emacs, by
 	Eric J Haywiser <ejh1-AT-MIT.EDU>.
 	
 	* ipython.el: close http://www.scipy.net/roundup/ipython/issue57
 	by applying the provided patch.  Thanks to Liu Jin
 	<m.liu.jin-AT-gmail.com> for the contribution.  No problems under
 	XEmacs/Linux, I'm trusting the submitter that it actually helps
 	under win32/GNU Emacs.  Will revisit if any problems are reported.
 
 2006-03-12  Fernando Perez  <[e-mail]>
 
 	* IPython/Gnuplot2.py (_FileClass): update for current Gnuplot.py
 	from SVN, thanks to a patch by Ryan Woodard <[e-mail]>.
 
 2006-03-12  Ville Vainio  <[e-mail]>
 
 	* Magic.py (magic_timeit): Added %timeit magic, contributed by
 	Torsten Marek.
 
 2006-03-12  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_macro): fix so that the n1-n2 syntax for
 	line ranges works again.
 
 2006-03-11  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (showtraceback): add back sys.last_traceback
 	and friends, after a discussion with Zach Pincus on ipython-user.
 	I'm not 100% sure, but after thinking about it quite a bit, it may
 	be OK.  Testing with the multithreaded shells didn't reveal any
 	problems, but let's keep an eye out.
 
 	In the process, I fixed a few things which were calling
 	self.InteractiveTB() directly (like safe_execfile), which is a
 	mistake: ALL exception reporting should be done by calling
 	self.showtraceback(), which handles state and tab-completion and
 	more.
 
 2006-03-01  Ville Vainio  <[e-mail]>
 
 	* Extensions/ipipe.py: Added Walter Doerwald's "ipipe" module.
 	To use, do "from ipipe import *".
 
 2006-02-24  Ville Vainio  <[e-mail]>
 
 	* Magic.py, upgrade_dir.py: %upgrade magic added. Does things more
 	"cleanly" and safely than the older upgrade mechanism.
 
 2006-02-21  Ville Vainio  <[e-mail]>
 
 	* Magic.py: %save works again.
 
 2006-02-15  Ville Vainio  <[e-mail]>
 
 	* Magic.py: %Pprint works again
 	
 	* Extensions/ipy_sane_defaults.py: Provide everything provided
 	in default ipythonrc, to make it possible to have a completely empty
 	ipythonrc (and thus completely rc-file free configuration)
 
 2006-02-11  Fernando Perez  <[e-mail]>
 
 	* IPython/hooks.py (editor): quote the call to the editor command,
 	to allow commands with spaces in them.  Problem noted by watching
 	Ian Oswald's video about textpad under win32 at
 	http://showmedo.com/videoListPage?listKey=PythonIPythonSeries
 
 	* IPython/UserConfig/ipythonrc: Replace @ signs with % when
 	describing magics (we haven't used @ for a loong time).
 
 	* IPython/ultraTB.py (VerboseTB.text.text_repr): Added patch
 	contributed by marienz to close
 	http://www.scipy.net/roundup/ipython/issue53.
 
 2006-02-10  Ville Vainio  <[e-mail]>
 
 	* genutils.py: getoutput now works in win32 too
 	
 	* completer.py: alias and magic completion only invoked
 	at the first "item" in the line, to avoid "cd %store"
 	nonsense.
 	
 2006-02-09  Ville Vainio  <[e-mail]>
 
 	* test/*: Added a unit testing framework (finally).
 	'%run runtests.py' to run test_*.
 	
 	* ipapi.py: Exposed runlines and set_custom_exc
 
 2006-02-07  Ville Vainio  <[e-mail]>
 
 	* iplib.py: don't split "f 1 2" to "f(1,2)" in autocall,
 	instead use "f(1 2)" as before.
 
 2006-02-05  Fernando Perez  <[e-mail]>
 
 	* IPython/demo.py (IPythonDemo): Add new classes to the demo
 	facilities, for demos processed by the IPython input filter
 	(IPythonDemo), and for running a script one-line-at-a-time as a
 	demo, both for pure Python (LineDemo) and for IPython-processed
 	input (IPythonLineDemo).  After a request by Dave Kohel, from the
 	SAGE team.
 	(Demo.edit): added an edit() method to the demo objects, to edit
 	the in-memory copy of the last executed block.
 
 	* IPython/Magic.py (magic_edit): add '-r' option for 'raw'
 	processing to %edit, %macro and %save.  These commands can now be
 	invoked on the unprocessed input as it was typed by the user
 	(without any prefilters applied).  After requests by the SAGE team
 	at SAGE days 2006: http://modular.ucsd.edu/sage/days1/schedule.html.
 
 2006-02-01  Ville Vainio  <[e-mail]>
 
 	* setup.py, eggsetup.py: easy_install ipython==dev works
 	correctly now (on Linux)
 	
 	* ipy_user_conf,ipmaker: user config changes, removed spurious
 	warnings
 	
 	* iplib: if rc.banner is string, use it as is.
 	
 	* Magic: %pycat accepts a string argument and pages it's contents.
 
 
 2006-01-30  Ville Vainio  <[e-mail]>
 
 	* pickleshare,pspersistence,ipapi,Magic: persistence overhaul.
 	Now %store and bookmarks work through PickleShare, meaning that
 	concurrent access is possible and all ipython sessions see the
 	same database situation all the time, instead of snapshot of
 	the situation when the session was started. Hence, %bookmark
 	results are immediately accessible from othes sessions. The database
 	is also available for use by user extensions. See:
 	http://www.python.org/pypi/pickleshare
 	
 	* hooks.py: Two new hooks, 'shutdown_hook' and 'late_startup_hook'.
 	
 	* aliases can now be %store'd
 	
 	* path.py moved to Extensions so that pickleshare does not need
 	IPython-specific import. Extensions added to pythonpath right
 	at __init__.
 	
 	* iplib.py: ipalias deprecated/redundant; aliases are converted and
 	called with _ip.system and the pre-transformed command string.
 
 2006-01-29  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (interact): Fix that we were not catching
 	KeyboardInterrupt exceptions properly.  I'm not quite sure why the
 	logic here had to change, but it's fixed now.
 
 2006-01-29  Ville Vainio  <[e-mail]>
 
 	* iplib.py: Try to import pyreadline on Windows.
 
 2006-01-27  Ville Vainio  <[e-mail]>
 
 	* iplib.py: Expose ipapi as _ip in builtin namespace.
 	Makes ipmagic (-> _ip.magic), ipsystem (-> _ip.system)
 	and ip_set_hook (-> _ip.set_hook) redundant. % and !
 	syntax now produce _ip.* variant of the commands.
 	
 	* "_ip.options().autoedit_syntax = 2" automatically throws
 	user to editor for syntax error correction without prompting.
 
 2006-01-27  Ville Vainio  <[e-mail]>
 
 	* ipmaker.py: Give "realistic" sys.argv for scripts (without
 	'ipython' at argv[0]) executed through command line.
 	NOTE: this DEPRECATES calling ipython with multiple scripts
 	("ipython a.py b.py c.py")
 	
 	* iplib.py, hooks.py: Added configurable input prefilter,
 	named 'input_prefilter'. See ext_rescapture.py for example
 	usage.
 	
 	* ext_rescapture.py, Magic.py: Better system command output capture
 	through 'var = !ls' (deprecates user-visible %sc). Same notation
 	applies for magics, 'var = %alias' assigns alias list to var.
 	
 	* ipapi.py: added meta() for accessing extension-usable data store.
 	
 	* iplib.py: added InteractiveShell.getapi(). New magics should be
 	written doing self.getapi() instead of using the shell directly.
 	
 	* Magic.py: %store now allows doing %store foo > ~/myfoo.txt and
 	%store foo >> ~/myfoo.txt to store variables to files (in clean
 	textual form, not a restorable pickle).
 	
 	* ipmaker.py: now import ipy_profile_PROFILENAME automatically
 	
 	* usage.py, Magic.py: added %quickref
 	
 	* iplib.py: ESC_PAREN fixes: /f 1 2 -> f(1,2), not f(1 2).
 	
 	* GetoptErrors when invoking magics etc. with wrong args
 	are now more helpful:
 	GetoptError: option -l not recognized (allowed: "qb" )
 
 2006-01-25  Fernando Perez  <[e-mail]>
 
 	* IPython/demo.py (Demo.show): Flush stdout after each block, so
 	computationally intensive blocks don't appear to stall the demo.
 
 2006-01-24  Ville Vainio  <[e-mail]>
 
 	* iplib.py, hooks.py: 'result_display' hook can return a non-None
 	value to manipulate resulting history entry.
 	
 	* ipapi.py: Moved TryNext here from hooks.py. Moved functions
 	to instance methods of IPApi class, to make extending an embedded
 	IPython feasible. See ext_rehashdir.py for example usage.
 	
 	* Merged 1071-1076 from branches/0.7.1
 
 
 2006-01-23  Fernando Perez  <[e-mail]>
 
 	* tools/release (daystamp): Fix build tools to use the new
 	eggsetup.py script to build lightweight eggs.
 
 	* Applied changesets 1062 and 1064 before 0.7.1 release.
 	
 	* IPython/Magic.py (magic_history): Add '-r' option to %hist, to
 	see the raw input history (without conversions like %ls ->
 	ipmagic("ls")).  After a request from W. Stein, SAGE
 	(http://modular.ucsd.edu/sage) developer.  This information is
 	stored in the input_hist_raw attribute of the IPython instance, so
 	developers can access it if needed (it's an InputList instance).
 	
 	* Versionstring = 0.7.2.svn
 	
 	* eggsetup.py: A separate script for constructing eggs, creates
 	proper launch scripts even on Windows (an .exe file in
 	\python24\scripts).
 	
 	* ipapi.py: launch_new_instance, launch entry point needed for the
 	egg.
 
 2006-01-23  Ville Vainio  <[e-mail]>
 
 	* Added %cpaste magic for pasting python code
 
 2006-01-22  Ville Vainio  <[e-mail]>
 
 	* Merge from branches/0.7.1 into trunk, revs 1052-1057
 	
 	* Versionstring = 0.7.2.svn
 	
 	* eggsetup.py: A separate script for constructing eggs, creates
 	proper launch scripts even on Windows (an .exe file in
 	\python24\scripts).
 	
 	* ipapi.py: launch_new_instance, launch entry point needed for the
 	egg.
 
 2006-01-22  Fernando Perez  <[e-mail]>
 
 	* IPython/OInspect.py (Inspector.pinfo): fix bug where foo?? or
 	%pfile foo would print the file for foo even if it was a binary.
 	Now, extensions '.so' and '.dll' are skipped.
 
 	* IPython/Shell.py (MTInteractiveShell.__init__): Fix threading
 	bug, where macros would fail in all threaded modes.  I'm not 100%
 	sure, so I'm going to put out an rc instead of making a release
 	today, and wait for feedback for at least a few days.
 
 	* IPython/iplib.py (handle_normal): fix (finally? somehow I doubt
 	it...) the handling of pasting external code with autoindent on.
 	To get out of a multiline input, the rule will appear for most
 	users unchanged: two blank lines or change the indent level
 	proposed by IPython.  But there is a twist now: you can
 	add/subtract only *one or two spaces*.  If you add/subtract three
 	or more (unless you completely delete the line), IPython will
 	accept that line, and you'll need to enter a second one of pure
 	whitespace.  I know it sounds complicated, but I can't find a
 	different solution that covers all the cases, with the right
 	heuristics.  Hopefully in actual use, nobody will really notice
 	all these strange rules and things will 'just work'.
 
 2006-01-21  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (interact): catch exceptions which can be
 	triggered asynchronously by signal handlers.  Thanks to an
 	automatic crash report, submitted by Colin Kingsley
 	<tercel-AT-gentoo.org>.
 	
 2006-01-20  Ville Vainio  <[e-mail]>
 
 	* Ipython/Extensions/ext_rehashdir.py: Created a usable example
 	(%rehashdir, very useful, try it out) of how to extend ipython
 	with new magics. Also added Extensions dir to pythonpath to make
 	importing extensions easy.
 	
 	* %store now complains when trying to store interactively declared
 	classes / instances of those classes.
 	
 	* Extensions/ipy_system_conf.py, UserConfig/ipy_user_conf.py,
 	ipmaker.py: Config rehaul. Now ipy_..._conf.py are always imported
 	if they exist, and ipy_user_conf.py with some defaults is created for
 	the user.
 	
 	* Startup rehashing done by the config file, not InterpreterExec.
 	This means system commands are available even without selecting the
 	pysh profile. It's the sensible default after all.
 
 2006-01-20  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (raw_input): I _think_ I got the pasting of
 	multiline code with autoindent on working.  But I am really not
 	sure, so this needs more testing.  Will commit a debug-enabled
 	version for now, while I test it some more, so that Ville and
 	others may also catch any problems.  Also made
 	self.indent_current_str() a method, to ensure that there's no
 	chance of the indent space count and the corresponding string
 	falling out of sync.  All code needing the string should just call
 	the method.
 
 2006-01-18  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_edit): fix check for when users don't
 	save their output files, the try/except was in the wrong section.
 
 2006-01-17  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_run): fix __file__ global missing from
 	script's namespace when executed via %run.  After a report by
 	Vivian.
 
 	* IPython/Debugger.py (Pdb.__init__): Fix breakage with '%run -d'
 	when using python 2.4.  The parent constructor changed in 2.4, and
 	we need to track it directly (we can't call it, as it messes up
 	readline and tab-completion inside our pdb would stop working).
 	After a bug report by R. Bernstein <rocky-AT-panix.com>.
 
 2006-01-16  Ville Vainio  <[e-mail]>
 
 	* Ipython/magic.py: Reverted back to old %edit functionality
 	that returns file contents on exit.
 	
 	* IPython/path.py: Added Jason Orendorff's "path" module to
 	IPython tree, http://www.jorendorff.com/articles/python/path/.
 	You can get path objects conveniently through %sc, and !!, e.g.:
 	 sc files=ls
 	 for p in files.paths: # or files.p
 	     print p,p.mtime
 	
 	* Ipython/iplib.py:"," and ";" autoquoting-upon-autocall
 	now work again without considering the exclusion regexp -
 	hence, things like ',foo my/path' turn to 'foo("my/path")'
 	instead of syntax error.
 	
 
 2006-01-14  Ville Vainio  <[e-mail]>
 
 	* IPython/ipapi.py (ashook, asmagic, options): Added convenience
 	ipapi decorators for python 2.4 users, options() provides access to rc
 	data.
 	
 	* IPython/Magic.py (magic_cd): %cd now accepts backslashes
 	as path separators (even on Linux ;-). Space character after
 	backslash (as yielded by tab completer) is still space;
 	"%cd long\ name" works as expected.
 
 	* IPython/ipapi.py,hooks.py,iplib.py: Hooks now implemented
 	as "chain of command", with priority. API stays the same,
 	TryNext exception raised by a hook function signals that
 	current hook failed and next hook should try handling it, as
 	suggested by Walter Dörwald <[e-mail]>. Walter also
 	requested configurable display hook, which is now implemented.
 
 2006-01-13  Ville Vainio  <[e-mail]>
 
 	* IPython/platutils*.py: platform specific utility functions,
 	so far only set_term_title is implemented (change terminal
 	label in windowing systems). %cd now changes the title to
 	current dir.
 
 	* IPython/Release.py: Added myself to "authors" list,
 	had to create new files.
 	
 	* IPython/iplib.py (handle_shell_escape): fixed logical flaw in
 	shell escape; not a known bug but had potential to be one in the
 	future.
 
 	* IPython/ipapi.py (added),OInspect.py,iplib.py: "Public"
 	extension API for IPython! See the module for usage example. Fix
 	OInspect for docstring-less magic functions.
 	
 
 2006-01-13  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (raw_input): temporarily deactivate all
 	attempts at allowing pasting of code with autoindent on.  It
 	introduced bugs (reported by Prabhu) and I can't seem to find a
 	robust combination which works in all cases.  Will have to revisit
 	later.
 
 	* IPython/genutils.py: remove isspace() function.  We've dropped
 	2.2 compatibility, so it's OK to use the string method.
 
 2006-01-12  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): fix regexp
 	matching what NOT to autocall on, to include all python binary
 	operators (including things like 'and', 'or', 'is' and 'in').
 	Prompted by a bug report on 'foo & bar', but I realized we had
 	many more potential bug cases with other operators.  The regexp is
 	self.re_exclude_auto, it's fairly commented.
 
 2006-01-12  Ville Vainio  <[e-mail]>
 
 	* IPython/iplib.py (make_quoted_expr,handle_shell_escape):
 	Prettified and hardened string/backslash quoting with ipsystem(),
 	ipalias() and ipmagic(). Now even \ characters are passed to
 	%magics, !shell escapes and aliases exactly as they are in the
 	ipython command line. Should improve backslash experience,
 	particularly in Windows (path delimiter for some commands that
 	won't understand '/'), but Unix benefits as well (regexps). %cd
 	magic still doesn't support backslash path delimiters, though. Also
 	deleted all pretense of supporting multiline command strings in
 	!system or %magic commands. Thanks to Jerry McRae for suggestions.
 	
 	* doc/build_doc_instructions.txt added. Documentation on how to
 	use doc/update_manual.py, added yesterday. Both files contributed
 	by Jörgen Stenarson <jorgen.stenarson-AT-bostream.nu>. This slates
 	doc/*.sh for deprecation at a later date.
 	
 	* /ipython.py Added ipython.py to root directory for
 	zero-installation (tar xzvf ipython.tgz; cd ipython; python
 	ipython.py) and development convenience (no need to keep doing
 	"setup.py install" between changes).
 	
 	* Made ! and !! shell escapes work (again) in multiline expressions:
 	  if 1:
 	      !ls
 	      !!ls
 
 2006-01-12  Fernando Perez  <[e-mail]>
 
 	* IPython/ipstruct.py (Struct): Rename IPython.Struct to
 	IPython.ipstruct, to avoid local shadowing of the stdlib 'struct'
 	module in case-insensitive installation.  Was causing crashes
 	under win32.  Closes http://www.scipy.net/roundup/ipython/issue49.
 
 	* IPython/Magic.py (magic_pycat): Fix pycat, patch by Marien Zwart
 	<marienz-AT-gentoo.org>, closes
 	http://www.scipy.net/roundup/ipython/issue51.
 
 2006-01-11  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.on_timer): Finally fix the
 	problem of excessive CPU usage under *nix and keyboard lag under
 	win32.
 
 2006-01-10  *** Released version 0.7.0
 
 2006-01-10  Fernando Perez  <[e-mail]>
 
 	* IPython/Release.py (revision): tag version number to 0.7.0,
 	ready for release.
 
 	* IPython/Magic.py (magic_edit): Add print statement to %edit so
 	it informs the user of the name of the temp. file used.  This can
 	help if you decide later to reuse that same file, so you know
 	where to copy the info from.
 
 2006-01-09  Fernando Perez  <[e-mail]>
 
 	* setup_bdist_egg.py: little script to build an egg.  Added
 	support in the release tools as well.
 
 2006-01-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellWX.__init__): add support for WXPython
 	version selection (new -wxversion command line and ipythonrc
 	parameter).  Patch contributed by Arnd Baecker
 	<arnd.baecker-AT-web.de>.
 
 	* IPython/iplib.py (embed_mainloop): fix tab-completion in
 	embedded instances, for variables defined at the interactive
 	prompt of the embedded ipython.  Reported by Arnd.
 
 	* IPython/Magic.py (magic_autocall): Fix %autocall magic.  Now
 	it can be used as a (stateful) toggle, or with a direct parameter.
 
 	* IPython/ultraTB.py (_fixed_getinnerframes): remove debug assert which
 	could be triggered in certain cases and cause the traceback
 	printer not to work.
 
 2006-01-07  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (_should_recompile): Small fix, closes
 	http://www.scipy.net/roundup/ipython/issue48.  Patch by Scott.
 
 2006-01-04  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.mainloop): fix bug in the GTK
 	backend for matplotlib (100% cpu utiliziation).  Thanks to Charlie
 	Moad for help with tracking it down.
 
 	* IPython/iplib.py (handle_auto): fix autocall handling for
 	objects which support BOTH __getitem__ and __call__ (so that f [x]
 	is left alone, instead of becoming f([x]) automatically).
 
 	* IPython/Magic.py (magic_cd): fix crash when cd -b was used.
 	Ville's patch.
 
 2006-01-03  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_auto): changed autocall semantics to
 	include 'smart' mode, where the autocall transformation is NOT
 	applied if there are no arguments on the line.  This allows you to
 	just type 'foo' if foo is a callable to see its internal form,
 	instead of having it called with no arguments (typically a
 	mistake).  The old 'full' autocall still exists: for that, you
 	need to set the 'autocall' parameter to 2 in your ipythonrc file.
 
 	* IPython/completer.py (Completer.attr_matches): add
 	tab-completion support for Enthoughts' traits.  After a report by
 	Arnd and a patch by Prabhu.
 
 2006-01-02  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (_fixed_getinnerframes): added Alex
 	Schmolck's patch to fix inspect.getinnerframes().
 
 	* IPython/iplib.py (InteractiveShell.__init__): significant fixes
 	for embedded instances, regarding handling of namespaces and items
 	added to the __builtin__ one.  Multiple embedded instances and
 	recursive embeddings should work better now (though I'm not sure
 	I've got all the corner cases fixed, that code is a bit of a brain
 	twister).
 
 	* IPython/Magic.py (magic_edit): added support to edit in-memory
 	macros (automatically creates the necessary temp files).  %edit
 	also doesn't return the file contents anymore, it's just noise.
 
 	* IPython/completer.py (Completer.attr_matches): revert change to
 	complete only on attributes listed in __all__.  I realized it
 	cripples the tab-completion system as a tool for exploring the
 	internals of unknown libraries (it renders any non-__all__
 	attribute off-limits).  I got bit by this when trying to see
 	something inside the dis module.
 
 2005-12-31  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): add .meta
 	namespace for users and extension writers to hold data in.  This
 	follows the discussion in
 	http://projects.scipy.org/ipython/ipython/wiki/RefactoringIPython.
 
 	* IPython/completer.py (IPCompleter.complete): small patch to help
 	tab-completion under Emacs, after a suggestion by John Barnard
 	<barnarj-AT-ccf.org>.
 
 	* IPython/Magic.py (Magic.extract_input_slices): added support for
 	the slice notation in magics to use N-M to represent numbers N...M
 	(closed endpoints).  This is used by %macro and %save.
 
 	* IPython/completer.py (Completer.attr_matches): for modules which
 	define __all__, complete only on those.  After a patch by Jeffrey
 	Collins <jcollins_boulder-AT-earthlink.net>.  Also, clean up and
 	speed up this routine.
 
 	* IPython/Logger.py (Logger.log): fix a history handling bug.  I
 	don't know if this is the end of it, but the behavior now is
 	certainly much more correct.  Note that coupled with macros,
 	slightly surprising (at first) behavior may occur: a macro will in
 	general expand to multiple lines of input, so upon exiting, the
 	in/out counters will both be bumped by the corresponding amount
 	(as if the macro's contents had been typed interactively).  Typing
 	%hist will reveal the intermediate (silently processed) lines.
 
 	* IPython/Magic.py (magic_run): fix a subtle bug which could cause
 	pickle to fail (%run was overwriting __main__ and not restoring
 	it, but pickle relies on __main__ to operate).
 
 	* IPython/iplib.py (InteractiveShell): fix pdb calling: I'm now
 	using properties, but forgot to make the main InteractiveShell
 	class a new-style class.  Properties fail silently, and
 	mysteriously, with old-style class (getters work, but
 	setters don't do anything).
 
 2005-12-30  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_history): fix history reporting bug (I
 	know some nasties are still there, I just can't seem to find a
 	reproducible test case to track them down; the input history is
 	falling out of sync...)
 
 	* IPython/iplib.py (handle_shell_escape): fix bug where both
 	aliases and system accesses where broken for indented code (such
 	as loops).
 
 	* IPython/genutils.py (shell): fix small but critical bug for
 	win32 system access.
 
 2005-12-29  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (showtraceback): remove use of the
 	sys.last_{type/value/traceback} structures, which are non
 	thread-safe.
 	(_prefilter): change control flow to ensure that we NEVER
 	introspect objects when autocall is off.  This will guarantee that
 	having an input line of the form 'x.y', where access to attribute
 	'y' has side effects, doesn't trigger the side effect TWICE.  It
 	is important to note that, with autocall on, these side effects
 	can still happen.
 	(ipsystem): new builtin, to complete the ip{magic/alias/system}
 	trio.  IPython offers these three kinds of special calls which are
 	not python code, and it's a good thing to have their call method
 	be accessible as pure python functions (not just special syntax at
 	the command line).  It gives us a better internal implementation
 	structure, as well as exposing these for user scripting more
 	cleanly.
 
 	* IPython/macro.py (Macro.__init__): moved macros to a standalone
 	file.  Now that they'll be more likely to be used with the
 	persistance system (%store), I want to make sure their module path
 	doesn't change in the future, so that we don't break things for
 	users' persisted data.
 
 	* IPython/iplib.py (autoindent_update): move indentation
 	management into the _text_ processing loop, not the keyboard
 	interactive one.  This is necessary to correctly process non-typed
 	multiline input (such as macros).
 
 	* IPython/Magic.py (Magic.format_latex): patch by Stefan van der
 	Walt <stefan-AT-sun.ac.za> to fix latex formatting of docstrings,
 	which was producing problems in the resulting manual.
 	(magic_whos): improve reporting of instances (show their class,
 	instead of simply printing 'instance' which isn't terribly
 	informative).
 
 	* IPython/genutils.py (shell): commit Jorgen Stenarson's patch
 	(minor mods) to support network shares under win32.
 
 	* IPython/winconsole.py (get_console_size): add new winconsole
 	module and fixes to page_dumb() to improve its behavior under
 	win32.  Contributed by Alexander Belchenko <bialix-AT-ukr.net>.
 
 	* IPython/Magic.py (Macro): simplified Macro class to just
 	subclass list.  We've had only 2.2 compatibility for a very long
 	time, yet I was still avoiding subclassing the builtin types.  No
 	more (I'm also starting to use properties, though I won't shift to
 	2.3-specific features quite yet).
 	(magic_store): added Ville's patch for lightweight variable
 	persistence, after a request on the user list by Matt Wilkie
 	<maphew-AT-gmail.com>.  The new %store magic's docstring has full
 	details.
 
 	* IPython/iplib.py (InteractiveShell.post_config_initialization):
 	changed the default logfile name from 'ipython.log' to
 	'ipython_log.py'.  These logs are real python files, and now that
 	we have much better multiline support, people are more likely to
 	want to use them as such.  Might as well name them correctly.
 
 	* IPython/Magic.py: substantial cleanup.  While we can't stop
 	using magics as mixins, due to the existing customizations 'out
 	there' which rely on the mixin naming conventions, at least I
 	cleaned out all cross-class name usage.  So once we are OK with
 	breaking compatibility, the two systems can be separated.
 
 	* IPython/Logger.py: major cleanup.  This one is NOT a mixin
 	anymore, and the class is a fair bit less hideous as well.  New
 	features were also introduced: timestamping of input, and logging
 	of output results.  These are user-visible with the -t and -o
 	options to %logstart.  Closes
 	http://www.scipy.net/roundup/ipython/issue11 and a request by
 	William Stein (SAGE developer - http://modular.ucsd.edu/sage).
 
 2005-12-28  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_shell_escape): add Ville's patch to
 	better handle backslashes in paths.  See the thread 'More Windows
 	questions part 2 - \/ characters revisited' on the iypthon user
 	list:
 	http://scipy.net/pipermail/ipython-user/2005-June/000907.html
 
 	(InteractiveShell.__init__): fix tab-completion bug in threaded shells.
 
 	(InteractiveShell.__init__): change threaded shells to not use the
 	ipython crash handler.  This was causing more problems than not,
 	as exceptions in the main thread (GUI code, typically) would
 	always show up as a 'crash', when they really weren't.
 
 	The colors and exception mode commands (%colors/%xmode) have been
 	synchronized to also take this into account, so users can get
 	verbose exceptions for their threaded code as well.  I also added
 	support for activating pdb inside this exception handler as well,
 	so now GUI authors can use IPython's enhanced pdb at runtime.
 
 	* IPython/ipmaker.py (make_IPython): make the autoedit_syntax flag
 	true by default, and add it to the shipped ipythonrc file.  Since
 	this asks the user before proceeding, I think it's OK to make it
 	true by default.
 
 	* IPython/Magic.py (magic_exit): make new exit/quit magics instead
 	of the previous special-casing of input in the eval loop.  I think
 	this is cleaner, as they really are commands and shouldn't have
 	a special role in the middle of the core code.
 
 2005-12-27  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (edit_syntax_error): added support for
 	automatically reopening the editor if the file had a syntax error
 	in it.  Thanks to scottt who provided the patch at:
 	http://www.scipy.net/roundup/ipython/issue36 (slightly modified
 	version committed).
 
 	* IPython/iplib.py (handle_normal): add suport for multi-line
 	input with emtpy lines.  This fixes
 	http://www.scipy.net/roundup/ipython/issue43 and a similar
 	discussion on the user list.
 
 	WARNING: a behavior change is necessarily introduced to support
 	blank lines: now a single blank line with whitespace does NOT
 	break the input loop, which means that when autoindent is on, by
 	default hitting return on the next (indented) line does NOT exit.
 
 	Instead, to exit a multiline input you can either have:
 
 	  - TWO whitespace lines (just hit return again), or
 	  - a single whitespace line of a different length than provided
 	by the autoindent (add or remove a space).
 
 	* IPython/completer.py (MagicCompleter.__init__): new 'completer'
 	module to better organize all readline-related functionality.
 	I've deleted FlexCompleter and put all completion clases here.
 
 	* IPython/iplib.py (raw_input): improve indentation management.
 	It is now possible to paste indented code with autoindent on, and
 	the code is interpreted correctly (though it still looks bad on
 	screen, due to the line-oriented nature of ipython).
 	(MagicCompleter.complete): change behavior so that a TAB key on an
 	otherwise empty line actually inserts a tab, instead of completing
 	on the entire global namespace.  This makes it easier to use the
 	TAB key for indentation.  After a request by Hans Meine
 	<hans_meine-AT-gmx.net>
 	(_prefilter): add support so that typing plain 'exit' or 'quit'
 	does a sensible thing.  Originally I tried to deviate as little as
 	possible from the default python behavior, but even that one may
 	change in this direction (thread on python-dev to that effect).
 	Regardless, ipython should do the right thing even if CPython's
 	'>>>' prompt doesn't.
 	(InteractiveShell): removed subclassing code.InteractiveConsole
 	class.  By now we'd overridden just about all of its methods: I've
 	copied the remaining two over, and now ipython is a standalone
 	class.  This will provide a clearer picture for the chainsaw
 	branch refactoring.
 
 2005-12-26  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.text): harden reporting against
 	failures for objects which break when dir() is called on them.
 
 	* IPython/FlexCompleter.py (Completer.__init__): Added support for
 	distinct local and global namespaces in the completer API.  This
 	change allows us to properly handle completion with distinct
 	scopes, including in embedded instances (this had never really
 	worked correctly).
 
 	Note: this introduces a change in the constructor for
 	MagicCompleter, as a new global_namespace parameter is now the
 	second argument (the others were bumped one position).
 
 2005-12-25  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (embed_mainloop): fix tab-completion in
 	embedded instances (which can be done now thanks to Vivian's
 	frame-handling fixes for pdb).
 	(InteractiveShell.__init__): Fix namespace handling problem in
 	embedded instances.  We were overwriting __main__ unconditionally,
 	and this should only be done for 'full' (non-embedded) IPython;
 	embedded instances must respect the caller's __main__.  Thanks to
 	a bug report by Yaroslav Bulatov <yaroslavvb-AT-gmail.com>
 
 2005-12-24  Fernando Perez  <[e-mail]>
 
 	* setup.py: added download_url to setup().  This registers the
 	download address at PyPI, which is not only useful to humans
 	browsing the site, but is also picked up by setuptools (the Eggs
 	machinery).  Thanks to Ville and R. Kern for the info/discussion
 	on this.
 
 2005-12-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Debugger.py (Pdb.__init__): Major pdb mode enhancements.
 	This brings a lot of nice functionality to the pdb mode, which now
 	has tab-completion, syntax highlighting, and better stack handling
 	than before.  Many thanks to Vivian De Smedt
 	<vivian-AT-vdesmedt.com> for the original patches.
 
 2005-12-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.mainloop): fix mainloop() calling
 	sequence to consistently accept the banner argument.  The
 	inconsistency was tripping SAGE, thanks to Gary Zablackis
 	<gzabl-AT-yahoo.com> for the report.
 
 2005-11-15  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.post_config_initialization):
 	Fix bug where a naked 'alias' call in the ipythonrc file would
 	cause a crash.  Bug reported by Jorgen Stenarson.
 
 2005-11-15  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): cleanups which should improve
 	startup time.
 
 	* IPython/iplib.py (runcode): my globals 'fix' for embedded
 	instances had introduced a bug with globals in normal code.  Now
 	it's working in all cases.
 
 	* IPython/Magic.py (magic_psearch): Finish wildcard cleanup and
 	API changes.  A new ipytonrc option, 'wildcards_case_sensitive'
 	has been introduced to set the default case sensitivity of the
 	searches.  Users can still select either mode at runtime on a
 	per-search basis.
 
 2005-11-13 Fernando Perez   <[e-mail]>
 
 	* IPython/wildcard.py (NameSpace.__init__): fix resolution of
 	attributes in wildcard searches for subclasses.  Modified version
 	of a patch by Jorgen.
 
 2005-11-12 Fernando Perez   <[e-mail]>
 
 	* IPython/iplib.py (embed_mainloop): Fix handling of globals for
 	embedded instances.  I added a user_global_ns attribute to the
 	InteractiveShell class to handle this.
 
 2005-10-31  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.mainloop): Change timeout_add to
 	idle_add, which fixes horrible keyboard lag problems under gtk 2.6
 	(reported under win32, but may happen also in other platforms).
 	Bug report and fix courtesy of Sean Moore <smm-AT-logic.bm>
 
 2005-10-15  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_psearch): new support for wildcard
 	patterns.  Now, typing ?a*b will list all names which begin with a
 	and end in b, for example.  The %psearch magic has full
 	docstrings.  Many thanks to Jörgen Stenarson
 	<jorgen.stenarson-AT-bostream.nu>, author of the patches
 	implementing this functionality.
 
 2005-09-27  Fernando Perez  <[e-mail]>
 
 	* Manual: fixed long-standing annoyance of double-dashes (as in
 	--prefix=~, for example) being stripped in the HTML version.  This
 	is a latex2html bug, but a workaround was provided.  Many thanks
 	to George K. Thiruvathukal <gthiruv-AT-luc.edu> for the detailed
 	help, and Michael Tobis <mtobis-AT-gmail.com> for getting the ball
 	rolling.  This seemingly small issue had tripped a number of users
 	when first installing, so I'm glad to see it gone.
 	
 2005-09-27  Fernando Perez  <[e-mail]>
 
 	* IPython/Extensions/numeric_formats.py: fix missing import,
 	reported by Stephen Walton.
 
 2005-09-24  Fernando Perez  <[e-mail]>
 
 	* IPython/demo.py: finish demo module, fully documented now.
 
 	* IPython/genutils.py (file_read): simple little utility to read a
 	file and ensure it's closed afterwards.
 
 2005-09-23  Fernando Perez  <[e-mail]>
 
 	* IPython/demo.py (Demo.__init__): added support for individually
 	tagging blocks for automatic execution.
 
 	* IPython/Magic.py (magic_pycat): new %pycat magic for showing
 	syntax-highlighted python sources, requested by John.
 
 2005-09-22  Fernando Perez  <[e-mail]>
 
 	* IPython/demo.py (Demo.again): fix bug where again() blocks after
 	finishing.
 
 	* IPython/genutils.py (shlex_split): moved from Magic to here,
 	where all 2.2 compatibility stuff lives.  I needed it for demo.py.
 
 	* IPython/demo.py (Demo.__init__): added support for silent
 	blocks, improved marks as regexps, docstrings written.
 	(Demo.__init__): better docstring, added support for sys.argv.
 
 	* IPython/genutils.py (marquee): little utility used by the demo
 	code, handy in general.
 
 	* IPython/demo.py (Demo.__init__): new class for interactive
 	demos.  Not documented yet, I just wrote it in a hurry for
 	scipy'05.  Will docstring later.
 
 2005-09-20  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (sigint_handler): Drastic simplification which
 	also seems to make Ctrl-C work correctly across threads!  This is
 	so simple, that I can't beleive I'd missed it before.  Needs more
 	testing, though.
 	(KBINT): Never mind, revert changes.  I'm sure I'd tried something
 	like this before...
 
 	* IPython/genutils.py (get_home_dir): add protection against
 	non-dirs in win32 registry.
 
 	* IPython/iplib.py (InteractiveShell.alias_table_validate): fix
 	bug where dict was mutated while iterating (pysh crash).
 
 2005-09-06  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_auto): Fix inconsistency arising from
 	spurious newlines added by this routine.  After a report by
 	F. Mantegazza.
 
 2005-09-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (hijack_gtk): remove pygtk.require("2.0")
 	calls.  These were a leftover from the GTK 1.x days, and can cause
 	problems in certain cases (after a report by John Hunter).
 
 	* IPython/iplib.py (InteractiveShell.__init__): Trap exception if
 	os.getcwd() fails at init time.  Thanks to patch from David Remahl
 	<chmod007-AT-mac.com>.
 	(InteractiveShell.__init__): prevent certain special magics from
 	being shadowed by aliases.  Closes
 	http://www.scipy.net/roundup/ipython/issue41.
 
 2005-08-31  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.complete): Added new
 	top-level completion method to expose the completion mechanism
 	beyond readline-based environments.
 
 2005-08-19  Fernando Perez  <[e-mail]>
 
 	* tools/ipsvnc (svnversion): fix svnversion capture.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Add has_readline
 	attribute to self, which was missing.  Before, it was set by a
 	routine which in certain cases wasn't being called, so the
 	instance could end up missing the attribute.  This caused a crash.
 	Closes http://www.scipy.net/roundup/ipython/issue40.
 
 2005-08-16  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.text): don't crash if object
 	contains non-string attribute.  Closes
 	http://www.scipy.net/roundup/ipython/issue38.
 
 2005-08-14  Fernando Perez  <[e-mail]>
 
 	* tools/ipsvnc: Minor improvements, to add changeset info.
 
 2005-08-12  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (runsource): remove self.code_to_run_src
 	attribute.  I realized this is nothing more than
 	'\n'.join(self.buffer), and having the same data in two different
 	places is just asking for synchronization bugs.  This may impact
 	people who have custom exception handlers, so I need to warn
 	ipython-dev about it (F. Mantegazza may use them).
 
 2005-07-29  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py: fix 2.2 compatibility (generators)
 
 2005-07-18  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (get_home_dir): fix to help users with
 	invalid $HOME under win32.
 
 2005-07-17  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (str_safe): Make unicode-safe.  Also remove
 	some old hacks and clean up a bit other routines; code should be
 	simpler and a bit faster.
 
 	* IPython/iplib.py (interact): removed some last-resort attempts
 	to survive broken stdout/stderr.  That code was only making it
 	harder to abstract out the i/o (necessary for gui integration),
 	and the crashes it could prevent were extremely rare in practice
 	(besides being fully user-induced in a pretty violent manner).
 
 	* IPython/genutils.py (IOStream.__init__): Simplify the i/o stuff.
 	Nothing major yet, but the code is simpler to read; this should
 	make it easier to do more serious modifications in the future.
 
 	* IPython/Extensions/InterpreterExec.py: Fix auto-quoting in pysh,
 	which broke in .15 (thanks to a report by Ville).
 
 	* IPython/Itpl.py (Itpl.__init__): add unicode support (it may not
 	be quite correct, I know next to nothing about unicode).  This
 	will allow unicode strings to be used in prompts, amongst other
 	cases.  It also will prevent ipython from crashing when unicode
 	shows up unexpectedly in many places.  If ascii encoding fails, we
 	assume utf_8.  Currently the encoding is not a user-visible
 	setting, though it could be made so if there is demand for it.
 
 	* IPython/ipmaker.py (make_IPython): remove old 2.1-specific hack.
 
 	* IPython/Struct.py (Struct.merge): switch keys() to iterator.
 
 	* IPython/background_jobs.py: moved 2.2 compatibility to genutils.
 
 	* IPython/genutils.py: Add 2.2 compatibility here, so all other
 	code can work transparently for 2.2/2.3.
 
 2005-07-16  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (ExceptionColors): Make a global variable
 	out of the color scheme table used for coloring exception
 	tracebacks.  This allows user code to add new schemes at runtime.
 	This is a minimally modified version of the patch at
 	http://www.scipy.net/roundup/ipython/issue35, many thanks to pabw
 	for the contribution.
 
 	* IPython/FlexCompleter.py (Completer.attr_matches): Add a
 	slightly modified version of the patch in
 	http://www.scipy.net/roundup/ipython/issue34, which also allows me
 	to remove the previous try/except solution (which was costlier).
 	Thanks to Gaetan Lehmann <gaetan.lehmann-AT-jouy.inra.fr> for the fix.
 
 2005-06-08  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (write/write_err): Add methods to abstract all
 	I/O a bit more.
 
 	* IPython/Shell.py (IPShellGTK.mainloop): Fix GTK deprecation
 	warning, reported by Aric Hagberg, fix by JD Hunter.
 
 2005-06-02  *** Released version 0.6.15
 
 2005-06-01  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (MagicCompleter.file_matches): Fix
 	tab-completion of filenames within open-quoted strings.  Note that
 	this requires that in ~/.ipython/ipythonrc, users change the
 	readline delimiters configuration to read:
 
 	readline_remove_delims -/~
 	
 
 2005-05-31  *** Released version 0.6.14
 
 2005-05-29  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.text): Fix crash for tracebacks
 	with files not on the filesystem.  Reported by Eliyahu Sandler
 	<[e-mail]>
 
 2005-05-22  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py: Fix a few crashes in the --upgrade option.
 	After an initial report by LUK ShunTim <[e-mail]>.
 
 2005-05-19  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (safe_execfile): close a file which could be
 	left open (causing problems in win32, which locks open files).
 	Thanks to a bug report by D Brown <[e-mail]>.
 
 2005-05-18  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.mplot_exec): pass all
 	keyword arguments correctly to safe_execfile().
 
 2005-05-13  Fernando Perez  <[e-mail]>
 
 	* ipython.1: Added info about Qt to manpage, and threads warning
 	to usage page (invoked with --help).
 
 	* IPython/iplib.py (MagicCompleter.python_func_kw_matches): Added
 	new matcher (it goes at the end of the priority list) to do
 	tab-completion on named function arguments.  Submitted by George
 	Sakkis <gsakkis-AT-eden.rutgers.edu>.  See the thread at
 	http://www.scipy.net/pipermail/ipython-dev/2005-April/000436.html
 	for more details.
 
 	* IPython/Magic.py (magic_run): Added new -e flag to ignore
 	SystemExit exceptions in the script being run.  Thanks to a report
 	by danny shevitz <danny_shevitz-AT-yahoo.com>, about this
 	producing very annoying behavior when running unit tests.
 
 2005-05-12  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_auto): fixed auto-quoting and parens,
 	which I'd broken (again) due to a changed regexp.  In the process,
 	added ';' as an escape to auto-quote the whole line without
 	splitting its arguments.  Thanks to a report by Jerry McRae
 	<qrs0xyc02-AT-sneakemail.com>.
 
 	* IPython/ultraTB.py (VerboseTB.text): protect against rare but
 	possible crashes caused by a TokenError.  Reported by Ed Schofield
 	<schofield-AT-ftw.at>.
 	
 2005-05-06  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (hijack_wx): Fix to work with WX v.2.6.
 
 2005-04-29  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellQt): Thanks to Denis Rivière
 	<nudz-AT-free.fr>, Yann Cointepas <yann-AT-sapetnioc.org> and Benjamin
 	Thyreau <Benji2-AT-decideur.info>, we now have a -qthread option
 	which provides support for Qt interactive usage (similar to the
 	existing one for WX and GTK).  This had been often requested.
 
 2005-04-14  *** Released version 0.6.13
 
 2005-04-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic._ofind): remove docstring evaluation
 	from _ofind, which gets called on almost every input line.  Now,
 	we only try to get docstrings if they are actually going to be
 	used (the overhead of fetching unnecessary docstrings can be
 	noticeable for certain objects, such as Pyro proxies).
 
 	* IPython/iplib.py (MagicCompleter.python_matches): Change the API
 	for completers.  For some reason I had been passing them the state
 	variable, which completers never actually need, and was in
 	conflict with the rlcompleter API.  Custom completers ONLY need to
 	take the text parameter.
 
 	* IPython/Extensions/InterpreterExec.py: Fix regexp so that magics
 	work correctly in pysh.  I've also moved all the logic which used
 	to be in pysh.py here, which will prevent problems with future
 	upgrades.  However, this time I must warn users to update their
 	pysh profile to include the line
 
 	import_all IPython.Extensions.InterpreterExec
 
 	because otherwise things won't work for them.  They MUST also
 	delete pysh.py and the line
 
 	execfile pysh.py
 
 	from their ipythonrc-pysh.
 
 	* IPython/FlexCompleter.py (Completer.attr_matches): Make more
 	robust in the face of objects whose dir() returns non-strings
 	(which it shouldn't, but some broken libs like ITK do).  Thanks to
 	a patch by John Hunter (implemented differently, though).  Also
 	minor improvements by using .extend instead of + on lists.
 
 	* pysh.py: 
 
 2005-04-06  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): Make multi_line_specials on
 	by default, so that all users benefit from it.  Those who don't
 	want it can still turn it off.
 
 	* IPython/UserConfig/ipythonrc: Add multi_line_specials to the
 	config file, I'd forgotten about this, so users were getting it
 	off by default.
 
 	* IPython/iplib.py (ipmagic): big overhaul of the magic system for
 	consistency.  Now magics can be called in multiline statements,
 	and python variables can be expanded in magic calls via $var.
 	This makes the magic system behave just like aliases or !system
 	calls.
 
 2005-03-28  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_auto): cleanup to use %s instead of
 	expensive string additions for building command.  Add support for
 	trailing ';' when autocall is used.
 
 2005-03-26  Fernando Perez  <[e-mail]>
 
 	* ipython.el: Fix http://www.scipy.net/roundup/ipython/issue31.
 	Bugfix by A. Schmolck, the ipython.el maintainer.  Also make
 	ipython.el robust against prompts with any number of spaces
 	(including 0) after the ':' character.
 
 	* IPython/Prompts.py (Prompt2.set_p_str): Fix spurious space in
 	continuation prompt, which misled users to think the line was
 	already indented.  Closes debian Bug#300847, reported to me by
 	Norbert Tretkowski <tretkowski-AT-inittab.de>.
 
 2005-03-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (Prompt1.__str__): Make sure that prompts are
 	properly aligned if they have embedded newlines.
 
 	* IPython/iplib.py (runlines): Add a public method to expose
 	IPython's code execution machinery, so that users can run strings
 	as if they had been typed at the prompt interactively.
 	(InteractiveShell.__init__): Added getoutput() to the __IPYTHON__
 	methods which can call the system shell, but with python variable
 	expansion.  The three such methods are: __IPYTHON__.system,
 	.getoutput and .getoutputerror.  These need to be documented in a
 	'public API' section (to be written) of the manual.
 
 2005-03-20  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.set_custom_exc): new system
 	for custom exception handling.  This is quite powerful, and it
 	allows for user-installable exception handlers which can trap
 	custom exceptions at runtime and treat them separately from
 	IPython's default mechanisms.  At the request of Frédéric
 	Mantegazza <mantegazza-AT-ill.fr>.
 	(InteractiveShell.set_custom_completer): public API function to
 	add new completers at runtime.
 
 2005-03-19  Fernando Perez  <[e-mail]>
 
 	* IPython/OInspect.py (getdoc): Add a call to obj.getdoc(), to
 	allow objects which provide their docstrings via non-standard
 	mechanisms (like Pyro proxies) to still be inspected by ipython's
 	? system.
 
 	* IPython/iplib.py (InteractiveShell.__init__): back off the _o/_e
 	automatic capture system.  I tried quite hard to make it work
 	reliably, and simply failed.  I tried many combinations with the
 	subprocess module, but eventually nothing worked in all needed
 	cases (not blocking stdin for the child, duplicating stdout
 	without blocking, etc).  The new %sc/%sx still do capture to these
 	magical list/string objects which make shell use much more
 	conveninent, so not all is lost.
 
 	XXX - FIX MANUAL for the change above!
 
 	(runsource): I copied code.py's runsource() into ipython to modify
 	it a bit.  Now the code object and source to be executed are
 	stored in ipython.  This makes this info accessible to third-party
 	tools, like custom exception handlers.  After a request by Frédéric
 	Mantegazza <mantegazza-AT-ill.fr>.
 
 	* IPython/UserConfig/ipythonrc: Add up/down arrow keys to
 	history-search via readline (like C-p/C-n).  I'd wanted this for a
 	long time, but only recently found out how to do it.  For users
 	who already have their ipythonrc files made and want this, just
 	add:
 
 	readline_parse_and_bind "\e[A": history-search-backward
 	readline_parse_and_bind "\e[B": history-search-forward
 
 2005-03-18  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_sc): %sc and %sx now use the fancy
 	LSString and SList classes which allow transparent conversions
 	between list mode and whitespace-separated string.
 	(magic_r): Fix recursion problem in %r.
 
 	* IPython/genutils.py (LSString): New class to be used for
 	automatic storage of the results of all alias/system calls in _o
 	and _e (stdout/err).  These provide a .l/.list attribute which
 	does automatic splitting on newlines.  This means that for most
 	uses, you'll never need to do capturing of output with %sc/%sx
 	anymore, since ipython keeps this always done for you.  Note that
 	only the LAST results are stored, the _o/e variables are
 	overwritten on each call.  If you need to save their contents
 	further, simply bind them to any other name.
 
 2005-03-17  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (BasePrompt.cwd_filt): a few more fixes for
 	prompt namespace handling.
 
 2005-03-16  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (CachedOutput.__init__): Fix default and
 	classic prompts to be '>>> ' (final space was missing, and it
 	trips the emacs python mode).
 	(BasePrompt.__str__): Added safe support for dynamic prompt
 	strings.  Now you can set your prompt string to be '$x', and the
 	value of x will be printed from your interactive namespace.  The
 	interpolation syntax includes the full Itpl support, so
 	${foo()+x+bar()} is a valid prompt string now, and the function
 	calls will be made at runtime.
 
 2005-03-15  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_history): renamed %hist to %history, to
 	avoid name clashes in pylab.  %hist still works, it just forwards
 	the call to %history.
 
 2005-03-02  *** Released version 0.6.12
 
 2005-03-02  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (handle_magic): log magic calls properly as
 	ipmagic() function calls.
 
 	* IPython/Magic.py (magic_time): Improved %time to support
 	statements and provide wall-clock as well as CPU time.
 
 2005-02-27  Fernando Perez  <[e-mail]>
 
 	* IPython/hooks.py: New hooks module, to expose user-modifiable
 	IPython functionality in a clean manner.  For now only the editor
 	hook is actually written, and other thigns which I intend to turn
 	into proper hooks aren't yet there.  The display and prefilter
 	stuff, for example, should be hooks.  But at least now the
 	framework is in place, and the rest can be moved here with more
 	time later.  IPython had had a .hooks variable for a long time for
 	this purpose, but I'd never actually used it for anything.
 
 2005-02-26  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): make the default ipython
 	directory be called _ipython under win32, to follow more the
 	naming peculiarities of that platform (where buggy software like
 	Visual Sourcesafe breaks with .named directories).  Reported by
 	Ville Vainio.
 
 2005-02-23  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): removed a few
 	auto_aliases for win32 which were causing problems.  Users can
 	define the ones they personally like.
 
 2005-02-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_time): new magic to time execution of
 	expressions.  After a request by Charles Moad <cmoad-AT-indiana.edu>.
 
 2005-02-19  Fernando Perez  <[e-mail]>
 
 	* IPython/ConfigLoader.py (ConfigLoader.load): Allow empty strings
 	into keys (for prompts, for example).
 
 	* IPython/Prompts.py (BasePrompt.set_p_str): Fix to allow empty
 	prompts in case users want them.  This introduces a small behavior
 	change: ipython does not automatically add a space to all prompts
 	anymore.  To get the old prompts with a space, users should add it
 	manually to their ipythonrc file, so for example prompt_in1 should
 	now read 'In [\#]: ' instead of 'In [\#]:'.
 	(BasePrompt.__init__): New option prompts_pad_left (only in rc
 	file) to control left-padding of secondary prompts.
 
 	* IPython/Magic.py (Magic.profile_missing_notice): Don't crash if
 	the profiler can't be imported.  Fix for Debian, which removed
 	profile.py because of License issues.  I applied a slightly
 	modified version of the original Debian patch at
 	http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=294500.
 
 2005-02-17  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (native_line_ends): Fix bug which would
 	cause improper line-ends under win32 b/c I was not opening files
 	in binary mode.  Bug report and fix thanks to Ville.
 
 	* IPython/iplib.py (handle_auto): Fix bug which I introduced when
 	trying to catch spurious foo[1] autocalls.  My fix actually broke
 	',/' autoquote/call with explicit escape (bad regexp).
 
 2005-02-15  *** Released version 0.6.11
 
 2005-02-14  Fernando Perez  <[e-mail]>
 
 	* IPython/background_jobs.py: New background job management
 	subsystem.  This is implemented via a new set of classes, and
 	IPython now provides a builtin 'jobs' object for background job
 	execution.  A convenience %bg magic serves as a lightweight
 	frontend for starting the more common type of calls.  This was
 	inspired by discussions with B. Granger and the BackgroundCommand
 	class described in the book Python Scripting for Computational
 	Science, by H. P. Langtangen: http://folk.uio.no/hpl/scripting
 	(although ultimately no code from this text was used, as IPython's
 	system is a separate implementation).
 
 	* IPython/iplib.py (MagicCompleter.python_matches): add new option
 	to control the completion of single/double underscore names
 	separately.  As documented in the example ipytonrc file, the
 	readline_omit__names variable can now be set to 2, to omit even
 	single underscore names.  Thanks to a patch by Brian Wong
 	<BrianWong-AT-AirgoNetworks.Com>.
 	(InteractiveShell.__init__): Fix bug which would cause foo[1] to
 	be autocalled as foo([1]) if foo were callable.  A problem for
 	things which are both callable and implement __getitem__.
 	(init_readline): Fix autoindentation for win32.  Thanks to a patch
 	by Vivian De Smedt <vivian-AT-vdesmedt.com>.
 
 2005-02-12  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): Disabled the stout traps
 	which I had written long ago to sort out user error messages which
 	may occur during startup.  This seemed like a good idea initially,
 	but it has proven a disaster in retrospect.  I don't want to
 	change much code for now, so my fix is to set the internal 'debug'
 	flag to true everywhere, whose only job was precisely to control
 	this subsystem.  This closes issue 28 (as well as avoiding all
 	sorts of strange hangups which occur from time to time).
 
 2005-02-07  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_edit): Fix 'ed -p' not working when the
 	previous call produced a syntax error.
 
 	* IPython/OInspect.py (Inspector.pinfo): Fix crash when inspecting
 	classes without constructor.
 
 2005-02-06  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (MagicCompleter.complete): Extend the list of
 	completions with the results of each matcher, so we return results
 	to the user from all namespaces.  This breaks with ipython
 	tradition, but I think it's a nicer behavior.  Now you get all
 	possible completions listed, from all possible namespaces (python,
 	filesystem, magics...)  After a request by John Hunter
 	<jdhunter-AT-nitace.bsd.uchicago.edu>.
 
 2005-02-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_prun): Fix bug where prun would fail if
 	the call had quote characters in it (the quotes were stripped).
 
 2005-01-31  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): reduce reliance on
 	Itpl.itpl() to make the code more robust against psyco
 	optimizations.
 
 	* IPython/Itpl.py (Itpl.__str__): Use a _getframe() call instead
 	of causing an exception.  Quicker, cleaner.
 
 2005-01-28  Fernando Perez  <[e-mail]>
 
 	* scripts/ipython_win_post_install.py (install): hardcode
 	sys.prefix+'python.exe' as the executable path.  It turns out that
 	during the post-installation run, sys.executable resolves to the
 	name of the binary installer!  I should report this as a distutils
 	bug, I think.  I updated the .10 release with this tiny fix, to
 	avoid annoying the lists further.
 
 2005-01-27  *** Released version 0.6.10
 
 2005-01-27  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (norm): Added 'inf' as optional name for
 	L-infinity norm, included references to mathworld.com for vector
 	norm definitions.
 	(amin/amax): added amin/amax for array min/max.  Similar to what
 	pylab ships with after the recent reorganization of names.
 	(spike/spike_odd): removed deprecated spike/spike_odd functions.
 
 	* ipython.el: committed Alex's recent fixes and improvements.
 	Tested with python-mode from CVS, and it looks excellent.  Since
 	python-mode hasn't released anything in a while, I'm temporarily
 	putting a copy of today's CVS (v 4.70) of python-mode in:
 	  http://ipython.scipy.org/tmp/python-mode.el
 
 	* scripts/ipython_win_post_install.py (install): Win32 fix to use
 	sys.executable for the executable name, instead of assuming it's
 	called 'python.exe' (the post-installer would have produced broken
 	setups on systems with a differently named python binary).
 
 	* IPython/PyColorize.py (Parser.__call__): change explicit '\n'
 	references to os.linesep, to make the code more
 	platform-independent.  This is also part of the win32 coloring
 	fixes.
 
 	* IPython/genutils.py (page_dumb): Remove attempts to chop long
 	lines, which actually cause coloring bugs because the length of
 	the line is very difficult to correctly compute with embedded
 	escapes.  This was the source of all the coloring problems under
 	Win32.  I think that _finally_, Win32 users have a properly
 	working ipython in all respects.  This would never have happened
 	if not for Gary Bishop and Viktor Ransmayr's great help and work.
 
 2005-01-26  *** Released version 0.6.9
 
 2005-01-25  Fernando Perez  <[e-mail]>
 
 	* setup.py: finally, we have a true Windows installer, thanks to
 	the excellent work of Viktor Ransmayr
 	<viktor.ransmayr-AT-t-online.de>.  The docs have been updated for
 	Windows users.  The setup routine is quite a bit cleaner thanks to
 	this, and the post-install script uses the proper functions to
 	allow a clean de-installation using the standard Windows Control
 	Panel.
 	
 	* IPython/genutils.py (get_home_dir): changed to use the $HOME
 	environment variable under all OSes (including win32) if
 	available.  This will give consistency to win32 users who have set
 	this variable for any reason.  If os.environ['HOME'] fails, the
 	previous policy of using HOMEDRIVE\HOMEPATH kicks in.
 
 2005-01-24  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (empty_like): add empty_like(), similar to
 	zeros_like() but taking advantage of the new empty() Numeric routine.
 
 2005-01-23  *** Released version 0.6.8
 
 2005-01-22  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.mplot_exec): I removed the
 	automatic show() calls.  After discussing things with JDH, it
 	turns out there are too many corner cases where this can go wrong.
 	It's best not to try to be 'too smart', and simply have ipython
 	reproduce as much as possible the default behavior of a normal
 	python shell.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Modified the
 	line-splitting regexp and _prefilter() to avoid calling getattr()
 	on assignments.  This closes
 	http://www.scipy.net/roundup/ipython/issue24.  Note that Python's
 	readline uses getattr(), so a simple <TAB> keypress is still
 	enough to trigger getattr() calls on an object.
 
 2005-01-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.magic_run): Fix the %run
 	docstring under pylab so it doesn't mask the original.
 
 2005-01-21  *** Released version 0.6.7
 
 2005-01-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MTInteractiveShell.runcode): Trap a crash with
 	signal handling for win32 users in multithreaded mode.
 
 2005-01-17  Fernando Perez  <[e-mail]>
 
 	* IPython/OInspect.py (Inspector.pinfo): Fix crash when inspecting
 	instances with no __init__.  After a crash report by Norbert Nemec
 	<Norbert-AT-nemec-online.de>.
 
 2005-01-14  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.text): Fix bug in reporting of
 	names for verbose exceptions, when multiple dotted names and the
 	'parent' object were present on the same line.
 
 2005-01-11  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (flag_calls): new utility to trap and flag
 	calls in functions.  I need it to clean up matplotlib support.
 	Also removed some deprecated code in genutils.
 
 	* IPython/Shell.py (MatplotlibShellBase.mplot_exec): small fix so
 	that matplotlib scripts called with %run, which don't call show()
 	themselves, still have their plotting windows open.
 
 2005-01-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.__init__): Patch by Andrew Straw
 	<astraw-AT-caltech.edu>, to fix gtk deprecation warnings.
 
 2004-12-19  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MTInteractiveShell.runcode): Get rid of
 	parent_runcode, which was an eyesore.  The same result can be
 	obtained with Python's regular superclass mechanisms.
 
 2004-12-17  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_sc): Fix quote stripping problem
 	reported by Prabhu.
 	(Magic.magic_sx): direct all errors to Term.cerr (defaults to
 	sys.stderr) instead of explicitly calling sys.stderr.  This helps
 	maintain our I/O abstractions clean, for future GUI embeddings.
 
 	* IPython/genutils.py (info): added new utility for sys.stderr
 	unified info message handling (thin wrapper around warn()).
 
 	* IPython/ultraTB.py (VerboseTB.text): Fix misreported global
 	composite (dotted) names on verbose exceptions.
 	(VerboseTB.nullrepr): harden against another kind of errors which
 	Python's inspect module can trigger, and which were crashing
 	IPython.  Thanks to a report by Marco Lombardi
 	<mlombard-AT-ma010192.hq.eso.org>.
 
 2004-12-13  *** Released version 0.6.6
 
 2004-12-12  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.mainloop): catch RuntimeErrors
 	generated by pygtk upon initialization if it was built without
 	threads (for matplotlib users).  After a crash reported by
 	Leguijt, Jaap J SIEP-EPT-RES <Jaap.Leguijt-AT-shell.com>.
 
 	* IPython/ipmaker.py (make_IPython): fix small bug in the
 	import_some parameter for multiple imports.
 
 	* IPython/iplib.py (ipmagic): simplified the interface of
 	ipmagic() to take a single string argument, just as it would be
 	typed at the IPython cmd line.
 	(ipalias): Added new ipalias() with an interface identical to
 	ipmagic().  This completes exposing a pure python interface to the
 	alias and magic system, which can be used in loops or more complex
 	code where IPython's automatic line mangling is not active.
 
 	* IPython/genutils.py (timing): changed interface of timing to
 	simply run code once, which is the most common case.  timings()
 	remains unchanged, for the cases where you want multiple runs.
 
 	* IPython/Shell.py (MatplotlibShellBase._matplotlib_config): Fix a
 	bug where Python2.2 crashes with exec'ing code which does not end
 	in a single newline.  Python 2.3 is OK, so I hadn't noticed this
 	before.
 
 2004-12-10  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_prun): changed name of option from
 	-t to -T, to accomodate the new -t flag in %run (the %run and
 	%prun options are kind of intermixed, and it's not easy to change
 	this with the limitations of python's getopt).
 
 	* IPython/Magic.py (Magic.magic_run): Added new -t option to time
 	the execution of scripts.  It's not as fine-tuned as timeit.py,
 	but it works from inside ipython (and under 2.2, which lacks
 	timeit.py).  Optionally a number of runs > 1 can be given for
 	timing very short-running code.
 
 	* IPython/genutils.py (uniq_stable): new routine which returns a
 	list of unique elements in any iterable, but in stable order of
 	appearance.  I needed this for the ultraTB fixes, and it's a handy
 	utility.
 
 	* IPython/ultraTB.py (VerboseTB.text): Fix proper reporting of
 	dotted names in Verbose exceptions.  This had been broken since
 	the very start, now x.y will properly be printed in a Verbose
 	traceback, instead of x being shown and y appearing always as an
 	'undefined global'.  Getting this to work was a bit tricky,
 	because by default python tokenizers are stateless.  Saved by
 	python's ability to easily add a bit of state to an arbitrary
 	function (without needing to build a full-blown callable object).
 
 	Also big cleanup of this code, which had horrendous runtime
 	lookups of zillions of attributes for colorization.  Moved all
 	this code into a few templates, which make it cleaner and quicker.
 
 	Printout quality was also improved for Verbose exceptions: one
 	variable per line, and memory addresses are printed (this can be
 	quite handy in nasty debugging situations, which is what Verbose
 	is for).
 
 	* IPython/ipmaker.py (make_IPython): Do NOT execute files named in
 	the command line as scripts to be loaded by embedded instances.
 	Doing so has the potential for an infinite recursion if there are
 	exceptions thrown in the process.  This fixes a strange crash
 	reported by Philippe MULLER <muller-AT-irit.fr>.
 
 2004-12-09  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.use): Change pylab support
 	to reflect new names in matplotlib, which now expose the
 	matlab-compatible interface via a pylab module instead of the
 	'matlab' name.  The new code is backwards compatible, so users of
 	all matplotlib versions are OK.  Patch by J. Hunter.
 
 	* IPython/OInspect.py (Inspector.pinfo): Add to object? printing
 	of __init__ docstrings for instances (class docstrings are already
 	automatically printed).  Instances with customized docstrings
 	(indep. of the class) are also recognized and all 3 separate
 	docstrings are printed (instance, class, constructor).  After some
 	comments/suggestions by J. Hunter.
 
 2004-12-05  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (MagicCompleter.complete): Remove annoying
 	warnings when tab-completion fails and triggers an exception.
 
 2004-12-03  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (magic_prun): Fix bug where an exception would
 	be triggered when using 'run -p'.  An incorrect option flag was
 	being set ('d' instead of 'D').
 	(manpage): fix missing escaped \- sign.
 
 2004-11-30  *** Released version 0.6.5
 
 2004-11-30  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_run): Fix bug in breakpoint
 	setting with -d option.
 
 	* setup.py (docfiles): Fix problem where the doc glob I was using
 	was COMPLETELY BROKEN.  It was giving the right files by pure
 	accident, but failed once I tried to include ipython.el.  Note:
 	glob() does NOT allow you to do exclusion on multiple endings!
 
 2004-11-29  Fernando Perez  <[e-mail]>
 
 	* IPython/usage.py (__doc__): cleaned up usage docstring, by using
 	the manpage as the source.  Better formatting & consistency.
 
 	* IPython/Magic.py (magic_run): Added new -d option, to run
 	scripts under the control of the python pdb debugger.  Note that
 	this required changing the %prun option -d to -D, to avoid a clash
 	(since %run must pass options to %prun, and getopt is too dumb to
 	handle options with string values with embedded spaces).  Thanks
 	to a suggestion by Matthew Arnison <maffew-AT-cat.org.au>.
 	(magic_who_ls): added type matching to %who and %whos, so that one
 	can filter their output to only include variables of certain
 	types.  Another suggestion by Matthew.
 	(magic_whos): Added memory summaries in kb and Mb for arrays.
 	(magic_who): Improve formatting (break lines every 9 vars).
 
 2004-11-28  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.log): Fix bug in syncing the input
 	cache when empty lines were present.
 
 2004-11-24  Fernando Perez  <[e-mail]>
 
 	* IPython/usage.py (__doc__): document the re-activated threading
 	options for WX and GTK.
 
 2004-11-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (start): Added Prabhu's big patch to reactivate
 	the -wthread and -gthread options, along with a new -tk one to try
 	and coordinate Tk threading with wx/gtk.  The tk support is very
 	platform dependent, since it seems to require Tcl and Tk to be
 	built with threads (Fedora1/2 appears NOT to have it, but in
 	Prabhu's Debian boxes it works OK).  But even with some Tk
 	limitations, this is a great improvement.
 
 	* IPython/Prompts.py (prompt_specials_color): Added \t for time
 	info in user prompts.  Patch by Prabhu.
 
 2004-11-18  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (ask_yes_no): Add check for a max of 20
 	EOFErrors and bail, to avoid infinite loops if a non-terminating
 	file is fed into ipython.  Patch submitted in issue 19 by user,
 	many thanks.
 
 	* IPython/iplib.py (InteractiveShell.handle_auto): do NOT trigger
 	autoquote/parens in continuation prompts, which can cause lots of
 	problems.  Closes roundup issue 20.
 
 2004-11-17  Fernando Perez  <[e-mail]>
 
 	* debian/control (Build-Depends-Indep): Fix dpatch dependency,
 	reported as debian bug #280505.  I'm not sure my local changelog
 	entry has the proper debian format (Jack?).
 
 2004-11-08  *** Released version 0.6.4
 
 2004-11-08  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (init_readline): Fix exit message for Windows
 	when readline is active.  Thanks to a report by Eric Jones
 	<eric-AT-enthought.com>.
 
 2004-11-07  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page): Add a trap for OSError exceptions,
 	sometimes seen by win2k/cygwin users.
 
 2004-11-06  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (interact): Change the handling of %Exit from
 	trying to propagate a SystemExit to an internal ipython flag.
 	This is less elegant than using Python's exception mechanism, but
 	I can't get that to work reliably with threads, so under -pylab
 	%Exit was hanging IPython.  Cross-thread exception handling is
 	really a bitch.  Thaks to a bug report by Stephen Walton
 	<stephen.walton-AT-csun.edu>.
 
 2004-11-04  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (raw_input_original): store a pointer to the
 	true raw_input to harden against code which can modify it
 	(wx.py.PyShell does this and would otherwise crash ipython).
 	Thanks to a bug report by Jim Flowers <james.flowers-AT-lgx.com>.
 
 	* IPython/Shell.py (MTInteractiveShell.runsource): Cleaner fix for
 	Ctrl-C problem, which does not mess up the input line.
 
 2004-11-03  Fernando Perez  <[e-mail]>
 
 	* IPython/Release.py: Changed licensing to BSD, in all files.
 	(name): lowercase name for tarball/RPM release.
 
 	* IPython/OInspect.py (getdoc): wrap inspect.getdoc() safely for
 	use throughout ipython.
 
 	* IPython/Magic.py (Magic._ofind): Switch to using the new
 	OInspect.getdoc() function.
 
 	* IPython/Shell.py (sigint_handler): Hack to ignore the execution
 	of the line currently being canceled via Ctrl-C.  It's extremely
 	ugly, but I don't know how to do it better (the problem is one of
 	handling cross-thread exceptions).
 
 2004-10-28  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (signal_handler): add signal handlers to trap
 	SIGINT and SIGSEGV in threaded code properly.  Thanks to a bug
 	report by Francesc Alted.
 
 2004-10-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Extensions/InterpreterExec.py (prefilter_shell): Fix @
 	to % for pysh syntax extensions.
 
 2004-10-09  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_whos): modify output of Numeric
 	arrays to print a more useful summary, without calling str(arr).
 	This avoids the problem of extremely lengthy computations which
 	occur if arr is large, and appear to the user as a system lockup
 	with 100% cpu activity.  After a suggestion by Kristian Sandberg
 	<[e-mail]>.
 	(Magic.__init__): fix bug in global magic escapes not being
 	correctly set.
 
 2004-10-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (__license__): change to absolute imports of
 	ipython's own internal packages, to start adapting to the absolute
 	import requirement of PEP-328.
 
 	* IPython/genutils.py (__author__): Fix coding to utf-8 on all
 	files, and standardize author/license marks through the Release
 	module instead of having per/file stuff (except for files with
 	particular licenses, like the MIT/PSF-licensed codes).
 
 	* IPython/Debugger.py: remove dead code for python 2.1
 
 2004-10-04  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (ipmagic): New function for accessing magics
 	via a normal python function call.
 
 	* IPython/Magic.py (Magic.magic_magic): Change the magic escape
 	from '@' to '%', to accomodate the new @decorator syntax of python
 	2.4.
 
 2004-09-29  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.use): Added a wrapper to
 	matplotlib.use to prevent running scripts which try to switch
 	interactive backends from within ipython.  This will just crash
 	the python interpreter, so we can't allow it (but a detailed error
 	is given to the user).
 	
 2004-09-28  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (MatplotlibShellBase.mplot_exec):
 	matplotlib-related fixes so that using @run with non-matplotlib
 	scripts doesn't pop up spurious plot windows.  This requires
 	matplotlib >= 0.63, where I had to make some changes as well.
 
 	* IPython/ipmaker.py (make_IPython): update version requirement to
 	python 2.2.
 
 	* IPython/iplib.py (InteractiveShell.mainloop): Add an optional
 	banner arg for embedded customization.
 
 	* IPython/Magic.py (Magic.__init__): big cleanup to remove all
 	explicit uses of __IP as the IPython's instance name.  Now things
 	are properly handled via the shell.name value.  The actual code
 	is a bit ugly b/c I'm doing it via a global in Magic.py, but this
 	is much better than before.  I'll clean things completely when the
 	magic stuff gets a real overhaul.
 
 	* ipython.1: small fixes, sent in by Jack Moffit.  He also sent in
 	minor changes to debian dir.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Fix adding a
 	pointer to the shell itself in the interactive namespace even when
 	a user-supplied dict is provided.  This is needed for embedding
 	purposes (found by tests with Michel Sanner).
 
 2004-09-27  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/ipythonrc: remove []{} from
 	readline_remove_delims, so that things like [modname.<TAB> do
 	proper completion.  This disables [].TAB, but that's a less common
 	case than module names in list comprehensions, for example.
 	Thanks to a report by Andrea Riciputi.
 
 2004-09-09  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellGTK.mainloop): reorder to avoid
 	blocking problems in win32 and osx.  Fix by John.
 
 2004-09-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellWX.OnInit): Fix output redirection bug
 	for Win32 and OSX.  Fix by John Hunter.
 
 2004-08-30  *** Released version 0.6.3
 
 2004-08-30  Fernando Perez  <[e-mail]>
 
 	* setup.py (isfile): Add manpages to list of dependent files to be
 	updated.
 
 2004-08-27  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (start): I've disabled -wthread and -gthread
 	for now.  They don't really work with standalone WX/GTK code
 	(though matplotlib IS working fine with both of those backends).
 	This will neeed much more testing.  I disabled most things with
 	comments, so turning it back on later should be pretty easy.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Fix accidental
 	autocalling of expressions like r'foo', by modifying the line
 	split regexp.  Closes
 	http://www.scipy.net/roundup/ipython/issue18, reported by Nicholas
 	Riley <ipythonbugs-AT-sabi.net>.
 	(InteractiveShell.mainloop): honor --nobanner with banner
 	extensions.
 
 	* IPython/Shell.py: Significant refactoring of all classes, so
 	that we can really support ALL matplotlib backends and threading
 	models (John spotted a bug with Tk which required this).  Now we
 	should support single-threaded, WX-threads and GTK-threads, both
 	for generic code and for matplotlib.
 
 	* IPython/ipmaker.py (__call__): Changed -mpthread option to
 	-pylab, to simplify things for users.  Will also remove the pylab
 	profile, since now all of matplotlib configuration is directly
 	handled here.  This also reduces startup time.
 
 	* IPython/Shell.py (IPShellGTK.run): Fixed bug where mainloop() of
 	shell wasn't being correctly called.  Also in IPShellWX.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Added option to
 	fine-tune banner.
 
 	* IPython/numutils.py (spike): Deprecate these spike functions,
 	delete (long deprecated) gnuplot_exec handler.
 
 2004-08-26  Fernando Perez  <[e-mail]>
 
 	* ipython.1: Update for threading options, plus some others which
 	were missing.
 
 	* IPython/ipmaker.py (__call__): Added -wthread option for
 	wxpython thread handling.  Make sure threading options are only
 	valid at the command line.
 
 	* scripts/ipython: moved shell selection into a factory function
 	in Shell.py, to keep the starter script to a minimum.
 
 2004-08-25  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellWX.wxexit): fixes to WX threading, by
 	John.  Along with some recent changes he made to matplotlib, the
 	next versions of both systems should work very well together.
 
 2004-08-24  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_prun): cleanup some dead code.  I
 	tried to switch the profiling to using hotshot, but I'm getting
 	strange errors from prof.runctx() there.  I may be misreading the
 	docs, but it looks weird.  For now the profiling code will
 	continue to use the standard profiler.
 
 2004-08-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellWX.__init__): Improvements to the WX
 	threaded shell, by John Hunter.  It's not quite ready yet, but
 	close.
 
 2004-08-22  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): tab cleanups, also
 	in Magic and ultraTB.
 
 	* ipython.1: document threading options in manpage.
 
 	* scripts/ipython: Changed name of -thread option to -gthread,
 	since this is GTK specific.  I want to leave the door open for a
 	-wthread option for WX, which will most likely be necessary.  This
 	change affects usage and ipmaker as well.
 
 	* IPython/Shell.py (matplotlib_shell): Add a factory function to
 	handle the matplotlib shell issues.  Code by John Hunter
 	<jdhunter-AT-nitace.bsd.uchicago.edu>.
 	(IPShellMatplotlibWX.__init__): Rudimentary WX support.  It's
 	broken (and disabled for end users) for now, but it puts the
 	infrastructure in place.
 
 2004-08-21  Fernando Perez  <[e-mail]>
 
 	* ipythonrc-pylab: Add matplotlib support.
 
 	* matplotlib_config.py: new files for matplotlib support, part of
 	the pylab profile.
 
 	* IPython/usage.py (__doc__): documented the threading options.
 
 2004-08-20  Fernando Perez  <[e-mail]>
 
 	* ipython: Modified the main calling routine to handle the -thread
 	and -mpthread options.  This needs to be done as a top-level hack,
 	because it determines which class to instantiate for IPython
 	itself.
 
 	* IPython/Shell.py (MTInteractiveShell.__init__): New set of
 	classes to support multithreaded GTK operation without blocking,
 	and matplotlib with all backends.  This is a lot of still very
 	experimental code, and threads are tricky.  So it may still have a
 	few rough edges...  This code owes a lot to
 	http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by
 	Brian # McErlean and John Finlay, to Antoon Pardon for fixes, and
 	to John Hunter for all the matplotlib work.
 
 	* IPython/ipmaker.py (__call__): Added -thread and -mpthread
 	options for gtk thread and matplotlib support.
 
 2004-08-16  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): don't trigger
 	autocall for things like p*q,p/q,p+q,p-q, when p is callable.  Bug
 	reported by Stephen Walton <stephen.walton-AT-csun.edu>.
 
 2004-08-11  Fernando Perez  <[e-mail]>
 
 	* setup.py (isfile): Fix build so documentation gets updated for
 	rpms (it was only done for .tgz builds).
 
 2004-08-10  Fernando Perez  <[e-mail]>
 
 	* genutils.py (Term): Fix misspell of stdin stream (sin->cin).
 
 	* iplib.py : Silence syntax error exceptions in tab-completion.
 	
 2004-08-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (Prompt2.set_colors): Fix incorrectly set
 	'color off' mark for continuation prompts.  This was causing long
 	continuation lines to mis-wrap.
 
 2004-08-01  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): Allow the shell class used
 	for building ipython to be a parameter.  All this is necessary
 	right now to have a multithreaded version, but this insane
 	non-design will be cleaned up soon.  For now, it's a hack that
 	works.
 
 	* IPython/Shell.py (IPShell.__init__): Stop using mutable default
 	args in various places.  No bugs so far, but it's a dangerous
 	practice.
 
 2004-07-31  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (complete): ignore SyntaxError exceptions to
 	fix completion of files with dots in their names under most
 	profiles (pysh was OK because the completion order is different).
 
 2004-07-27  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): build dict of
 	keywords manually, b/c the one in keyword.py was removed in python
 	2.4.  Patch by Anakim Border <aborder-AT-users.sourceforge.net>.
 	This is NOT a bug under python 2.3 and earlier.
 
 2004-07-26  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.text): Add another
 	linecache.checkcache() call to try to prevent inspect.py from
 	crashing under python 2.3.  I think this fixes
 	http://www.scipy.net/roundup/ipython/issue17.
 
 2004-07-26  *** Released version 0.6.2
 
 2004-07-26  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_cd): Fix bug where 'cd -N' would
 	fail for any number.
 	(Magic.magic_bookmark): Fix bug where 'bookmark -l' would fail for
 	empty bookmarks.
 
 2004-07-26  *** Released version 0.6.1
 
 2004-07-26  Fernando Perez  <[e-mail]>
 
 	* ipython_win_post_install.py (run): Added pysh shortcut for Windows.
 
 	* IPython/iplib.py (protect_filename): Applied Ville's patch for
 	escaping '()[]{}' in filenames.
 
 	* IPython/Magic.py (shlex_split): Fix handling of '*' and '?' for
 	Python 2.2 users who lack a proper shlex.split.
 
 2004-07-19  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.init_readline): Add support
 	for reading readline's init file.  I follow the normal chain:
 	$INPUTRC is honored, otherwise ~/.inputrc is used.  Thanks to a
 	report by Mike Heeter.  This closes
 	http://www.scipy.net/roundup/ipython/issue16.
 
 2004-07-18  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (__init__): Add better handling of '\' under
 	Win32 for filenames.  After a patch by Ville.
 
 2004-07-17  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): fix bug where
 	autocalling would be triggered for 'foo is bar' if foo is
 	callable.  I also cleaned up the autocall detection code to use a
 	regexp, which is faster.  Bug reported by Alexander Schmolck.
 
 	* IPython/Magic.py (Magic.magic_pinfo): Fix bug where strings with
 	'?' in them would confuse the help system.  Reported by Alex
 	Schmolck.
 
 2004-07-16  Fernando Perez  <[e-mail]>
 
 	* IPython/GnuplotInteractive.py (__all__): added plot2.
 
 	* IPython/Gnuplot2.py (Gnuplot.plot2): added new function for
 	plotting dictionaries, lists or tuples of 1d arrays.
 
 	* IPython/Magic.py (Magic.magic_hist): small clenaups and
 	optimizations.
 
 	* IPython/iplib.py:Remove old Changelog info for cleanup.  This is
 	the information which was there from Janko's original IPP code:
 
 	03.05.99 20:53 porto.ifm.uni-kiel.de
 	--Started changelog.
 	--make clear do what it say it does
 	--added pretty output of lines from inputcache
 	--Made Logger a mixin class, simplifies handling of switches
 	--Added own completer class. .string<TAB> expands to last history
 	line which starts with string.  The new expansion is also present
 	with Ctrl-r from the readline library.  But this shows, who this
 	can be done for other cases.
 	--Added convention that all shell functions should accept a
 	parameter_string This opens the door for different behaviour for
 	each function. @cd is a good example of this.
 
 	04.05.99 12:12 porto.ifm.uni-kiel.de
 	--added logfile rotation
 	--added new mainloop method which freezes first the namespace
 
 	07.05.99 21:24 porto.ifm.uni-kiel.de
 	--added the docreader classes. Now there is a help system.
 	-This is only a first try. Currently it's not easy to put new
 	stuff in the indices. But this is the way to go. Info would be
 	better, but HTML is every where and not everybody has an info
 	system installed and it's not so easy to change html-docs to info.
 	--added global logfile option
 	--there is now a hook for object inspection method pinfo needs to
 	be provided for this. Can be reached by two '??'.
 
 	08.05.99 20:51 porto.ifm.uni-kiel.de
 	--added a README
 	--bug in rc file. Something has changed so functions in the rc
 	file need to reference the shell and not self. Not clear if it's a
 	bug or feature.
 	--changed rc file for new behavior
 
 2004-07-15  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.log): fixed recent bug where the input
 	cache was falling out of sync in bizarre manners when multi-line
 	input was present.  Minor optimizations and cleanup.
 
 	(Logger): Remove old Changelog info for cleanup.  This is the
 	information which was there from Janko's original code:
 
 	Changes to Logger: - made the default log filename a parameter
 
 	- put a check for lines beginning with !@? in log(). Needed
 	(even if the handlers properly log their lines) for mid-session
 	logging activation to work properly. Without this, lines logged
 	in mid session, which get read from the cache, would end up
 	'bare' (with !@? in the open) in the log. Now they are caught
 	and prepended with a #.
 
 	* IPython/iplib.py (InteractiveShell.init_readline): added check
 	in case MagicCompleter fails to be defined, so we don't crash.
 
 2004-07-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Gnuplot2.py (Gnuplot.hardcopy): add automatic generation
 	of EPS if the requested filename ends in '.eps'.
 
 2004-07-04  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.handle_shell_escape): Fix
 	escaping of quotes when calling the shell.
 
 2004-07-02  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (CachedOutput.update): Fix problem with
 	gettext not working because we were clobbering '_'.  Fixes
 	http://www.scipy.net/roundup/ipython/issue6.
 
 2004-07-01  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_cd): integrated bookmark handling
 	into @cd.  Patch by Ville.
 
 	* IPython/iplib.py (InteractiveShell.post_config_initialization):
 	new function to store things after ipmaker runs.  Patch by Ville.
 	Eventually this will go away once ipmaker is removed and the class
 	gets cleaned up, but for now it's ok.  Key functionality here is
 	the addition of the persistent storage mechanism, a dict for
 	keeping data across sessions (for now just bookmarks, but more can
 	be implemented later).
 
 	* IPython/Magic.py (Magic.magic_bookmark): New bookmark system,
 	persistent across sections.  Patch by Ville, I modified it
 	soemwhat to allow bookmarking arbitrary dirs other than CWD.  Also
 	added a '-l' option to list all bookmarks.
 
 	* IPython/iplib.py (InteractiveShell.atexit_operations): new
 	center for cleanup.  Registered with atexit.register().  I moved
 	here the old exit_cleanup().  After a patch by Ville.
 
 	* IPython/Magic.py (get_py_filename): added '~' to the accepted
 	characters in the hacked shlex_split for python 2.2.
 
 	* IPython/iplib.py (file_matches): more fixes to filenames with
 	whitespace in them.  It's not perfect, but limitations in python's
 	readline make it impossible to go further.
 
 2004-06-29  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (file_matches): escape whitespace correctly in
 	filename completions.  Bug reported by Ville.
 
 2004-06-28  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (__call__): Added per-profile histories.  Now
 	the history file will be called 'history-PROFNAME' (or just
 	'history' if no profile is loaded).  I was getting annoyed at
 	getting my Numerical work history clobbered by pysh sessions.
 
 	* IPython/iplib.py (InteractiveShell.__init__): Internal
 	getoutputerror() function so that we can honor the system_verbose
 	flag for _all_ system calls.  I also added escaping of #
 	characters here to avoid confusing Itpl.
 
 	* IPython/Magic.py (shlex_split): removed call to shell in
 	parse_options and replaced it with shlex.split().  The annoying
 	part was that in Python 2.2, shlex.split() doesn't exist, so I had
 	to backport it from 2.3, with several frail hacks (the shlex
 	module is rather limited in 2.2).  Thanks to a suggestion by Ville
 	Vainio <[e-mail]>.  For Python 2.3 there should be no
 	problem.
 	
 	(Magic.magic_system_verbose): new toggle to print the actual
 	system calls made by ipython.  Mainly for debugging purposes.
 
 	* IPython/GnuplotRuntime.py (gnu_out): fix bug for cygwin, which
 	doesn't support persistence.  Reported (and fix suggested) by
 	Travis Caldwell <[e-mail]>.
 
 2004-06-26  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.log): fix to handle correctly empty
 	continue prompts.
 
 	* IPython/Extensions/InterpreterExec.py (pysh): moved the pysh()
 	function (basically a big docstring) and a few more things here to
 	speedup startup. pysh.py is now very lightweight.  We want because
 	it gets execfile'd, while InterpreterExec gets imported, so
 	byte-compilation saves time.
 
 2004-06-25  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_cd): Fixed to restore usage of 'cd
 	-NUM', which was recently broken.
 
 	* IPython/iplib.py (InteractiveShell.handle_shell_escape): allow !
 	in multi-line input (but not !!, which doesn't make sense there).
 
 	* IPython/UserConfig/ipythonrc: made autoindent on by default.
 	It's just too useful, and people can turn it off in the less
 	common cases where it's a problem.
 
 2004-06-24  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): big change -
 	special syntaxes (like alias calling) is now allied in multi-line
 	input.  This is still _very_ experimental, but it's necessary for
 	efficient shell usage combining python looping syntax with system
 	calls.  For now it's restricted to aliases, I don't think it
 	really even makes sense to have this for magics.
 
 2004-06-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Extensions/InterpreterExec.py (prefilter_shell): Added
 	$var=cmd <=> @sc var=cmd and  $$var=cmd <=> @sc -l var=cmd.
 
 	* IPython/Magic.py (Magic.magic_rehashx): modified to handle
 	extensions under Windows (after code sent by Gary Bishop).  The
 	extensions considered 'executable' are stored in IPython's rc
 	structure as win_exec_ext.
 
 	* IPython/genutils.py (shell): new function, like system() but
 	without return value.  Very useful for interactive shell work.
 
 	* IPython/Magic.py (Magic.magic_unalias): New @unalias function to
 	delete aliases.
 
 	* IPython/iplib.py (InteractiveShell.alias_table_update): make
 	sure that the alias table doesn't contain python keywords.
 
 2004-06-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_rehash): Fix crash when
 	non-existent items are found in $PATH.  Reported by Thorsten.
 
 2004-06-20  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (complete): modified the completer so that the
 	order of priorities can be easily changed at runtime.
 
 	* IPython/Extensions/InterpreterExec.py (prefilter_shell):
 	Modified to auto-execute all lines beginning with '~', '/' or '.'.
 
 	* IPython/Magic.py (Magic.magic_sx): modified @sc and @sx to
 	expand Python variables prepended with $ in all system calls.  The
 	same was done to InteractiveShell.handle_shell_escape.  Now all
 	system access mechanisms (!, !!, @sc, @sx and aliases) allow the
 	expansion of python variables and expressions according to the
 	syntax of PEP-215 - http://www.python.org/peps/pep-0215.html.
 
 	Though PEP-215 has been rejected, a similar (but simpler) one
 	seems like it will go into Python 2.4, PEP-292 -
 	http://www.python.org/peps/pep-0292.html.
 
 	I'll keep the full syntax of PEP-215, since IPython has since the
 	start used Ka-Ping Yee's reference implementation discussed there
 	(Itpl), and I actually like the powerful semantics it offers.
 
 	In order to access normal shell variables, the $ has to be escaped
 	via an extra $.  For example:
 
 	In [7]: PATH='a python variable'
 
 	In [8]: !echo $PATH
 	a python variable
 
 	In [9]: !echo $$PATH
 	/usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
 
 	(Magic.parse_options): escape $ so the shell doesn't evaluate
 	things prematurely.
 
 	* IPython/iplib.py (InteractiveShell.call_alias): added the
 	ability for aliases to expand python variables via $.
 
 	* IPython/Magic.py (Magic.magic_rehash): based on the new alias
 	system, now there's a @rehash/@rehashx pair of magics.  These work
 	like the csh rehash command, and can be invoked at any time.  They
 	build a table of aliases to everything in the user's $PATH
 	(@rehash uses everything, @rehashx is slower but only adds
 	executable files).  With this, the pysh.py-based shell profile can
 	now simply call rehash upon startup, and full access to all
 	programs in the user's path is obtained.
 
 	* IPython/iplib.py (InteractiveShell.call_alias): The new alias
 	functionality is now fully in place.  I removed the old dynamic
 	code generation based approach, in favor of a much lighter one
 	based on a simple dict.  The advantage is that this allows me to
 	now have thousands of aliases with negligible cost (unthinkable
 	with the old system).
 
 2004-06-19  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (__init__): extended MagicCompleter class to
 	also complete (last in priority) on user aliases.
 
 	* IPython/Itpl.py (Itpl.__str__): fixed order of globals/locals in
 	call to eval.
 	(ItplNS.__init__): Added a new class which functions like Itpl,
 	but allows configuring the namespace for the evaluation to occur
 	in.
 
 2004-06-18  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.runcode): modify to print a
 	better message when 'exit' or 'quit' are typed (a common newbie
 	confusion).
 
 	* IPython/Magic.py (Magic.magic_colors): Added the runtime color
 	check for Windows users.
 
 	* IPython/iplib.py (InteractiveShell.user_setup): removed
 	disabling of colors for Windows.  I'll test at runtime and issue a
 	warning if Gary's readline isn't found, as to nudge users to
 	download it.
 
 2004-06-16  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (Stream.__init__): changed to print errors
 	to sys.stderr.  I had a circular dependency here.  Now it's
 	possible to run ipython as IDLE's shell (consider this pre-alpha,
 	since true stdout things end up in the starting terminal instead
 	of IDLE's out).
 
 	* IPython/Prompts.py (Prompt2.set_colors): prevent crashes for
 	users who haven't # updated their prompt_in2 definitions.  Remove
 	eventually.
 	(multiple_replace): added credit to original ASPN recipe.
 
 2004-06-15  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): add 'cp' to the
 	list of auto-defined aliases.
 
 2004-06-13  Fernando Perez  <[e-mail]>
 
 	* setup.py (scriptfiles): Don't trigger win_post_install unless an
 	install was really requested (so setup.py can be used for other
 	things under Windows).
 
 2004-06-10  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.create_log): Manually remove any old
 	backup, since os.remove may fail under Windows.  Fixes bug
 	reported by Thorsten.
 
 2004-06-09  Fernando Perez  <[e-mail]>
 
 	* examples/example-embed.py: fixed all references to %n (replaced
 	with \\# for ps1/out prompts and with \\D for ps2 prompts).  Done
 	for all examples and the manual as well.
 
 2004-06-08  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (Prompt2.set_p_str): fixed all prompt
 	alignment and color management.  All 3 prompt subsystems now
 	inherit from BasePrompt.
 
 	* tools/release: updates for windows installer build and tag rpms
 	with python version (since paths are fixed).
 
 	* IPython/UserConfig/ipythonrc: modified to use \# instead of %n,
 	which will become eventually obsolete.  Also fixed the default
 	prompt_in2 to use \D, so at least new users start with the correct
 	defaults.
 	WARNING: Users with existing ipythonrc files will need to apply
 	this fix manually!
 
 	* setup.py: make windows installer (.exe).  This is finally the
 	integration of an old patch by Cory Dodt <dodt-AT-fcoe.k12.ca.us>,
 	which I hadn't included because it required Python 2.3 (or recent
 	distutils).
 
 	* IPython/usage.py (__doc__): update docs (and manpage) to reflect
 	usage of new '\D' escape.
 
 	* IPython/Prompts.py (ROOT_SYMBOL): Small fix for Windows (which
 	lacks os.getuid())
 	(CachedOutput.set_colors): Added the ability to turn coloring
 	on/off with @colors even for manually defined prompt colors.  It
 	uses a nasty global, but it works safely and via the generic color
 	handling mechanism.
 	(Prompt2.__init__): Introduced new escape '\D' for continuation
 	prompts. It represents the counter ('\#') as dots.
 	*** NOTE *** THIS IS A BACKWARDS-INCOMPATIBLE CHANGE.  Users will
 	need to update their ipythonrc files and replace '%n' with '\D' in
 	their prompt_in2 settings everywhere.  Sorry, but there's
 	otherwise no clean way to get all prompts to properly align.  The
 	ipythonrc shipped with IPython has been updated.
 
 2004-06-07  Fernando Perez  <[e-mail]>
 
 	* setup.py (isfile): Pass local_icons option to latex2html, so the
 	resulting HTML file is self-contained.  Thanks to
 	dryice-AT-liu.com.cn for the tip.
 
 	* pysh.py: I created a new profile 'shell', which implements a
 	_rudimentary_ IPython-based shell.  This is in NO WAY a realy
 	system shell, nor will it become one anytime soon.  It's mainly
 	meant to illustrate the use of the new flexible bash-like prompts.
 	I guess it could be used by hardy souls for true shell management,
 	but it's no tcsh/bash...  pysh.py is loaded by the 'shell'
 	profile.  This uses the InterpreterExec extension provided by
 	W.J. van der Laan <gnufnork-AT-hetdigitalegat.nl>
 
 	* IPython/Prompts.py (PromptOut.__str__): now it will correctly
 	auto-align itself with the length of the previous input prompt
 	(taking into account the invisible color escapes).
 	(CachedOutput.__init__): Large restructuring of this class.  Now
 	all three prompts (primary1, primary2, output) are proper objects,
 	managed by the 'parent' CachedOutput class.  The code is still a
 	bit hackish (all prompts share state via a pointer to the cache),
 	but it's overall far cleaner than before.
 
 	* IPython/genutils.py (getoutputerror): modified to add verbose,
 	debug and header options.  This makes the interface of all getout*
 	functions uniform.
 	(SystemExec.getoutputerror): added getoutputerror to SystemExec.
 
 	* IPython/Magic.py (Magic.default_option): added a function to
 	allow registering default options for any magic command.  This
 	makes it easy to have profiles which customize the magics globally
 	for a certain use.  The values set through this function are
 	picked up by the parse_options() method, which all magics should
 	use to parse their options.
 
 	* IPython/genutils.py (warn): modified the warnings framework to
 	use the Term I/O class.  I'm trying to slowly unify all of
 	IPython's I/O operations to pass through Term.
 
 	* IPython/Prompts.py (Prompt2._str_other): Added functionality in
 	the secondary prompt to correctly match the length of the primary
 	one for any prompt.  Now multi-line code will properly line up
 	even for path dependent prompts, such as the new ones available
 	via the prompt_specials.
 
 2004-06-06  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (prompt_specials): Added the ability to have
 	bash-like special sequences in the prompts, which get
 	automatically expanded.  Things like hostname, current working
 	directory and username are implemented already, but it's easy to
 	add more in the future.  Thanks to a patch by W.J. van der Laan
 	<gnufnork-AT-hetdigitalegat.nl>
 	(prompt_specials): Added color support for prompt strings, so
 	users can define arbitrary color setups for their prompts.
 
 2004-06-05  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (Term.reopen_all): Added Windows-specific
 	code to load Gary Bishop's readline and configure it
 	automatically.  Thanks to Gary for help on this.
 
 2004-06-01  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.create_log): fix bug for logging
 	with no filename (previous fix was incomplete).
 
 2004-05-25  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.parse_options): fix bug where naked
 	parens would get passed to the shell.
 
 2004-05-20  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_prun): changed default profile
 	sort order to 'time' (the more common profiling need).
 
 	* IPython/OInspect.py (Inspector.pinfo): flush the inspect cache
 	so that source code shown is guaranteed in sync with the file on
 	disk (also changed in psource).  Similar fix to the one for
 	ultraTB on 2004-05-06.  Thanks to a bug report by Yann Le Du
 	<yann.ledu-AT-noos.fr>.
 	
 	* IPython/Magic.py (Magic.parse_options): Fixed bug where commands
 	with a single option would not be correctly parsed. Closes
 	http://www.scipy.net/roundup/ipython/issue14.  This bug had been
 	introduced in 0.6.0 (on 2004-05-06).
 
 2004-05-13  *** Released version 0.6.0
 
 2004-05-13  Fernando Perez  <[e-mail]>
 
 	* debian/: Added debian/ directory to CVS, so that debian support
 	is publicly accessible.  The debian package is maintained by Jack
 	Moffit <jack-AT-xiph.org>.
 
 	* Documentation: included the notes about an ipython-based system
 	shell (the hypothetical 'pysh') into the new_design.pdf document,
 	so that these ideas get distributed to users along with the
 	official documentation.
 
 2004-05-10  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.create_log): fix recently introduced
 	bug (misindented line) where logstart would fail when not given an
 	explicit filename.
 
 2004-05-09  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.parse_options): skip system call when
 	there are no options to look for.  Faster, cleaner for the common
 	case.
 
 	* Documentation: many updates to the manual: describing Windows
 	support better, Gnuplot updates, credits, misc small stuff.  Also
 	updated the new_design doc a bit.
 
 2004-05-06  *** Released version 0.6.0.rc1
 
 2004-05-06  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (ListTB.text): modified a ton of string +=
 	operations to use the vastly more efficient list/''.join() method.
 	(FormattedTB.text): Fix
 	http://www.scipy.net/roundup/ipython/issue12 - exception source
 	extract not updated after reload.  Thanks to Mike Salib
 	<msalib-AT-mit.edu> for pinning the source of the problem.
 	Fortunately, the solution works inside ipython and doesn't require
 	any changes to python proper.
 
 	* IPython/Magic.py (Magic.parse_options): Improved to process the
 	argument list as a true shell would (by actually using the
 	underlying system shell).  This way, all @magics automatically get
 	shell expansion for variables.  Thanks to a comment by Alex
 	Schmolck.
 
 2004-04-04  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): Added a special
 	trap for a debugger quit exception, which is basically impossible
 	to handle by normal mechanisms, given what pdb does to the stack.
 	This fixes a crash reported by <fgibbons-AT-llama.med.harvard.edu>.
 
 2004-04-03  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (Term): Standardized the names of the Term
 	class streams to cin/cout/cerr, following C++ naming conventions
 	(I can't use in/out/err because 'in' is not a valid attribute
 	name).
 
 	* IPython/iplib.py (InteractiveShell.interact): don't increment
 	the prompt if there's no user input.  By Daniel 'Dang' Griffith
 	<pythondev-dang-AT-lazytwinacres.net>, after a suggestion from
 	Francois Pinard.
 
 2004-04-02  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (Stream.__init__): Modified to survive at
 	least importing in contexts where stdin/out/err aren't true file
 	objects, such as PyCrust (they lack fileno() and mode).  However,
 	the recovery facilities which rely on these things existing will
 	not work.
 
 2004-04-01  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_sx): modified (as well as @sc) to
 	use the new getoutputerror() function, so it properly
 	distinguishes stdout/err.
 
 	* IPython/genutils.py (getoutputerror): added a function to
 	capture separately the standard output and error of a command.
 	After a comment from dang on the mailing lists.  This code is
 	basically a modified version of commands.getstatusoutput(), from
 	the standard library.
 
 	* IPython/iplib.py (InteractiveShell.handle_shell_escape): added
 	'!!' as a special syntax (shorthand) to access @sx.
 
 	* IPython/Magic.py (Magic.magic_sx): new magic, to execute a shell
 	command and return its output as a list split on '\n'.
 
 2004-03-31  Fernando Perez  <[e-mail]>
 
 	* IPython/FakeModule.py (FakeModule.__init__): added __nonzero__
 	method to dictionaries used as FakeModule instances if they lack
 	it.  At least pydoc in python2.3 breaks for runtime-defined
 	functions without this hack.  At some point I need to _really_
 	understand what FakeModule is doing, because it's a gross hack.
 	But it solves Arnd's problem for now...
 
 2004-02-27  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.create_log): Fix bug where 'rotate'
 	mode would behave erratically.  Also increased the number of
 	possible logs in rotate mod to 999.  Thanks to Rod Holland
 	<[e-mail]> for the report and fixes.
 	
 2004-02-26  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page): Check that the curses module really
 	has the initscr attribute before trying to use it.  For some
 	reason, the Solaris curses module is missing this.  I think this
 	should be considered a Solaris python bug, but I'm not sure.
 
 2004-01-17  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (Stream.__init__): Changes to try to make
 	ipython robust against stdin/out/err being closed by the user.
 	This is 'user error' (and blocks a normal python session, at least
 	the stdout case).  However, Ipython should be able to survive such
 	instances of abuse as gracefully as possible.  To simplify the
 	coding and maintain compatibility with Gary Bishop's Term
 	contributions, I've made use of classmethods for this.  I think
 	this introduces a dependency on python 2.2.
 
 2004-01-13  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (exp_safe): simplified the code a bit and
 	removed the need for importing the kinds module altogether.
 
 2004-01-06  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_sc): Made the shell capture system
 	a magic function instead, after some community feedback.  No
 	special syntax will exist for it, but its name is deliberately
 	very short.
 
 2003-12-20  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.handle_shell_assign): Added
 	new functionality, to automagically assign the result of a shell
 	command to a variable.  I'll solicit some community feedback on
 	this before making it permanent.
 
 	* IPython/OInspect.py (Inspector.pinfo): Fix crash when info was
 	requested about callables for which inspect couldn't obtain a
 	proper argspec.  Thanks to a crash report sent by Etienne
 	Posthumus <etienne-AT-apple01.cs.vu.nl>.
 
 2003-12-09  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page): patch for the pager to work across
 	various versions of Windows.  By Gary Bishop.
 
 2003-12-04  Fernando Perez  <[e-mail]>
 
 	* IPython/Gnuplot2.py (PlotItems): Fixes for working with
 	Gnuplot.py version 1.7, whose internal names changed quite a bit.
 	While I tested this and it looks ok, there may still be corner
 	cases I've missed.
 
 2003-12-01  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): Fixed a bug
 	where a line like 'p,q=1,2' would fail because the automagic
 	system would be triggered for @p.
 
 	* IPython/DPyGetOpt.py (DPyGetOpt.processArguments): Tab-related
 	cleanups, code unmodified.
 
 	* IPython/genutils.py (Term): added a class for IPython to handle
 	output.  In most cases it will just be a proxy for stdout/err, but
 	having this allows modifications to be made for some platforms,
 	such as handling color escapes under Windows.  All of this code
 	was contributed by Gary Bishop, with minor modifications by me.
 	The actual changes affect many files.
 
 2003-11-30  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (file_matches): new completion code, courtesy
 	of Jeff Collins.  This enables filename completion again under
 	python 2.3, which disabled it at the C level.
 
 2003-11-11  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (amap): Added amap() fn.  Simple shorthand
 	for Numeric.array(map(...)), but often convenient.
 
 2003-11-05  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (frange): Changed a call from int() to
 	int(round()) to prevent a problem reported with arange() in the
 	numpy list.
 
 2003-10-06  Fernando Perez  <[e-mail]>
 
 	* IPython/DPyGetOpt.py (DPyGetOpt.processArguments): changed to
 	prevent crashes if sys lacks an argv attribute (it happens with
 	embedded interpreters which build a bare-bones sys module).
 	Thanks to a report/bugfix by Adam Hupp <hupp-AT-cs.wisc.edu>.
 
 2003-09-24  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic._ofind): blanket except around getattr()
 	to protect against poorly written user objects where __getattr__
 	raises exceptions other than AttributeError.  Thanks to a bug
 	report by Oliver Sander <osander-AT-gmx.de>.
 
 	* IPython/FakeModule.py (FakeModule.__repr__): this method was
 	missing.  Thanks to bug report by Ralf Schmitt <ralf-AT-brainbot.com>.
 
 2003-09-09  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): fix bug where
 	unpacking a list whith a callable as first element would
 	mistakenly trigger autocalling.  Thanks to a bug report by Jeffery
 	Collins.
 
 2003-08-25  *** Released version 0.5.0
 
 2003-08-22  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.linereader): Improved handling of
 	improperly defined user exceptions.  Thanks to feedback from Mark
 	Russell <mrussell-AT-verio.net>.
 	
 2003-08-20  Fernando Perez  <[e-mail]>
 
 	* IPython/OInspect.py (Inspector.pinfo): changed String Form
 	printing so that it would print multi-line string forms starting
 	with a new line.  This way the formatting is better respected for
 	objects which work hard to make nice string forms.
 
 	* IPython/iplib.py (InteractiveShell.handle_auto): Fix bug where
 	autocall would overtake data access for objects with both
 	__getitem__ and __call__.
 
 2003-08-19  *** Released version 0.5.0-rc1
 
 2003-08-19  Fernando Perez  <[e-mail]>
 
 	* IPython/deep_reload.py (load_tail): single tiny change here
 	seems to fix the long-standing bug of dreload() failing to work
 	for dotted names.  But this module is pretty tricky, so I may have
 	missed some subtlety.  Needs more testing!.
 
 	* IPython/ultraTB.py (VerboseTB.linereader): harden against user
 	exceptions which have badly implemented __str__ methods.
 	(VerboseTB.text): harden against inspect.getinnerframes crashing,
 	which I've been getting reports about from Python 2.3 users.  I
 	wish I had a simple test case to reproduce the problem, so I could
 	either write a cleaner workaround or file a bug report if
 	necessary.
 
 	* IPython/Magic.py (Magic.magic_edit): fixed bug where after
 	making a class 'foo', file 'foo.py' couldn't be edited.  Thanks to
 	a bug report by Tjabo Kloppenburg.
 
 	* IPython/ultraTB.py (VerboseTB.debugger): hardened against pdb
 	crashes.  Wrapped the pdb call in a blanket try/except, since pdb
 	seems rather unstable.  Thanks to a bug report by Tjabo
 	Kloppenburg <tjabo.kloppenburg-AT-unix-ag.uni-siegen.de>.
 
 	* IPython/Release.py (version): release 0.5.0-rc1.  I want to put
 	this out soon because of the critical fixes in the inner loop for
 	generators.
 
 	* IPython/Magic.py (Magic.getargspec): removed.  This (and
 	_get_def) have been obsoleted by OInspect for a long time, I
 	hadn't noticed that they were dead code.
 	(Magic._ofind): restored _ofind functionality for a few literals
 	(those in ["''",'""','[]','{}','()']).  But it won't work anymore
 	for things like "hello".capitalize?, since that would require a
 	potentially dangerous eval() again.
 
 	* IPython/iplib.py (InteractiveShell._prefilter): reorganized the
 	logic a bit more to clean up the escapes handling and minimize the
 	use of _ofind to only necessary cases.  The interactive 'feel' of
 	IPython should have improved quite a bit with the changes in
 	_prefilter and _ofind (besides being far safer than before).
 
 	* IPython/Magic.py (Magic.magic_edit): Fixed old bug (but rather
 	obscure, never reported).  Edit would fail to find the object to
 	edit under some circumstances.
 	(Magic._ofind): CRITICAL FIX.  Finally removed the eval() calls
 	which were causing double-calling of generators.  Those eval calls
 	were _very_ dangerous, since code with side effects could be
 	triggered.  As they say, 'eval is evil'...  These were the
 	nastiest evals in IPython.  Besides, _ofind is now far simpler,
 	and it should also be quite a bit faster.  Its use of inspect is
 	also safer, so perhaps some of the inspect-related crashes I've
 	seen lately with Python 2.3 might be taken care of.  That will
 	need more testing.
 
 2003-08-17  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): significant
 	simplifications to the logic for handling user escapes.  Faster
 	and simpler code.
 
 2003-08-14  Fernando Perez  <[e-mail]>
 
         * IPython/numutils.py (sum_flat): rewrote to be non-recursive.
         Now it requires O(N) storage (N=size(a)) for non-contiguous input,
         but it should be quite a bit faster.  And the recursive version
         generated O(log N) intermediate storage for all rank>1 arrays,
         even if they were contiguous.
         (l1norm): Added this function.
         (norm):  Added this function for arbitrary norms (including
         l-infinity).  l1 and l2 are still special cases for convenience
         and speed.
 	
 2003-08-03  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_edit): Removed all remaining string
 	exceptions, which now raise PendingDeprecationWarnings in Python
 	2.3.  There were some in Magic and some in Gnuplot2.
 
 2003-06-30  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page): modified to call curses only for
 	terminals where TERM=='xterm'.  After problems under many other
 	terminals were reported by Keith Beattie <KSBeattie-AT-lbl.gov>.
 
 	* IPython/iplib.py (complete): removed spurious 'print "IE"' which
 	would be triggered when readline was absent.  This was just an old
 	debugging statement I'd forgotten to take out.
 
 2003-06-20  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (clock): modified to return only user time
 	(not counting system time), after a discussion on scipy.  While
 	system time may be a useful quantity occasionally, it may much
 	more easily be skewed by occasional swapping or other similar
 	activity.
 
 2003-06-05  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (identity): new function, for building
 	arbitrary rank Kronecker deltas (mostly backwards compatible with
 	Numeric.identity)
 
 2003-06-03  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.handle_magic): protect
 	arguments passed to magics with spaces, to allow trailing '\' to
 	work normally (mainly for Windows users).
 
 2003-05-29  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): Load site._Helper() as help
 	instead of pydoc.help.  This fixes a bizarre behavior where
 	printing '%s' % locals() would trigger the help system.  Now
 	ipython behaves like normal python does.  
 
 	Note that if one does 'from pydoc import help', the bizarre
 	behavior returns, but this will also happen in normal python, so
 	it's not an ipython bug anymore (it has to do with how pydoc.help
 	is implemented).
 
 2003-05-22  Fernando Perez  <[e-mail]>
 
 	* IPython/FlexCompleter.py (Completer.attr_matches): fixed to
 	return [] instead of None when nothing matches, also match to end
 	of line.  Patch by Gary Bishop.
 
 	* IPython/ipmaker.py (make_IPython): Added same sys.excepthook
 	protection as before, for files passed on the command line.  This
 	prevents the CrashHandler from kicking in if user files call into
 	sys.excepthook (such as PyQt and WxWindows have a nasty habit of
 	doing).  After a report by Kasper Souren <Kasper.Souren-AT-ircam.fr>
 
 2003-05-20  *** Released version 0.4.0
 
 2003-05-20  Fernando Perez  <[e-mail]>
 
 	* setup.py: added support for manpages.  It's a bit hackish b/c of
 	a bug in the way the bdist_rpm distutils target handles gzipped
 	manpages, but it works.  After a patch by Jack.
 
 2003-05-19  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py: added a mockup of the kinds module, since
 	it was recently removed from Numeric.  This way, numutils will
 	work for all users even if they are missing kinds.
 
 	* IPython/Magic.py (Magic._ofind): Harden against an inspect
 	failure, which can occur with SWIG-wrapped extensions.  After a
 	crash report from Prabhu.
 
 2003-05-16  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.excepthook): New method to
 	protect ipython from user code which may call directly
 	sys.excepthook (this looks like an ipython crash to the user, even
 	when it isn't).  After a patch by Gary Bishop <gb-AT-cs.unc.edu>.
 	This is especially important to help users of WxWindows, but may
 	also be useful in other cases.
 
 	* IPython/ultraTB.py (AutoFormattedTB.__call__): Changed to allow
 	an optional tb_offset to be specified, and to preserve exception
 	info if given.  After a patch by Gary Bishop <gb-AT-cs.unc.edu>.
 
 	* ipython.1 (Default): Thanks to Jack's work, we now have manpages!
 
 2003-05-15  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.user_setup): Fix crash when
 	installing for a new user under Windows.
 
 2003-05-12  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.handle_emacs): New line
 	handler for Emacs comint-based lines.  Currently it doesn't do
 	much (but importantly, it doesn't update the history cache).  In
 	the future it may be expanded if Alex needs more functionality
 	there.
 
 	* IPython/CrashHandler.py (CrashHandler.__call__): Added platform
 	info to crash reports.
 
 	* IPython/iplib.py (InteractiveShell.mainloop): Added -c option,
 	just like Python's -c.  Also fixed crash with invalid -color
 	option value at startup. Thanks to Will French
 	<wfrench-AT-bestweb.net> for the bug report.
 
 2003-05-09  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (EvalDict.__getitem__): Renamed EvalString
 	to EvalDict (it's a mapping, after all) and simplified its code
 	quite a bit, after a nice discussion on c.l.py where Gustavo
 	Córdova <gcordova-AT-sismex.com> suggested the new version.
 
 2003-04-30  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (timings_out): modified it to reduce its
 	overhead in the common reps==1 case.
 
 2003-04-29  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (timings_out): Modified to use the resource
 	module, which avoids the wraparound problems of time.clock().
 
 2003-04-17  *** Released version 0.2.15pre4
 
 2003-04-17  Fernando Perez  <[e-mail]>
 
 	* setup.py (scriptfiles): Split windows-specific stuff over to a
 	separate file, in an attempt to have a Windows GUI installer.
 	That didn't work, but part of the groundwork is done.
 
 	* IPython/UserConfig/ipythonrc: Added M-i, M-o and M-I for
 	indent/unindent with 4 spaces.  Particularly useful in combination
 	with the new auto-indent option.
 
 2003-04-16  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py: various replacements of self.rc for
 	self.shell.rc.  A lot more remains to be done to fully disentangle
 	this class from the main Shell class.
 
 	* IPython/GnuplotRuntime.py: added checks for mouse support so
 	that we don't try to enable it if the current gnuplot doesn't
 	really support it.  Also added checks so that we don't try to
 	enable persist under Windows (where Gnuplot doesn't recognize the
 	option).
 
 	* IPython/iplib.py (InteractiveShell.interact): Added optional
 	auto-indenting code, after a patch by King C. Shu
 	<kingshu-AT-myrealbox.com>. It's off by default because it doesn't
 	get along well with pasting indented code.  If I ever figure out
 	how to make that part go well, it will become on by default.
 
 	* IPython/Prompts.py (Prompt1.auto_rewrite): Fixed bug which would
 	crash ipython if there was an unmatched '%' in the user's prompt
 	string.  Reported by Thorsten Kampe <thorsten-AT-thorstenkampe.de>.
 	
 	* IPython/iplib.py (InteractiveShell.interact): removed the
 	ability to ask the user whether he wants to crash or not at the
 	'last line' exception handler.  Calling functions at that point
 	changes the stack, and the error reports would have incorrect
 	tracebacks.
 
 	* IPython/Magic.py (Magic.magic_page): Added new @page magic, to
 	pass through a peger a pretty-printed form of any object.  After a
 	contribution by Olivier Aubert <oaubert-AT-bat710.univ-lyon1.fr>
 
 2003-04-14  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.user_setup): Fixed bug where
 	all files in ~ would be modified at first install (instead of
 	~/.ipython).  This could be potentially disastrous, as the
 	modification (make line-endings native) could damage binary files.
 	
 2003-04-10  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.handle_help): Modified to
 	handle only lines which are invalid python.  This now means that
 	lines like 'x=1 #?' execute properly.  Thanks to Jeffery Collins
 	for the bug report.
 
 2003-04-01  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.showtraceback): Fixed bug
 	where failing to set sys.last_traceback would crash pdb.pm().
 	Thanks to Jeffery D. Collins <Jeff.Collins-AT-vexcel.com> for the bug
 	report.
 
 2003-03-25  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_prun): rstrip() output of profiler
 	before printing it (it had a lot of spurious blank lines at the
 	end).
 
 	* IPython/Gnuplot2.py (Gnuplot.hardcopy): fixed bug where lpr
 	output would be sent 21 times!  Obviously people don't use this
 	too often, or I would have heard about it.
 
 2003-03-24  Fernando Perez  <[e-mail]>
 
 	* setup.py (scriptfiles): renamed the data_files parameter from
 	'base' to 'data' to fix rpm build issues.  Thanks to Ralf Ahlbrink
 	for the patch.
 
 2003-03-20  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (error): added error() and fatal()
 	functions.
 
 2003-03-18  *** Released version 0.2.15pre3
 
 2003-03-18  Fernando Perez  <[e-mail]>
 
 	* setupext/install_data_ext.py
 	(install_data_ext.initialize_options): Class contributed by Jack
 	Moffit for fixing the old distutils hack.  He is sending this to
 	the distutils folks so in the future we may not need it as a
 	private fix.
 
 	* MANIFEST.in: Extensive reorganization, based on Jack Moffit's
 	changes for Debian packaging.  See his patch for full details.
 	The old distutils hack of making the ipythonrc* files carry a
 	bogus .py extension is gone, at last.  Examples were moved to a
 	separate subdir under doc/, and the separate executable scripts
 	now live in their own directory.  Overall a great cleanup.  The
 	manual was updated to use the new files, and setup.py has been
 	fixed for this setup.
 
 	* IPython/PyColorize.py (Parser.usage): made non-executable and
 	created a pycolor wrapper around it to be included as a script.
 
 2003-03-12  *** Released version 0.2.15pre2
 
 2003-03-12  Fernando Perez  <[e-mail]>
 
 	* IPython/ColorANSI.py (make_color_table): Finally fixed the
 	long-standing problem with garbage characters in some terminals.
 	The issue was really that the \001 and \002 escapes must _only_ be
 	passed to input prompts (which call readline), but _never_ to
 	normal text to be printed on screen.  I changed ColorANSI to have
 	two classes: TermColors and InputTermColors, each with the
 	appropriate escapes for input prompts or normal text.  The code in
 	Prompts.py got slightly more complicated, but this very old and
 	annoying bug is finally fixed.  
 
 	All the credit for nailing down the real origin of this problem
 	and the correct solution goes to Jack Moffit <jack-AT-xiph.org>.
 	*Many* thanks to him for spending quite a bit of effort on this.
 
 2003-03-05  *** Released version 0.2.15pre1
 
 2003-03-03  Fernando Perez  <[e-mail]>
 
 	* IPython/FakeModule.py: Moved the former _FakeModule to a
 	separate file, because it's also needed by Magic (to fix a similar
 	pickle-related issue in @run).
 
 2003-03-02  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_autocall): new magic to control
 	the autocall option at runtime.
 	(Magic.magic_dhist): changed self.user_ns to self.shell.user_ns
 	across Magic.py to start separating Magic from InteractiveShell.
 	(Magic._ofind): Fixed to return proper namespace for dotted
 	names. Before, a dotted name would always return 'not currently
 	defined', because it would find the 'parent'. s.x would be found,
 	but since 'x' isn't defined by itself, it would get confused.
 	(Magic.magic_run): Fixed pickling problems reported by Ralf
 	Ahlbrink <RAhlbrink-AT-RosenInspection.net>.  The fix was similar to
 	that I'd used when Mike Heeter reported similar issues at the
 	top-level, but now for @run.  It boils down to injecting the
 	namespace where code is being executed with something that looks
 	enough like a module to fool pickle.dump().  Since a pickle stores
 	a named reference to the importing module, we need this for
 	pickles to save something sensible.
 
 	* IPython/ipmaker.py (make_IPython): added an autocall option.
 
 	* IPython/iplib.py (InteractiveShell._prefilter): reordered all of
 	the auto-eval code.  Now autocalling is an option, and the code is
 	also vastly safer.  There is no more eval() involved at all.
 
 2003-03-01  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic._ofind): Changed interface to return a
 	dict with named keys instead of a tuple.
 
 	* IPython: Started using CVS for IPython as of 0.2.15pre1.
 
 	* setup.py (make_shortcut): Fixed message about directories
 	created during Windows installation (the directories were ok, just
 	the printed message was misleading).  Thanks to Chris Liechti
 	<cliechti-AT-gmx.net> for the heads up.
 
 2003-02-21  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): Fixed catching
 	of ValueError exception when checking for auto-execution.  This
 	one is raised by things like Numeric arrays arr.flat when the
 	array is non-contiguous.
 
 2003-01-31  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (SystemExec.bq): Fixed bug where bq would
 	not return any value at all (even though the command would get
 	executed).
 	(xsys): Flush stdout right after printing the command to ensure
 	proper ordering of commands and command output in the total
 	output.
 	(SystemExec/xsys/bq): Switched the names of xsys/bq and
 	system/getoutput as defaults.  The old ones are kept for
 	compatibility reasons, so no code which uses this library needs
 	changing.
 
 2003-01-27  *** Released version 0.2.14
 
 2003-01-25  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_edit): Fixed problem where
 	functions defined in previous edit sessions could not be re-edited
 	(because the temp files were immediately removed).  Now temp files
 	are removed only at IPython's exit.
 	(Magic.magic_run): Improved @run to perform shell-like expansions
 	on its arguments (~users and $VARS).  With this, @run becomes more
 	like a normal command-line.
 
 	* IPython/Shell.py (IPShellEmbed.__call__): Fixed a bunch of small
 	bugs related to embedding and cleaned up that code.  A fairly
 	important one was the impossibility to access the global namespace
 	through the embedded IPython (only local variables were visible).
 
 2003-01-14  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell._prefilter): Fixed
 	auto-calling to be a bit more conservative.  Now it doesn't get
 	triggered if any of '!=()<>' are in the rest of the input line, to
 	allow comparing callables.  Thanks to Alex for the heads up.
 
 2003-01-07  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page): fixed estimation of the number of
 	lines in a string to be paged to simply count newlines. This
 	prevents over-guessing due to embedded escape sequences. A better
 	long-term solution would involve stripping out the control chars
 	for the count, but it's potentially so expensive I just don't
 	think it's worth doing.
 
 2002-12-19  *** Released version 0.2.14pre50
 
 2002-12-19  Fernando Perez  <[e-mail]>
 
 	* tools/release (version): Changed release scripts to inform
 	Andrea and build a NEWS file with a list of recent changes.
 
 	* IPython/ColorANSI.py (__all__): changed terminal detection
 	code. Seems to work better for xterms without breaking
 	konsole. Will need more testing to determine if WinXP and Mac OSX
 	also work ok.
 
 2002-12-18  *** Released version 0.2.14pre49
 
 2002-12-18  Fernando Perez  <[e-mail]>
 
 	* Docs: added new info about Mac OSX, from Andrea.
 
 	* IPython/Gnuplot2.py (String): Added a String PlotItem class to
 	allow direct plotting of python strings whose format is the same
 	of gnuplot data files.
 
 2002-12-16  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): fixed default (y)
 	value of exit question to be acknowledged.
 
 2002-12-03  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py: removed generators, which had been added
 	by mistake in an earlier debugging run. This was causing trouble
 	to users of python 2.1.x. Thanks to Abel Daniel <abli-AT-freemail.hu>
 	for pointing this out.
 
 2002-11-17  Fernando Perez  <[e-mail]>
 
 	* Manual: updated the Gnuplot section.
 
 	* IPython/GnuplotRuntime.py: refactored a lot all this code, with
 	a much better split of what goes in Runtime and what goes in
 	Interactive.
 
 	* IPython/ipmaker.py: fixed bug where import_fail_info wasn't
 	being imported from iplib.
 
 	* IPython/GnuplotInteractive.py (magic_gpc): renamed @gp to @gpc
 	for command-passing. Now the global Gnuplot instance is called
 	'gp' instead of 'g', which was really a far too fragile and
 	common name.
 
 	* IPython/Gnuplot2.py (eps_fix_bbox): added this to fix broken
 	bounding boxes generated by Gnuplot for square plots.
 
 	* IPython/genutils.py (popkey): new function added. I should
 	suggest this on c.l.py as a dict method, it seems useful.
 
 	* IPython/Gnuplot2.py (Gnuplot.plot): Overhauled plot and replot
 	to transparently handle PostScript generation. MUCH better than
 	the previous plot_eps/replot_eps (which I removed now). The code
 	is also fairly clean and well documented now (including
 	docstrings).
 
 2002-11-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_edit): fixed docstring
 	(inconsistent with options).
 
 	* IPython/Gnuplot2.py (Gnuplot.hardcopy): hardcopy had been
 	manually disabled, I don't know why. Fixed it.
 	(Gnuplot._plot_eps): added new plot_eps/replot_eps to get directly
 	eps output.
 
 2002-11-12  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (ask_yes_no): trap EOF and ^C so that they
 	don't propagate up to caller. Fixes crash reported by François
 	Pinard.
 
 2002-11-09  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): fixed problem with writing
 	history file for new users.
 	(make_IPython): fixed bug where initial install would leave the
 	user running in the .ipython dir.
 	(make_IPython): fixed bug where config dir .ipython would be
 	created regardless of the given -ipythondir option. Thanks to Cory
 	Dodt <cdodt-AT-fcoe.k12.ca.us> for the bug report.
 
 	* IPython/genutils.py (ask_yes_no): new function for asking yes/no
 	type confirmations. Will need to use it in all of IPython's code
 	consistently.
 	
 	* IPython/CrashHandler.py (CrashHandler.__call__): changed the
 	context to print 31 lines instead of the default 5. This will make
 	the crash reports extremely detailed in case the problem is in
 	libraries I don't have access to.
 
 	* IPython/iplib.py (InteractiveShell.interact): changed the 'last
 	line of defense' code to still crash, but giving users fair
 	warning. I don't want internal errors to go unreported: if there's
 	an internal problem, IPython should crash and generate a full
 	report.
 
 2002-11-08  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): added code to trap
 	otherwise uncaught exceptions which can appear if people set
 	sys.stdout to something badly broken. Thanks to a crash report
 	from henni-AT-mail.brainbot.com.
 
 2002-11-04  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): added
 	__IPYTHON__active to the builtins. It's a flag which goes on when
 	the interaction starts and goes off again when it stops. This
 	allows embedding code to detect being inside IPython. Before this
 	was done via __IPYTHON__, but that only shows that an IPython
 	instance has been created.
 
 	* IPython/Magic.py (Magic.magic_env): I realized that in a
 	UserDict, instance.data holds the data as a normal dict. So I
 	modified @env to return os.environ.data instead of rebuilding a
 	dict by hand.
 
 2002-11-02  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (warn): changed so that level 1 prints no
 	header. Level 2 is now the default (with 'WARNING' header, as
 	before). I think I tracked all places where changes were needed in
 	IPython, but outside code using the old level numbering may have
 	broken.
 
 	* IPython/iplib.py (InteractiveShell.runcode): added this to
 	handle the tracebacks in SystemExit traps correctly. The previous
 	code (through interact) was printing more of the stack than
 	necessary, showing IPython internal code to the user.
 
 	* IPython/UserConfig/ipythonrc.py: Made confirm_exit 1 by
 	default. Now that the default at the confirmation prompt is yes,
 	it's not so intrusive. François' argument that ipython sessions
 	tend to be complex enough not to lose them from an accidental C-d,
 	is a valid one.
 
 	* IPython/iplib.py (InteractiveShell.interact): added a
 	showtraceback() call to the SystemExit trap, and modified the exit
 	confirmation to have yes as the default.
 
 	* IPython/UserConfig/ipythonrc.py: removed 'session' option from
 	this file. It's been gone from the code for a long time, this was
 	simply leftover junk.
 
 2002-11-01  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/ipythonrc.py: new confirm_exit option
 	added. If set, IPython now traps EOF and asks for
 	confirmation. After a request by François Pinard.
 
 	* IPython/Magic.py (Magic.magic_Exit): New @Exit and @Quit instead
 	of @abort, and with a new (better) mechanism for handling the
 	exceptions.
 
 2002-10-27  Fernando Perez  <[e-mail]>
 
 	* IPython/usage.py (__doc__): updated the --help information and
 	the ipythonrc file to indicate that -log generates
 	./ipython.log. Also fixed the corresponding info in @logstart.
 	This and several other fixes in the manuals thanks to reports by
 	François Pinard <pinard-AT-iro.umontreal.ca>.
 	
 	* IPython/Logger.py (Logger.switch_log): Fixed error message to
 	refer to @logstart (instead of @log, which doesn't exist).
 
 	* IPython/iplib.py (InteractiveShell._prefilter): fixed
 	AttributeError crash. Thanks to Christopher Armstrong
 	<radix-AT-twistedmatrix.com> for the report/fix. This bug had been
 	introduced recently (in 0.2.14pre37) with the fix to the eval
 	problem mentioned below.
 	
 2002-10-17  Fernando Perez  <[e-mail]>
 
 	* IPython/ConfigLoader.py (ConfigLoader.load): Fixes for Windows
 	installation. Thanks to Leonardo Santagada <retype-AT-terra.com.br>.
 
 	* IPython/iplib.py (InteractiveShell._prefilter): Many changes to
 	this function to fix a problem reported by Alex Schmolck. He saw
 	it with list comprehensions and generators, which were getting
 	called twice. The real problem was an 'eval' call in testing for
 	automagic which was evaluating the input line silently. 
 
 	This is a potentially very nasty bug, if the input has side
 	effects which must not be repeated. The code is much cleaner now,
 	without any blanket 'except' left and with a regexp test for
 	actual function names. 
 
 	But an eval remains, which I'm not fully comfortable with. I just
 	don't know how to find out if an expression could be a callable in
 	the user's namespace without doing an eval on the string. However
 	that string is now much more strictly checked so that no code
 	slips by, so the eval should only happen for things that can
 	really be only function/method names.
 
 2002-10-15  Fernando Perez  <[e-mail]>
 
 	* Updated LyX to 1.2.1 so I can work on the docs again. Added Mac
 	OSX information to main manual, removed README_Mac_OSX file from
 	distribution. Also updated credits for recent additions.
 
 2002-10-10  Fernando Perez  <[e-mail]>
 
 	* README_Mac_OSX: Added a README for Mac OSX users for fixing
 	terminal-related issues. Many thanks to Andrea Riciputi
 	<andrea.riciputi-AT-libero.it> for writing it.
 
 	* IPython/UserConfig/ipythonrc.py: Fixes to various small issues,
 	thanks to Thorsten Kampe <thorsten-AT-thorstenkampe.de>.
 
 	* setup.py (make_shortcut): Fixes for Windows installation. Thanks
 	to Fredrik Kant <fredrik.kant-AT-front.com> and Syver Enstad
 	<syver-en-AT-online.no> who both submitted patches for this problem.
 
 	* IPython/iplib.py (InteractiveShell.embed_mainloop): Patch for
 	global embedding to make sure that things don't overwrite user
 	globals accidentally. Thanks to Richard <rxe-AT-renre-europe.com>
 
 	* IPython/Gnuplot2.py (gp): Patch for Gnuplot.py 1.6
 	compatibility. Thanks to Hayden Callow
 	<h.callow-AT-elec.canterbury.ac.nz>
 
 2002-10-04  Fernando Perez  <[e-mail]>
 
 	* IPython/Gnuplot2.py (PlotItem): Added 'index' option for
 	Gnuplot.File objects.
 	      
 2002-07-23  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (timing): Added timings() and timing() for
 	quick access to the most commonly needed data, the execution
 	times. Old timing() renamed to timings_out().
 
 2002-07-18  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShellEmbed.restore_system_completer): fixed
 	bug with nested instances disrupting the parent's tab completion.
 
 	* IPython/iplib.py (all_completions): Added Alex Schmolck's
 	all_completions code to begin the emacs integration.
 
 	* IPython/Gnuplot2.py (zip_items): Added optional 'titles'
 	argument to allow titling individual arrays when plotting.
 
 2002-07-15  Fernando Perez  <[e-mail]>
 
 	* setup.py (make_shortcut): changed to retrieve the value of
 	'Program Files' directory from the registry (this value changes in
 	non-english versions of Windows). Thanks to Thomas Fanslau
 	<tfanslau-AT-gmx.de> for the report.
 
 2002-07-10  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.debugger): enabled workaround for
 	a bug in pdb, which crashes if a line with only whitespace is
 	entered. Bug report submitted to sourceforge.
 
 2002-07-09  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.nullrepr): fixed rare crash when
 	reporting exceptions (it's a bug in inspect.py, I just set a
 	workaround).
 
 2002-07-08  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): fixed reference to
 	__IPYTHON__ in __builtins__ to show up in user_ns.
 
 2002-07-03  Fernando Perez  <[e-mail]>
 
 	* IPython/GnuplotInteractive.py (magic_gp_set_default): changed
 	name from @gp_set_instance to @gp_set_default.
 
 	* IPython/ipmaker.py (make_IPython): default editor value set to
 	'0' (a string), to match the rc file. Otherwise will crash when
 	.strip() is called on it.
 	
 
 2002-06-28  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.safe_execfile): fix importing
 	of files in current directory when a file is executed via
 	@run. Patch also by RA <ralf_ahlbrink-AT-web.de>.
 
 	* setup.py (manfiles): fix for rpm builds, submitted by RA
 	<ralf_ahlbrink-AT-web.de>. Now we have RPMs!
 
 	* IPython/ipmaker.py (make_IPython): fixed lookup of default
 	editor when set to '0'. Problem was, '0' evaluates to True (it's a
 	string!). A. Schmolck caught this one.
 
 2002-06-27  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): fixed bug when running user
 	defined files at the cmd line. __name__ wasn't being set to
 	__main__.
 
 	* IPython/Gnuplot2.py (zip_items): improved it so it can plot also
 	regular lists and tuples besides Numeric arrays.
 
 	* IPython/Prompts.py (CachedOutput.__call__): Added output
 	supression for input ending with ';'. Similar to Mathematica and
 	Matlab. The _* vars and Out[] list are still updated, just like
 	Mathematica behaves.
 
 2002-06-25  Fernando Perez  <[e-mail]>
 
 	* IPython/ConfigLoader.py (ConfigLoader.load): fixed checking of
 	.ini extensions for profiels under Windows.
 
 	* IPython/OInspect.py (Inspector.pinfo): improved alignment of
 	string form. Fix contributed by Alexander Schmolck
 	<a.schmolck-AT-gmx.net>
 
 	* IPython/GnuplotRuntime.py (gp_new): new function. Returns a
 	pre-configured Gnuplot instance.
 
 2002-06-21  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py (exp_safe): new function, works around the
 	underflow problems in Numeric.
 	(log2): New fn. Safe log in base 2: returns exact integer answer
 	for exact integer powers of 2.
 
 	* IPython/Magic.py (get_py_filename): fixed it not expanding '~'
 	properly.
 
 2002-06-20  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (timing): new function like
 	Mathematica's. Similar to time_test, but returns more info.
 
 2002-06-18  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_save): modified @save and @r
 	according to Mike Heeter's suggestions.
 
 2002-06-16  Fernando Perez  <[e-mail]>
 
 	* IPython/GnuplotRuntime.py: Massive overhaul to the Gnuplot
 	system. GnuplotMagic is gone as a user-directory option. New files
 	make it easier to use all the gnuplot stuff both from external
 	programs as well as from IPython. Had to rewrite part of
 	hardcopy() b/c of a strange bug: often the ps files simply don't
 	get created, and require a repeat of the command (often several
 	times).
 
 	* IPython/ultraTB.py (AutoFormattedTB.__call__): changed to
 	resolve output channel at call time, so that if sys.stderr has
 	been redirected by user this gets honored.
 
 2002-06-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPShell.__init__): Changed IPythonShell to
 	IPShell. Kept a copy with the old names to avoid breaking people's
 	embedded code.
 
 	* IPython/ipython: simplified it to the bare minimum after
 	Holger's suggestions. Added info about how to use it in
 	PYTHONSTARTUP.
 
 	* IPython/Shell.py (IPythonShell): changed the options passing
 	from a string with funky %s replacements to a straight list. Maybe
 	a bit more typing, but it follows sys.argv conventions, so there's
 	less special-casing to remember.
 
 2002-06-12  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_r): new magic auto-repeat
 	command. Thanks to a suggestion by Mike Heeter.
 	(Magic.magic_pfile): added behavior to look at filenames if given
 	arg is not a defined object.
 	(Magic.magic_save): New @save function to save code snippets. Also
 	a Mike Heeter idea.
 
 	* IPython/UserConfig/GnuplotMagic.py (plot): Improvements to
 	plot() and replot(). Much more convenient now, especially for
 	interactive use.
 
 	* IPython/Magic.py (Magic.magic_run): Added .py automatically to
 	filenames.
 
 2002-06-02  Fernando Perez  <[e-mail]>
 
 	* IPython/Struct.py (Struct.__init__): modified to admit
 	initialization via another struct.
 
 	* IPython/genutils.py (SystemExec.__init__): New stateful
 	interface to xsys and bq. Useful for writing system scripts.
 
 2002-05-30  Fernando Perez  <[e-mail]>
 
 	* MANIFEST.in: Changed docfile selection to exclude all the lyx
 	documents. This will make the user download smaller (it's getting
 	too big).
 
 2002-05-29  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (_FakeModule.__init__): New class introduced to
 	fix problems with shelve and pickle. Seems to work, but I don't
 	know if corner cases break it. Thanks to Mike Heeter
 	<korora-AT-SDF.LONESTAR.ORG> for the bug reports and test cases.
 
 2002-05-24  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Macro.__init__): fixed magics embedded in
 	macros having broken.
 
 2002-05-21  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_logstart): fixed recently
 	introduced logging bug: all history before logging started was
 	being written one character per line! This came from the redesign
 	of the input history as a special list which slices to strings,
 	not to lists.
 
 2002-05-20  Fernando Perez  <[e-mail]>
 
 	* IPython/Prompts.py (CachedOutput.__init__): made the color table
 	be an attribute of all classes in this module. The design of these
 	classes needs some serious overhauling.
 
 	* IPython/DPyGetOpt.py (DPyGetOpt.setPosixCompliance): fixed bug
 	which was ignoring '_' in option names.
 
 	* IPython/ultraTB.py (FormattedTB.__init__): Changed
 	'Verbose_novars' to 'Context' and made it the new default. It's a
 	bit more readable and also safer than verbose.
 
 	* IPython/PyColorize.py (Parser.__call__): Fixed coloring of
 	triple-quoted strings.
 
 	* IPython/OInspect.py (__all__): new module exposing the object
 	introspection facilities. Now the corresponding magics are dummy
 	wrappers around this. Having this module will make it much easier
 	to put these functions into our modified pdb.
 	This new object inspector system uses the new colorizing module,
 	so source code and other things are nicely syntax highlighted.
 
 2002-05-18  Fernando Perez  <[e-mail]>
 
 	* IPython/ColorANSI.py: Split the coloring tools into a separate
 	module so I can use them in other code easier (they were part of
 	ultraTB).
 
 2002-05-17  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/GnuplotMagic.py (magic_gp_set_instance):
 	fixed it to set the global 'g' also to the called instance, as
 	long as 'g' was still a gnuplot instance (so it doesn't overwrite
 	user's 'g' variables).
 
 	* IPython/iplib.py (InteractiveShell.__init__): Added In/Out
 	global variables (aliases to _ih,_oh) so that users which expect
 	In[5] or Out[7] to work aren't unpleasantly surprised.
 	(InputList.__getslice__): new class to allow executing slices of
 	input history directly. Very simple class, complements the use of
 	macros.
 
 2002-05-16  Fernando Perez  <[e-mail]>
 
 	* setup.py (docdirbase): make doc directory be just doc/IPython
 	without version numbers, it will reduce clutter for users.
 
 	* IPython/Magic.py (Magic.magic_run): Add explicit local dict to
 	execfile call to prevent possible memory leak. See for details:
 	http://mail.python.org/pipermail/python-list/2002-February/088476.html
 
 2002-05-15  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_psource): made the object
 	introspection names be more standard: pdoc, pdef, pfile and
 	psource. They all print/page their output, and it makes
 	remembering them easier. Kept old names for compatibility as
 	aliases.
 
 2002-05-14  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/GnuplotMagic.py: I think I finally understood
 	what the mouse problem was. The trick is to use gnuplot with temp
 	files and NOT with pipes (for data communication), because having
 	both pipes and the mouse on is bad news.
 
 2002-05-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic._ofind): fixed namespace order search
 	bug. Information would be reported about builtins even when
 	user-defined functions overrode them.
 
 2002-05-11  Fernando Perez  <[e-mail]>
 
 	* IPython/__init__.py (__all__): removed FlexCompleter from
 	__all__ so that things don't fail in platforms without readline.
 
 2002-05-10  Fernando Perez  <[e-mail]>
 
 	* IPython/__init__.py (__all__): removed numutils from __all__ b/c
 	it requires Numeric, effectively making Numeric a dependency for
 	IPython.
 
 	* Released 0.2.13
 
 	* IPython/Magic.py (Magic.magic_prun): big overhaul to the
 	profiler interface. Now all the major options from the profiler
 	module are directly supported in IPython, both for single
 	expressions (@prun) and for full programs (@run -p).
 
 2002-05-09  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_doc): fixed to show docstrings of
 	magic properly formatted for screen.
 
 	* setup.py (make_shortcut): Changed things to put pdf version in
 	doc/ instead of doc/manual (had to change lyxport a bit).
 
 	* IPython/Magic.py (Profile.string_stats): made profile runs go
 	through pager (they are long and a pager allows searching, saving,
 	etc.)
 
 2002-05-08  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.12
 
 2002-05-06  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_hist): small bug fixed (recently
 	introduced); 'hist n1 n2' was broken.
 	(Magic.magic_pdb): added optional on/off arguments to @pdb
 	(Magic.magic_run): added option -i to @run, which executes code in
 	the IPython namespace instead of a clean one. Also added @irun as
 	an alias to @run -i.
 
 	* IPython/UserConfig/GnuplotMagic.py (magic_gp_set_instance):
 	fixed (it didn't really do anything, the namespaces were wrong).
 
 	* IPython/Debugger.py (__init__): Added workaround for python 2.1
 
 	* IPython/__init__.py (__all__): Fixed package namespace, now
 	'import IPython' does give access to IPython.<all> as
 	expected. Also renamed __release__ to Release.
 
 	* IPython/Debugger.py (__license__): created new Pdb class which
 	functions like a drop-in for the normal pdb.Pdb but does NOT
 	import readline by default. This way it doesn't muck up IPython's
 	readline handling, and now tab-completion finally works in the
 	debugger -- sort of. It completes things globally visible, but the
 	completer doesn't track the stack as pdb walks it. That's a bit
 	tricky, and I'll have to implement it later.
 
 2002-05-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_oinfo): fixed formatting bug for
 	magic docstrings when printed via ? (explicit \'s were being
 	printed).
 
 	* IPython/ipmaker.py (make_IPython): fixed namespace
 	identification bug. Now variables loaded via logs or command-line
 	files are recognized in the interactive namespace by @who.
 
 	* IPython/iplib.py (InteractiveShell.safe_execfile): Fixed bug in
 	log replay system stemming from the string form of Structs.
 
 	* IPython/Magic.py (Macro.__init__): improved macros to properly
 	handle magic commands in them.
 	(Magic.magic_logstart): usernames are now expanded so 'logstart
 	~/mylog' now works.
 
 	* IPython/iplib.py (complete): fixed bug where paths starting with
 	'/' would be completed as magic names.
 
 2002-05-04  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_run): added options -p and -f to
 	allow running full programs under the profiler's control.
 
 	* IPython/ultraTB.py (FormattedTB.__init__): Added Verbose_novars
 	mode to report exceptions verbosely but without formatting
 	variables. This addresses the issue of ipython 'freezing' (it's
 	not frozen, but caught in an expensive formatting loop) when huge
 	variables are in the context of an exception.
 	(VerboseTB.text): Added '--->' markers at line where exception was
 	triggered. Much clearer to read, especially in NoColor modes.
 
 	* IPython/Magic.py (Magic.magic_run): bugfix: -n option had been
 	implemented in reverse when changing to the new parse_options().
 
 2002-05-03  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.parse_options): new function so that
 	magics can parse options easier.
 	(Magic.magic_prun): new function similar to profile.run(),
 	suggested by Chris Hart.
 	(Magic.magic_cd): fixed behavior so that it only changes if
 	directory actually is in history.
 
 	* IPython/usage.py (__doc__): added information about potential
 	slowness of Verbose exception mode when there are huge data
 	structures to be formatted (thanks to Archie Paulson).
 
 	* IPython/ipmaker.py (make_IPython): Changed default logging
 	(when simply called with -log) to use curr_dir/ipython.log in
 	rotate mode. Fixed crash which was occuring with -log before
 	(thanks to Jim Boyle).
 
 2002-05-01  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.11 for these fixes (mainly the ultraTB one which
 	was nasty -- though somewhat of a corner case).
 
 	* IPython/ultraTB.py (AutoFormattedTB.text): renamed __text to
 	text (was a bug).
 
 2002-04-30  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/GnuplotMagic.py (magic_gp): Minor fix to add
 	a print after ^D or ^C from the user so that the In[] prompt
 	doesn't over-run the gnuplot one.
 
 2002-04-29  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.10
 
 	* IPython/__release__.py (version): get date dynamically.
 
 	* Misc. documentation updates thanks to Arnd's comments. Also ran
 	a full spellcheck on the manual (hadn't been done in a while).
 
 2002-04-27  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_logstart): Fixed bug where
 	starting a log in mid-session would reset the input history list.
 
 2002-04-26  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.wait): Fixed bug where not
 	all files were being included in an update. Now anything in
 	UserConfig that matches [A-Za-z]*.py will go (this excludes
 	__init__.py)
 
 2002-04-25  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.__init__): Added __IPYTHON__
 	to __builtins__ so that any form of embedded or imported code can
 	test for being inside IPython.
 
 	* IPython/UserConfig/GnuplotMagic.py: (magic_gp_set_instance):
 	changed to GnuplotMagic because it's now an importable module,
 	this makes the name follow that of the standard Gnuplot module.
 	GnuplotMagic can now be loaded at any time in mid-session.
 
 2002-04-24  Fernando Perez  <[e-mail]>
 
 	* IPython/numutils.py: removed SIUnits. It doesn't properly set
 	the globals (IPython has its own namespace) and the
 	PhysicalQuantity stuff is much better anyway.
 
 	* IPython/UserConfig/example-gnuplot.py (g2): Added gnuplot
 	embedding example to standard user directory for
 	distribution. Also put it in the manual.
 
 	* IPython/numutils.py (gnuplot_exec): Changed to take a gnuplot
 	instance as first argument (so it doesn't rely on some obscure
 	hidden global).
 
 	* IPython/UserConfig/ipythonrc.py: put () back in accepted
 	delimiters. While it prevents ().TAB from working, it allows
 	completions in open (... expressions. This is by far a more common
 	case.
 
 2002-04-23  Fernando Perez  <[e-mail]>
 
 	* IPython/Extensions/InterpreterPasteInput.py: new
 	syntax-processing module for pasting lines with >>> or ... at the
 	start.
 
 	* IPython/Extensions/PhysicalQ_Interactive.py
 	(PhysicalQuantityInteractive.__int__): fixed to work with either
 	Numeric or math.
 
 	* IPython/UserConfig/ipythonrc-numeric.py: reorganized the
 	provided profiles. Now we have:
 	-math -> math module as * and cmath with its own namespace.
 	-numeric -> Numeric as *, plus gnuplot & grace
 	-physics -> same as before
 
 	* IPython/Magic.py (Magic.magic_magic): Fixed bug where
 	user-defined magics wouldn't be found by @magic if they were
 	defined as class methods. Also cleaned up the namespace search
 	logic and the string building (to use %s instead of many repeated
 	string adds).
 
 	* IPython/UserConfig/example-magic.py (magic_foo): updated example
 	of user-defined magics to operate with class methods (cleaner, in
 	line with the gnuplot code).
 
 2002-04-22  Fernando Perez  <[e-mail]>
 
 	* setup.py: updated dependency list so that manual is updated when
 	all included files change.
 
 	* IPython/ipmaker.py (make_IPython): Fixed bug which was ignoring
 	the delimiter removal option (the fix is ugly right now).
 
 	* IPython/UserConfig/ipythonrc-physics.py: simplified not to load
 	all of the math profile (quicker loading, no conflict between
 	g-9.8 and g-gnuplot).
 
 	* IPython/CrashHandler.py (CrashHandler.__call__): changed default
 	name of post-mortem files to IPython_crash_report.txt.
 
 	* Cleanup/update of the docs. Added all the new readline info and
 	formatted all lists as 'real lists'.
 
 	* IPython/ipmaker.py (make_IPython): removed now-obsolete
 	tab-completion options, since the full readline parse_and_bind is
 	now accessible.
 
 	* IPython/iplib.py (InteractiveShell.init_readline): Changed
 	handling of readline options. Now users can specify any string to
 	be passed to parse_and_bind(), as well as the delimiters to be
 	removed.
 	(InteractiveShell.__init__): Added __name__ to the global
 	namespace so that things like Itpl which rely on its existence
 	don't crash.
 	(InteractiveShell._prefilter): Defined the default with a _ so
 	that prefilter() is easier to override, while the default one
 	remains available.
 
 2002-04-18  Fernando Perez  <[e-mail]>
 
 	* Added information about pdb in the docs.
 
 2002-04-17  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): added rc_override option to
 	allow passing config options at creation time which may override
 	anything set in the config files or command line. This is
 	particularly useful for configuring embedded instances.
 
 2002-04-15  Fernando Perez  <[e-mail]>
 
 	* IPython/Logger.py (Logger.log): Fixed a nasty bug which could
 	crash embedded instances because of the input cache falling out of
 	sync with the output counter.
 
 	* IPython/Shell.py (IPythonShellEmbed.__init__): added a debug
 	mode which calls pdb after an uncaught exception in IPython itself.
 
 2002-04-14  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.showtraceback): pdb mucks up
 	readline, fix it back after each call.
 
 	* IPython/ultraTB.py (AutoFormattedTB.__text): made text a private
 	method to force all access via __call__(), which guarantees that
 	traceback references are properly deleted.
 
 	* IPython/Prompts.py (CachedOutput._display): minor fixes to
 	improve printing when pprint is in use.
 
 2002-04-13  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPythonShellEmbed.__call__): SystemExit
 	exceptions aren't caught anymore. If the user triggers one, he
 	should know why he's doing it and it should go all the way up,
 	just like any other exception. So now @abort will fully kill the
 	embedded interpreter and the embedding code (unless that happens
 	to catch SystemExit).
 
 	* IPython/ultraTB.py (VerboseTB.__init__): added a call_pdb flag
 	and a debugger() method to invoke the interactive pdb debugger
 	after printing exception information. Also added the corresponding
 	-pdb option and @pdb magic to control this feature, and updated
 	the docs. After a suggestion from Christopher Hart
 	(hart-AT-caltech.edu).
 
 2002-04-12  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPythonShellEmbed.__init__): modified to use
 	the exception handlers defined by the user (not the CrashHandler)
 	so that user exceptions don't trigger an ipython bug report.
 
 	* IPython/ultraTB.py (ColorTB.__init__): made the color scheme
 	configurable (it should have always been so).
 
 2002-03-26  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPythonShellEmbed.__call__): many changes here
 	and there to fix embedding namespace issues. This should all be
 	done in a more elegant way.
 
 2002-03-25  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (get_home_dir): Try to make it work under
 	win9x also.
 
 2002-03-20  Fernando Perez  <[e-mail]>
 
 	* IPython/Shell.py (IPythonShellEmbed.__init__): leave
 	sys.displayhook untouched upon __init__.
 
 2002-03-19  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.9 (for embedding bug, basically).
 
 	* IPython/Shell.py (IPythonShellEmbed.__call__): Trap SystemExit
 	exceptions so that enclosing shell's state can be restored.
 
 	* Changed magic_gnuplot.py to magic-gnuplot.py to standardize
 	naming conventions in the .ipython/ dir.
 
 	* IPython/iplib.py (InteractiveShell.init_readline): removed '-'
 	from delimiters list so filenames with - in them get expanded.
 
 	* IPython/Shell.py (IPythonShellEmbed.__call__): fixed bug with
 	sys.displayhook not being properly restored after an embedded call.
 
  2002-03-18  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.8
 
 	* IPython/iplib.py (InteractiveShell.user_setup): fixed bug where
 	some files weren't being included in a -upgrade.
 	(InteractiveShell.init_readline): Added 'set show-all-if-ambiguous
 	on' so that the first tab completes.
 	(InteractiveShell.handle_magic): fixed bug with spaces around
 	quotes breaking many magic commands.
 
 	* setup.py: added note about ignoring the syntax error messages at
 	installation.
 
 	* IPython/UserConfig/magic_gnuplot.py (magic_gp): finished
 	streamlining the gnuplot interface, now there's only one magic @gp.
 
 2002-03-17  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/magic_gnuplot.py: new name for the
 	example-magic_pm.py file. Much enhanced system, now with a shell
 	for communicating directly with gnuplot, one command at a time.
 
 	* IPython/Magic.py (Magic.magic_run): added option -n to prevent
 	setting __name__=='__main__'.
 
 	* IPython/UserConfig/example-magic_pm.py (magic_pm): Added
 	mini-shell for accessing gnuplot from inside ipython. Should
 	extend it later for grace access too. Inspired by Arnd's
 	suggestion.
 
 	* IPython/iplib.py (InteractiveShell.handle_magic): fixed bug when
 	calling magic functions with () in their arguments. Thanks to Arnd
 	Baecker for pointing this to me.
 
 	* IPython/numutils.py (sum_flat): fixed bug. Would recurse
 	infinitely for integer or complex arrays (only worked with floats).
 
 2002-03-16  Fernando Perez  <[e-mail]>
 
 	* setup.py: Merged setup and setup_windows into a single script
 	which properly handles things for windows users.
 
 2002-03-15  Fernando Perez  <[e-mail]>
 
 	* Big change to the manual: now the magics are all automatically
 	documented. This information is generated from their docstrings
 	and put in a latex file included by the manual lyx file. This way
 	we get always up to date information for the magics. The manual
 	now also has proper version information, also auto-synced.
 
 	For this to work, an undocumented --magic_docstrings option was added.
 
 2002-03-13  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (TermColors): fixed problem with dark colors
 	under CDE terminals. An explicit ;2 color reset is needed in the escapes.
 
 2002-03-12  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (TermColors): changed color escapes again to
 	fix the (old, reintroduced) line-wrapping bug. Basically, if
 	\001..\002 aren't given in the color escapes, lines get wrapped
 	weirdly. But giving those screws up old xterms and emacs terms. So
 	I added some logic for emacs terms to be ok, but I can't identify old
 	xterms separately ($TERM=='xterm' for many terminals, like konsole).
 
 2002-03-10  Fernando Perez  <[e-mail]>
 
 	* IPython/usage.py (__doc__): Various documentation cleanups and
 	updates, both in usage docstrings and in the manual.
 
 	* IPython/Prompts.py (CachedOutput.set_colors): cleanups for
 	handling of caching. Set minimum acceptabe value for having a
 	cache at 20 values.
 
 	* IPython/iplib.py (InteractiveShell.user_setup): moved the
 	install_first_time function to a method, renamed it and added an
 	'upgrade' mode. Now people can update their config directory with
 	a simple command line switch (-upgrade, also new).
 
 	* IPython/Magic.py (Magic.magic_pfile): Made @pfile an alias to
 	@file (convenient for automagic users under Python >= 2.2). 
 	Removed @files (it seemed more like a plural than an abbrev. of
 	'file show').
 
 	* IPython/iplib.py (install_first_time): Fixed crash if there were
 	backup files ('~') in .ipython/ install directory.
 
 	* IPython/ipmaker.py (make_IPython): fixes for new prompt
 	system. Things look fine, but these changes are fairly
 	intrusive. Test them for a few days.
 
 	* IPython/Prompts.py (CachedOutput.__init__): Massive rewrite of
 	the prompts system. Now all in/out prompt strings are user
 	controllable. This is particularly useful for embedding, as one
 	can tag embedded instances with particular prompts. 
 
 	Also removed global use of sys.ps1/2, which now allows nested
 	embeddings without any problems. Added command-line options for
 	the prompt strings.
 
 2002-03-08  Fernando Perez  <[e-mail]>
 
 	* IPython/UserConfig/example-embed-short.py (ipshell): added
 	example file with the bare minimum code for embedding.
 
 	* IPython/Shell.py (IPythonShellEmbed.set_dummy_mode): added
 	functionality for the embeddable shell to be activated/deactivated
 	either globally or at each call.
 
 	* IPython/Prompts.py (Prompt1.auto_rewrite): Fixes the problem of
 	rewriting the prompt with '--->' for auto-inputs with proper
 	coloring. Now the previous UGLY hack in handle_auto() is gone, and
 	this is handled by the prompts class itself, as it should.
 
 2002-03-05  Fernando Perez  <[e-mail]>
 
 	* IPython/Magic.py (Magic.magic_logstart): Changed @log to
 	@logstart to avoid name clashes with the math log function.
 
 	* Big updates to X/Emacs section of the manual.
 
 	* Removed ipython_emacs. Milan explained to me how to pass
 	arguments to ipython through Emacs. Some day I'm going to end up
 	learning some lisp...
 
 2002-03-04  Fernando Perez  <[e-mail]>
 
 	* IPython/ipython_emacs: Created script to be used as the
 	py-python-command Emacs variable so we can pass IPython
 	parameters. I can't figure out how to tell Emacs directly to pass
 	parameters to IPython, so a dummy shell script will do it.
 
 	Other enhancements made for things to work better under Emacs'
 	various types of terminals. Many thanks to Milan Zamazal
 	<pdm-AT-zamazal.org> for all the suggestions and pointers.
 
 2002-03-01  Fernando Perez  <[e-mail]>
 
 	* IPython/ipmaker.py (make_IPython): added a --readline! option so
 	that loading of readline is now optional. This gives better
 	control to emacs users.
 
 	* IPython/ultraTB.py (__date__): Modified color escape sequences
 	and now things work fine under xterm and in Emacs' term buffers
 	(though not shell ones). Well,  in emacs you get colors, but all
 	seem to be 'light' colors (no difference between dark and light
 	ones). But the garbage chars are gone, and also in xterms. It
 	seems that now I'm using 'cleaner' ansi sequences.
 
 2002-02-21  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.7 (mainly to publish the scoping fix).
 	
 	* IPython/Logger.py (Logger.logstate): added. A corresponding
 	@logstate magic was created.
 
 	* IPython/Magic.py: fixed nested scoping problem under Python
 	2.1.x (automagic wasn't working).
 
 2002-02-20  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.6.
 
 	* IPython/OutputTrap.py (OutputTrap.__init__): added a 'quiet'
 	option so that logs can come out without any headers at all.
 
 	* IPython/UserConfig/ipythonrc-scipy.py: created a profile for
 	SciPy.
 
 	* IPython/iplib.py (InteractiveShell.embed_mainloop): Changed so
 	that embedded IPython calls don't require vars() to be explicitly
 	passed. Now they are extracted from the caller's frame (code
 	snatched from Eric Jones' weave). Added better documentation to
 	the section on embedding and the example file.
 
 	* IPython/genutils.py (page): Changed so that under emacs, it just
 	prints the string. You can then page up and down in the emacs
 	buffer itself. This is how the builtin help() works.
 
 	* IPython/Prompts.py (CachedOutput.__call__): Fixed issue with
 	macro scoping: macros need to be executed in the user's namespace
 	to work as if they had been typed by the user.
 
 	* IPython/Magic.py (Magic.magic_macro): Changed macros so they
 	execute automatically (no need to type 'exec...'). They then
 	behave like 'true macros'. The printing system was also modified
 	for this to work.
 
 2002-02-19  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (page_file): new function for paging files
 	in an OS-independent way. Also necessary for file viewing to work
 	well inside Emacs buffers.
 	(page): Added checks for being in an emacs buffer.
 	(page): fixed bug for Windows ($TERM isn't set in Windows). Fixed
 	same bug in iplib.
 
 2002-02-18  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.init_readline): modified use
 	of readline so that IPython can work inside an Emacs buffer.
 
 	* IPython/ultraTB.py (AutoFormattedTB.__call__): some fixes to
 	method signatures (they weren't really bugs, but it looks cleaner
 	and keeps PyChecker happy).
 
 	* IPython/ipmaker.py (make_IPython): added hooks Struct to __IP
 	for implementing various user-defined hooks. Currently only
 	display is done.
 
 	* IPython/Prompts.py (CachedOutput._display): changed display
 	functions so that they can be dynamically changed by users easily.
 
 	* IPython/Extensions/numeric_formats.py (num_display): added an
 	extension for printing NumPy arrays in flexible manners. It
 	doesn't do anything yet, but all the structure is in
 	place. Ultimately the plan is to implement output format control
 	like in Octave.
 
 	* IPython/Magic.py (Magic.lsmagic): changed so that bound magic
 	methods are found at run-time by all the automatic machinery.
 
 2002-02-17  Fernando Perez  <[e-mail]>
 
 	* setup_Windows.py (make_shortcut): documented. Cleaned up the
 	whole file a little.
 
 	* ToDo: closed this document. Now there's a new_design.lyx
 	document for all new ideas. Added making a pdf of it for the
 	end-user distro.
 
 	* IPython/Logger.py (Logger.switch_log): Created this to replace
 	logon() and logoff(). It also fixes a nasty crash reported by 
 	Philip Hisley <compsys-AT-starpower.net>. Many thanks to him.
 
 	* IPython/iplib.py (complete): got auto-completion to work with
 	automagic (I had wanted this for a long time).
 
 	* IPython/Magic.py (Magic.magic_files): Added @files as an alias
 	to @file, since file() is now a builtin and clashes with automagic
 	for @file.
 
 	* Made some new files: Prompts, CrashHandler, Magic, Logger. All
 	of this was previously in iplib, which had grown to more than 2000
 	lines, way too long. No new functionality, but it makes managing
 	the code a bit easier.
 
 	* IPython/iplib.py (IPythonCrashHandler.__call__): Added version
 	information to crash reports.
 
 2002-02-12  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.5.
 
 2002-02-11  Fernando Perez  <[e-mail]>
 
 	* Wrote a relatively complete Windows installer. It puts
 	everything in place, creates Start Menu entries and fixes the
 	color issues. Nothing fancy, but it works.
 
 2002-02-10  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.safe_execfile): added an
 	os.path.expanduser() call so that we can type @run ~/myfile.py and
 	have thigs work as expected.
 
 	* IPython/genutils.py (page): fixed exception handling so things
 	work both in Unix and Windows correctly. Quitting a pager triggers
 	an IOError/broken pipe in Unix, and in windows not finding a pager
 	is also an IOError, so I had to actually look at the return value
 	of the exception, not just the exception itself. Should be ok now.
 
 	* IPython/ultraTB.py (ColorSchemeTable.set_active_scheme):
 	modified to allow case-insensitive color scheme changes.
 
 2002-02-09  Fernando Perez  <[e-mail]>
 
 	* IPython/genutils.py (native_line_ends): new function to leave
 	user config files with os-native line-endings.
 
 	* README and manual updates.
 
 	* IPython/genutils.py: fixed unicode bug: use types.StringTypes
 	instead of StringType to catch Unicode strings.
 
 	* IPython/genutils.py (filefind): fixed bug for paths with
 	embedded spaces (very common in Windows).
 
 	* IPython/ipmaker.py (make_IPython): added a '.ini' to the rc
 	files under Windows, so that they get automatically associated
 	with a text editor. Windows makes it a pain to handle
 	extension-less files.
 
 	* IPython/iplib.py (InteractiveShell.init_readline): Made the
 	warning about readline only occur for Posix. In Windows there's no
 	way to get readline, so why bother with the warning.
 
 	* IPython/Struct.py (Struct.__str__): fixed to use self.__dict__
 	for __str__ instead of dir(self), since dir() changed in 2.2.
 
 	* Ported to Windows! Tested on XP, I suspect it should work fine
 	on NT/2000, but I don't think it will work on 98 et al. That
 	series of Windows is such a piece of junk anyway that I won't try
 	porting it there. The XP port was straightforward, showed a few
 	bugs here and there (fixed all), in particular some string
 	handling stuff which required considering Unicode strings (which
 	Windows uses). This is good, but hasn't been too tested :) No
 	fancy installer yet, I'll put a note in the manual so people at
 	least make manually a shortcut.
 
 	* IPython/iplib.py (Magic.magic_colors): Unified the color options
 	into a single one, "colors". This now controls both prompt and
 	exception color schemes, and can be changed both at startup
 	(either via command-line switches or via ipythonrc files) and at
 	runtime, with @colors.
 	(Magic.magic_run): renamed @prun to @run and removed the old
 	@run. The two were too similar to warrant keeping both.
 
 2002-02-03  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (install_first_time): Added comment on how to
 	configure the color options for first-time users. Put a <return>
 	request at the end so that small-terminal users get a chance to
 	read the startup info.
 
 2002-01-23  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (CachedOutput.update): Changed output memory
 	variable names from _o,_oo,_ooo,_o<n> to simply _,__,___,_<n>. For
 	input history we still use _i. Did this b/c these variable are
 	very commonly used in interactive work, so the less we need to
 	type the better off we are.
 	(Magic.magic_prun): updated @prun to better handle the namespaces
 	the file will run in, including a fix for __name__ not being set
 	before.
 
 2002-01-20  Fernando Perez  <[e-mail]>
 
 	* IPython/ultraTB.py (VerboseTB.linereader): Fixed printing of
 	extra garbage for Python 2.2. Need to look more carefully into
 	this later.
 
 2002-01-19  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.showtraceback): fixed to
 	display SyntaxError exceptions properly formatted when they occur
 	(they can be triggered by imported code).
 
 2002-01-18  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.safe_execfile): now
 	SyntaxError exceptions are reported nicely formatted, instead of
 	spitting out only offset information as before.
 	(Magic.magic_prun): Added the @prun function for executing
 	programs with command line args inside IPython.
 
 2002-01-16  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (Magic.magic_hist): Changed @hist and @dhist
 	to *not* include the last item given in a range. This brings their
 	behavior in line with Python's slicing: 
 	  a[n1:n2] -> a[n1]...a[n2-1]
 	It may be a bit less convenient, but I prefer to stick to Python's
 	conventions *everywhere*, so users never have to wonder.
 	(Magic.magic_macro): Added @macro function to ease the creation of
 	macros.
 
 2002-01-05  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.4.
 
 	* IPython/iplib.py (Magic.magic_pdef): 
 	(InteractiveShell.safe_execfile): report magic lines and error
 	lines without line numbers so one can easily copy/paste them for
 	re-execution.
 
 	* Updated manual with recent changes.
 
 	* IPython/iplib.py (Magic.magic_oinfo): added constructor
 	docstring printing when class? is called. Very handy for knowing
 	how to create class instances (as long as __init__ is well
 	documented, of course :)
 	(Magic.magic_doc): print both class and constructor docstrings.
 	(Magic.magic_pdef): give constructor info if passed a class and
 	__call__ info for callable object instances.
 
 2002-01-04  Fernando Perez  <[e-mail]>
 
 	* Made deep_reload() off by default. It doesn't always work
 	exactly as intended, so it's probably safer to have it off. It's
 	still available as dreload() anyway, so nothing is lost.
 
 2002-01-02  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.3 (contacted R.Singh at CU about biopython course,
 	so I wanted an updated release).
 
 2001-12-27  Fernando Perez  <[e-mail]>
 
 	* IPython/iplib.py (InteractiveShell.interact): Added the original
 	code from 'code.py' for this module in order to change the
 	handling of a KeyboardInterrupt. This was necessary b/c otherwise
 	the history cache would break when the user hit Ctrl-C, and
 	interact() offers no way to add any hooks to it.
 
 2001-12-23  Fernando Perez  <[e-mail]>
 
 	* setup.py: added check for 'MANIFEST' before trying to remove
 	it. Thanks to Sean Reifschneider.
 
 2001-12-22  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.2.
 
 	* Finished (reasonably) writing the manual. Later will add the
 	python-standard navigation stylesheets, but for the time being
 	it's fairly complete. Distribution will include html and pdf
 	versions.
 
 	* Bugfix: '.' wasn't being added to sys.path. Thanks to Prabhu
 	(MayaVi author).
 
 2001-12-21  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.1. Barring any nasty bugs, this is it as far as a
 	good public release, I think (with the manual and the distutils
 	installer). The manual can use some work, but that can go
 	slowly. Otherwise I think it's quite nice for end users. Next
 	summer, rewrite the guts of it...
 
 	* Changed format of ipythonrc files to use whitespace as the
 	separator instead of an explicit '='. Cleaner.
 
 2001-12-20  Fernando Perez  <[e-mail]>
 
 	* Started a manual in LyX. For now it's just a quick merge of the
 	various internal docstrings and READMEs. Later it may grow into a
 	nice, full-blown manual.
 
 	* Set up a distutils based installer. Installation should now be
 	trivially simple for end-users.
 
 2001-12-11  Fernando Perez  <[e-mail]>
 
 	* Released 0.2.0. First public release, announced it at
 	comp.lang.python. From now on, just bugfixes...
 
 	* Went through all the files, set copyright/license notices and
 	cleaned up things. Ready for release.
 
 2001-12-10  Fernando Perez  <[e-mail]>
 
 	* Changed the first-time installer not to use tarfiles. It's more
 	robust now and less unix-dependent. Also makes it easier for
 	people to later upgrade versions.
 
 	* Changed @exit to @abort to reflect the fact that it's pretty
 	brutal (a sys.exit()). The difference between @abort and Ctrl-D
 	becomes significant only when IPyhton is embedded: in that case,
 	C-D closes IPython only, but @abort kills the enclosing program
 	too (unless it had called IPython inside a try catching
 	SystemExit).
 
 	* Created Shell module which exposes the actuall IPython Shell
 	classes, currently the normal and the embeddable one. This at
 	least offers a stable interface we won't need to change when
 	(later) the internals are rewritten. That rewrite will be confined
 	to iplib and ipmaker, but the Shell interface should remain as is.
 
 	* Added embed module which offers an embeddable IPShell object,
 	useful to fire up IPython *inside* a running program. Great for
 	debugging or dynamical data analysis.
 
 2001-12-08  Fernando Perez  <[e-mail]>
 
 	* Fixed small bug preventing seeing info from methods of defined
 	objects (incorrect namespace in _ofind()).
 
 	* Documentation cleanup. Moved the main usage docstrings to a
 	separate file, usage.py (cleaner to maintain, and hopefully in the
 	future some perlpod-like way of producing interactive, man and
 	html docs out of it will be found).
 
 	* Added @profile to see your profile at any time.
 
 	* Added @p as an alias for 'print'. It's especially convenient if
 	using automagic ('p x' prints x).
 
 	* Small cleanups and fixes after a pychecker run.
 
 	* Changed the @cd command to handle @cd - and @cd -<n> for
 	visiting any directory in _dh.
 
 	* Introduced _dh, a history of visited directories. @dhist prints
 	it out with numbers.
 
 2001-12-07  Fernando Perez  <[e-mail]>
 
 	* Released 0.1.22
 
 	* Made initialization a bit more robust against invalid color
 	options in user input (exit, not traceback-crash).
 
 	* Changed the bug crash reporter to write the report only in the
 	user's .ipython directory. That way IPython won't litter people's
 	hard disks with crash files all over the place. Also print on
 	screen the necessary mail command.
 
 	* With the new ultraTB, implemented LightBG color scheme for light
 	background terminals. A lot of people like white backgrounds, so I
 	guess we should at least give them something readable.
 
 2001-12-06  Fernando Perez  <[e-mail]>
 
 	* Modified the structure of ultraTB. Now there's a proper class
 	for tables of color schemes which allow adding schemes easily and
 	switching the active scheme without creating a new instance every
 	time (which was ridiculous). The syntax for creating new schemes
 	is also cleaner. I think ultraTB is finally done, with a clean
 	class structure. Names are also much cleaner (now there's proper
 	color tables, no need for every variable to also have 'color' in
 	its name).
 
 	* Broke down genutils into separate files. Now genutils only
 	contains utility functions, and classes have been moved to their
 	own files (they had enough independent functionality to warrant
 	it): ConfigLoader, OutputTrap, Struct.
 
 2001-12-05  Fernando Perez  <[e-mail]>
 
 	* IPython turns 21! Released version 0.1.21, as a candidate for
 	public consumption. If all goes well, release in a few days.
 
 	* Fixed path bug (files in Extensions/ directory wouldn't be found
 	unless IPython/ was explicitly in sys.path).
 
 	* Extended the FlexCompleter class as MagicCompleter to allow
 	completion of @-starting lines.
 
 	* Created __release__.py file as a central repository for release
 	info that other files can read from.
 
 	* Fixed small bug in logging: when logging was turned on in
 	mid-session, old lines with special meanings (!@?) were being
 	logged without the prepended comment, which is necessary since
 	they are not truly valid python syntax. This should make session
 	restores produce less errors.
 
 	* The namespace cleanup forced me to make a FlexCompleter class
 	which is nothing but a ripoff of rlcompleter, but with selectable
 	namespace (rlcompleter only works in __main__.__dict__). I'll try
 	to submit a note to the authors to see if this change can be
 	incorporated in future rlcompleter releases (Dec.6: done)
 
 	* More fixes to namespace handling. It was a mess! Now all
 	explicit references to __main__.__dict__ are gone (except when
 	really needed) and everything is handled through the namespace
 	dicts in the IPython instance. We seem to be getting somewhere
 	with this, finally...
 
 	* Small documentation updates.
 
 	* Created the Extensions directory under IPython (with an
 	__init__.py). Put the PhysicalQ stuff there. This directory should
 	be used for all special-purpose extensions.
 
 	* File renaming:
 	  ipythonlib --> ipmaker
 	  ipplib     --> iplib
 	This makes a bit more sense in terms of what these files actually do.
 
 	* Moved all the classes and functions in ipythonlib to ipplib, so
 	now ipythonlib only has make_IPython(). This will ease up its
 	splitting in smaller functional chunks later.
 
 	* Cleaned up (done, I think) output of @whos. Better column
 	formatting, and now shows str(var) for as much as it can, which is
 	typically what one gets with a 'print var'.
 
 2001-12-04  Fernando Perez  <[e-mail]>
 
 	* Fixed namespace problems. Now builtin/IPyhton/user names get
 	properly reported in their namespace. Internal namespace handling
 	is finally getting decent (not perfect yet, but much better than
 	the ad-hoc mess we had).
 
 	* Removed -exit option. If people just want to run a python
 	script, that's what the normal interpreter is for. Less
 	unnecessary options, less chances for bugs.
 
 	* Added a crash handler which generates a complete post-mortem if
 	IPython crashes. This will help a lot in tracking bugs down the
 	road.
 
 	* Fixed nasty bug in auto-evaluation part of prefilter(). Names
 	which were boud to functions being reassigned would bypass the
 	logger, breaking the sync of _il with the prompt counter. This
 	would then crash IPython later when a new line was logged.
 
 2001-12-02  Fernando Perez  <[e-mail]>
 
 	* Made IPython a package. This means people don't have to clutter
 	their sys.path with yet another directory. Changed the INSTALL
 	file accordingly.
 
 	* Cleaned up the output of @who_ls, @who and @whos. @who_ls now
 	sorts its output (so @who shows it sorted) and @whos formats the
 	table according to the width of the first column. Nicer, easier to
 	read. Todo: write a generic table_format() which takes a list of
 	lists and prints it nicely formatted, with optional row/column
 	separators and proper padding and justification. 
 
 	* Released 0.1.20
 
 	* Fixed bug in @log which would reverse the inputcache list (a
 	copy operation was missing).
 
 	* Code cleanup. @config was changed to use page(). Better, since
 	its output is always quite long.
 
 	* Itpl is back as a dependency. I was having too many problems
 	getting the parametric aliases to work reliably, and it's just
 	easier to code weird string operations with it than playing %()s
 	games. It's only ~6k, so I don't think it's too big a deal.
 
 	* Found (and fixed) a very nasty bug with history. !lines weren't
 	getting cached, and the out of sync caches would crash
 	IPython. Fixed it by reorganizing the prefilter/handlers/logger
 	division of labor a bit better. Bug fixed, cleaner structure.
 
 2001-12-01  Fernando Perez  <[e-mail]>
 
 	* Released 0.1.19
 
 	* Added option -n to @hist to prevent line number printing. Much
 	easier to copy/paste code this way.
 
 	* Created global _il to hold the input list. Allows easy
 	re-execution of blocks of code by slicing it (inspired by Janko's
 	comment on 'macros').
 
 	* Small fixes and doc updates.
 
 	* Rewrote @history function (was @h). Renamed it to @hist, @h is
 	much too fragile with automagic. Handles properly multi-line
 	statements and takes parameters.
 
 2001-11-30  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.18 released.
 
 	* Fixed nasty namespace bug in initial module imports.
 
 	* Added copyright/license notes to all code files (except
 	DPyGetOpt). For the time being, LGPL. That could change.
 
 	* Rewrote a much nicer README, updated INSTALL, cleaned up
 	ipythonrc-* samples.
 
 	* Overall code/documentation cleanup. Basically ready for
 	release. Only remaining thing: licence decision (LGPL?).
 
 	* Converted load_config to a class, ConfigLoader. Now recursion
 	control is better organized. Doesn't include the same file twice.
 
 2001-11-29  Fernando Perez  <[e-mail]>
 
 	* Got input history working. Changed output history variables from
 	_p to _o so that _i is for input and _o for output. Just cleaner
 	convention.
 
 	* Implemented parametric aliases. This pretty much allows the
 	alias system to offer full-blown shell convenience, I think.
 
 	* Version 0.1.17 released, 0.1.18 opened.
 
 	* dot_ipython/ipythonrc (alias): added documentation.
 	(xcolor): Fixed small bug (xcolors -> xcolor)
 
 	* Changed the alias system. Now alias is a magic command to define
 	aliases just like the shell. Rationale: the builtin magics should
 	be there for things deeply connected to IPython's
 	architecture. And this is a much lighter system for what I think
 	is the really important feature: allowing users to define quickly
 	magics that will do shell things for them, so they can customize
 	IPython easily to match their work habits. If someone is really
 	desperate to have another name for a builtin alias, they can
 	always use __IP.magic_newname = __IP.magic_oldname. Hackish but
 	works.
 
 2001-11-28  Fernando Perez  <[e-mail]>
 
 	* Changed @file so that it opens the source file at the proper
 	line. Since it uses less, if your EDITOR environment is
 	configured, typing v will immediately open your editor of choice
 	right at the line where the object is defined. Not as quick as
 	having a direct @edit command, but for all intents and purposes it
 	works. And I don't have to worry about writing @edit to deal with
 	all the editors, less does that.
 
 	* Version 0.1.16 released, 0.1.17 opened.
 
 	* Fixed some nasty bugs in the page/page_dumb combo that could
 	crash IPython.
 
 2001-11-27  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.15 released, 0.1.16 opened.
 
 	* Finally got ? and ?? to work for undefined things: now it's
 	possible to type {}.get? and get information about the get method
 	of dicts, or os.path? even if only os is defined (so technically
 	os.path isn't). Works at any level. For example, after import os,
 	os?, os.path?, os.path.abspath? all work. This is great, took some
 	work in _ofind.
 
 	* Fixed more bugs with logging. The sanest way to do it was to add
 	to @log a 'mode' parameter. Killed two in one shot (this mode
 	option was a request of Janko's). I think it's finally clean
 	(famous last words).
 
 	* Added a page_dumb() pager which does a decent job of paging on
 	screen, if better things (like less) aren't available. One less
 	unix dependency (someday maybe somebody will port this to
 	windows).
 
 	* Fixed problem in magic_log: would lock of logging out if log
 	creation failed (because it would still think it had succeeded).
 
 	* Improved the page() function using curses to auto-detect screen
 	size. Now it can make a much better decision on whether to print
 	or page a string. Option screen_length was modified: a value 0
 	means auto-detect, and that's the default now.
 
 	* Version 0.1.14 released, 0.1.15 opened. I think this is ready to
 	go out. I'll test it for a few days, then talk to Janko about
 	licences and announce it.
 
 	* Fixed the length of the auto-generated ---> prompt which appears
 	for auto-parens and auto-quotes. Getting this right isn't trivial,
 	with all the color escapes, different prompt types and optional
 	separators. But it seems to be working in all the combinations.
 
 2001-11-26  Fernando Perez  <[e-mail]>
 
 	* Wrote a regexp filter to get option types from the option names
 	string. This eliminates the need to manually keep two duplicate
 	lists.
 
 	* Removed the unneeded check_option_names. Now options are handled
 	in a much saner manner and it's easy to visually check that things
 	are ok.
 
 	* Updated version numbers on all files I modified to carry a
 	notice so Janko and Nathan have clear version markers.
 
 	* Updated docstring for ultraTB with my changes. I should send
 	this to Nathan.
 
 	* Lots of small fixes. Ran everything through pychecker again.
 
 	* Made loading of deep_reload an cmd line option. If it's not too
 	kosher, now people can just disable it. With -nodeep_reload it's
 	still available as dreload(), it just won't overwrite reload().
 
 	* Moved many options to the no| form (-opt and -noopt
 	accepted). Cleaner.
 
 	* Changed magic_log so that if called with no parameters, it uses
 	'rotate' mode. That way auto-generated logs aren't automatically
 	over-written. For normal logs, now a backup is made if it exists
 	(only 1 level of backups). A new 'backup' mode was added to the
 	Logger class to support this. This was a request by Janko.
 
 	* Added @logoff/@logon to stop/restart an active log.
 
 	* Fixed a lot of bugs in log saving/replay. It was pretty
 	broken. Now special lines (!@,/) appear properly in the command
 	history after a log replay.
 
 	* Tried and failed to implement full session saving via pickle. My
 	idea was to pickle __main__.__dict__, but modules can't be
 	pickled. This would be a better alternative to replaying logs, but
 	seems quite tricky to get to work. Changed -session to be called
 	-logplay, which more accurately reflects what it does. And if we
 	ever get real session saving working, -session is now available.
 
 	* Implemented color schemes for prompts also. As for tracebacks,
 	currently only NoColor and Linux are supported. But now the
 	infrastructure is in place, based on a generic ColorScheme
 	class. So writing and activating new schemes both for the prompts
 	and the tracebacks should be straightforward.
 
 	* Version 0.1.13 released, 0.1.14 opened.
 
 	* Changed handling of options for output cache. Now counter is
 	hardwired starting at 1 and one specifies the maximum number of
 	entries *in the outcache* (not the max prompt counter). This is
 	much better, since many statements won't increase the cache
 	count. It also eliminated some confusing options, now there's only
 	one: cache_size.
 
 	* Added 'alias' magic function and magic_alias option in the
 	ipythonrc file. Now the user can easily define whatever names he
 	wants for the magic functions without having to play weird
 	namespace games. This gives IPython a real shell-like feel.
 
 	* Fixed doc/?/?? for magics. Now all work, in all forms (explicit
 	@ or not).
 
 	This was one of the last remaining 'visible' bugs (that I know
 	of). I think if I can clean up the session loading so it works
 	100% I'll release a 0.2.0 version on c.p.l (talk to Janko first
 	about licensing).	
 
 2001-11-25  Fernando Perez  <[e-mail]>
 
 	* Rewrote somewhat oinfo (?/??). Nicer, now uses page() and
 	there's a cleaner distinction between what ? and ?? show.
 
 	* Added screen_length option. Now the user can define his own
 	screen size for page() operations.
 
 	* Implemented magic shell-like functions with automatic code
 	generation. Now adding another function is just a matter of adding
 	an entry to a dict, and the function is dynamically generated at
 	run-time. Python has some really cool features!
 
 	* Renamed many options to cleanup conventions a little. Now all
 	are lowercase, and only underscores where needed. Also in the code
 	option name tables are clearer.
 
 	* Changed prompts a little. Now input is 'In [n]:' instead of
 	'In[n]:='. This allows it the numbers to be aligned with the
 	Out[n] numbers, and removes usage of ':=' which doesn't exist in
 	Python (it was a Mathematica thing). The '...' continuation prompt
 	was also changed a little to align better.
 
 	* Fixed bug when flushing output cache. Not all _p<n> variables
 	exist, so their deletion needs to be wrapped in a try:
 
 	* Figured out how to properly use inspect.formatargspec() (it
 	requires the args preceded by *). So I removed all the code from
 	_get_pdef in Magic, which was just replicating that.
 
 	* Added test to prefilter to allow redefining magic function names
 	as variables. This is ok, since the @ form is always available,
 	but whe should allow the user to define a variable called 'ls' if
 	he needs it.
 
 	* Moved the ToDo information from README into a separate ToDo.
 
 	* General code cleanup and small bugfixes. I think it's close to a
 	state where it can be released, obviously with a big 'beta'
 	warning on it.
 
 	* Got the magic function split to work. Now all magics are defined
 	in a separate class. It just organizes things a bit, and now
 	Xemacs behaves nicer (it was choking on InteractiveShell b/c it
 	was too long).
 
 	* Changed @clear to @reset to avoid potential confusions with
 	the shell command clear. Also renamed @cl to @clear, which does
 	exactly what people expect it to from their shell experience.
 
 	Added a check to the @reset command (since it's so
 	destructive, it's probably a good idea to ask for confirmation).
 	But now reset only works for full namespace resetting. Since the
 	del keyword is already there for deleting a few specific
 	variables, I don't see the point of having a redundant magic
 	function for the same task.
 
 2001-11-24  Fernando Perez  <[e-mail]>
 
 	* Updated the builtin docs (esp. the ? ones).
 
 	* Ran all the code through pychecker. Not terribly impressed with
 	it: lots of spurious warnings and didn't really find anything of
 	substance (just a few modules being imported and not used).
 
 	* Implemented the new ultraTB functionality into IPython. New
 	option: xcolors. This chooses color scheme. xmode now only selects
 	between Plain and Verbose. Better orthogonality.
 
 	* Large rewrite of ultraTB. Much cleaner now, with a separation of
 	mode and color scheme for the exception handlers. Now it's
 	possible to have the verbose traceback with no coloring.
 
 2001-11-23  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.12 released, 0.1.13 opened.
 
 	* Removed option to set auto-quote and auto-paren escapes by
 	user. The chances of breaking valid syntax are just too high. If
 	someone *really* wants, they can always dig into the code.
 
 	* Made prompt separators configurable.
 
 2001-11-22  Fernando Perez  <[e-mail]>
 
 	* Small bugfixes in many places.
 
 	* Removed the MyCompleter class from ipplib. It seemed redundant
 	with the C-p,C-n history search functionality. Less code to
 	maintain.
 
 	* Moved all the original ipython.py code into ipythonlib.py. Right
 	now it's just one big dump into a function called make_IPython, so
 	no real modularity has been gained. But at least it makes the
 	wrapper script tiny, and since ipythonlib is a module, it gets
 	compiled and startup is much faster.
 
 	This is a reasobably 'deep' change, so we should test it for a
 	while without messing too much more with the code.
 
 2001-11-21  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.11 released, 0.1.12 opened for further work.
 
 	* Removed dependency on Itpl. It was only needed in one place. It
 	would be nice if this became part of python, though. It makes life
 	*a lot* easier in some cases.
 
 	* Simplified the prefilter code a bit. Now all handlers are
 	expected to explicitly return a value (at least a blank string).
 
 	* Heavy edits in ipplib. Removed the help system altogether. Now
 	obj?/?? is used for inspecting objects, a magic @doc prints
 	docstrings, and full-blown Python help is accessed via the 'help'
 	keyword. This cleans up a lot of code (less to maintain) and does
 	the job. Since 'help' is now a standard Python component, might as
 	well use it and remove duplicate functionality.
 
 	Also removed the option to use ipplib as a standalone program. By
 	now it's too dependent on other parts of IPython to function alone.
 
 	* Fixed bug in genutils.pager. It would crash if the pager was
 	exited immediately after opening (broken pipe).
 
 	* Trimmed down the VerboseTB reporting a little. The header is
 	much shorter now and the repeated exception arguments at the end
 	have been removed. For interactive use the old header seemed a bit
 	excessive.
 
 	* Fixed small bug in output of @whos for variables with multi-word
 	types (only first word was displayed).
 
 2001-11-17  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.10 released, 0.1.11 opened for further work.
 
 	* Modified dirs and friends. dirs now *returns* the stack (not
 	prints), so one can manipulate it as a variable. Convenient to
 	travel along many directories.
 
 	* Fixed bug in magic_pdef: would only work with functions with
 	arguments with default values.
 
 2001-11-14  Fernando Perez  <[e-mail]>
 
 	* Added the PhysicsInput stuff to dot_ipython so it ships as an
 	example with IPython. Various other minor fixes and cleanups.
 
 	* Version 0.1.9 released, 0.1.10 opened for further work.
 
 	* Added sys.path to the list of directories searched in the
 	execfile= option. It used to be the current directory and the
 	user's IPYTHONDIR only.
 
 2001-11-13  Fernando Perez  <[e-mail]>
 
 	* Reinstated the raw_input/prefilter separation that Janko had
 	initially. This gives a more convenient setup for extending the
 	pre-processor from the outside: raw_input always gets a string,
 	and prefilter has to process it. We can then redefine prefilter
 	from the outside and implement extensions for special
 	purposes.
 
 	Today I got one for inputting PhysicalQuantity objects
 	(from Scientific) without needing any function calls at
 	all. Extremely convenient, and it's all done as a user-level
 	extension (no IPython code was touched). Now instead of:
 		a = PhysicalQuantity(4.2,'m/s**2')
 	one can simply say
 		a = 4.2 m/s**2
 	or even
 		a = 4.2 m/s^2
 	
 	I use this, but it's also a proof of concept: IPython really is
 	fully user-extensible, even at the level of the parsing of the
 	command line. It's not trivial, but it's perfectly doable.
 
 	* Added 'add_flip' method to inclusion conflict resolver. Fixes
 	the problem of modules being loaded in the inverse order in which
 	they were defined in 
 
 	* Version 0.1.8 released, 0.1.9 opened for further work.
 
 	* Added magics pdef, source and file. They respectively show the
 	definition line ('prototype' in C), source code and full python
 	file for any callable object. The object inspector oinfo uses
 	these to show the same information.
 
 	* Version 0.1.7 released, 0.1.8 opened for further work.
 
 	* Separated all the magic functions into a class called Magic. The
 	InteractiveShell class was becoming too big for Xemacs to handle
 	(de-indenting a line would lock it up for 10 seconds while it
 	backtracked on the whole class!)
 
 	FIXME: didn't work. It can be done, but right now namespaces are
 	all messed up. Do it later (reverted it for now, so at least
 	everything works as before).
 
 	* Got the object introspection system (magic_oinfo) working! I
 	think this is pretty much ready for release to Janko, so he can
 	test it for a while and then announce it. Pretty much 100% of what
 	I wanted for the 'phase 1' release is ready. Happy, tired.
 
 2001-11-12  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.6 released, 0.1.7 opened for further work.
 
 	* Fixed bug in printing: it used to test for truth before
 	printing, so 0 wouldn't print. Now checks for None.
 
 	* Fixed bug where auto-execs increase the prompt counter by 2 (b/c
 	they have to call len(str(sys.ps1)) ). But the fix is ugly, it
 	reaches by hand into the outputcache. Think of a better way to do
 	this later.
 
 	* Various small fixes thanks to Nathan's comments.
 
 	* Changed magic_pprint to magic_Pprint. This way it doesn't
 	collide with pprint() and the name is consistent with the command
 	line option.
 
 	* Changed prompt counter behavior to be fully like
 	Mathematica's. That is, even input that doesn't return a result
 	raises the prompt counter. The old behavior was kind of confusing
 	(getting the same prompt number several times if the operation
 	didn't return a result).
 
 	* Fixed Nathan's last name in a couple of places (Gray, not Graham).
 
 	* Fixed -Classic mode (wasn't working anymore).
 
 	* Added colored prompts using Nathan's new code. Colors are
 	currently hardwired, they can be user-configurable. For
 	developers, they can be chosen in file ipythonlib.py, at the
 	beginning of the CachedOutput class def.
 
 2001-11-11  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.5 released, 0.1.6 opened for further work.
 
 	* Changed magic_env to *return* the environment as a dict (not to
 	print it). This way it prints, but it can also be processed.
 
 	* Added Verbose exception reporting to interactive
 	exceptions. Very nice, now even 1/0 at the prompt gives a verbose
 	traceback. Had to make some changes to the ultraTB file. This is
 	probably the last 'big' thing in my mental todo list.  This ties
 	in with the next entry:
 
 	* Changed -Xi and -Xf to a single -xmode option. Now all the user
 	has to specify is Plain, Color or Verbose for all exception
 	handling.
 
 	* Removed ShellServices option. All this can really be done via
 	the magic system. It's easier to extend, cleaner and has automatic
 	namespace protection and documentation.
 
 2001-11-09  Fernando Perez  <[e-mail]>
 
 	* Fixed bug in output cache flushing (missing parameter to
 	__init__). Other small bugs fixed (found using pychecker).
 
 	* Version 0.1.4 opened for bugfixing.
 
 2001-11-07  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.3 released, mainly because of the raw_input bug.
 
 	* Fixed NASTY bug in raw_input: input line wasn't properly parsed
 	and when testing for whether things were callable, a call could
 	actually be made to certain functions. They would get called again
 	once 'really' executed, with a resulting double call. A disaster
 	in many cases (list.reverse() would never work!).
 
 	* Removed prefilter() function, moved its code to raw_input (which
 	after all was just a near-empty caller for prefilter). This saves
 	a function call on every prompt, and simplifies the class a tiny bit.
 
 	* Fix _ip to __ip name in magic example file.
 
 	* Changed 'tar -x -f' to 'tar xvf' in auto-installer. This should
 	work with non-gnu versions of tar.
 
 2001-11-06  Fernando Perez  <[e-mail]>
 
 	* Version 0.1.2. Just to keep track of the recent changes.
 
 	* Fixed nasty bug in output prompt routine. It used to check 'if
 	arg != None...'. Problem is, this fails if arg implements a
 	special comparison (__cmp__) which disallows comparing to
 	None. Found it when trying to use the PhysicalQuantity module from
 	ScientificPython.
 
 2001-11-05  Fernando Perez  <[e-mail]>
 
 	* Also added dirs. Now the pushd/popd/dirs family functions
 	basically like the shell, with the added convenience of going home
 	when called with no args.
 
 	* pushd/popd slightly modified to mimic shell behavior more
 	closely.
 
 	* Added env,pushd,popd from ShellServices as magic functions. I
 	think the cleanest will be to port all desired functions from
 	ShellServices as magics and remove ShellServices altogether. This
 	will provide a single, clean way of adding functionality
 	(shell-type or otherwise) to IP.
 
 2001-11-04  Fernando Perez  <[e-mail]>
 
 	* Added .ipython/ directory to sys.path. This way users can keep
 	customizations there and access them via import.
 
 2001-11-03  Fernando Perez  <[e-mail]>
 
 	* Opened version 0.1.1 for new changes.
 
 	* Changed version number to 0.1.0: first 'public' release, sent to
 	Nathan and Janko.
 
 	* Lots of small fixes and tweaks.
 
 	* Minor changes to whos format. Now strings are shown, snipped if
 	too long.
 
 	* Changed ShellServices to work on __main__ so they show up in @who
 
 	* Help also works with ? at the end of a line:
 		?sin and sin?
 	both produce the same effect. This is nice, as often I use the
 	tab-complete to find the name of a method, but I used to then have
 	to go to the beginning of the line to put a ? if I wanted more
 	info. Now I can just add the ? and hit return. Convenient.
 
 2001-11-02  Fernando Perez  <[e-mail]>
 
 	* Python version check (>=2.1) added.
 
 	* Added LazyPython documentation. At this point the docs are quite
 	a mess. A cleanup is in order.
 
 	* Auto-installer created. For some bizarre reason, the zipfiles
 	module isn't working on my system. So I made a tar version
 	(hopefully the command line options in various systems won't kill
 	me).
 
 	* Fixes to Struct in genutils. Now all dictionary-like methods are
 	protected (reasonably).
 
 	* Added pager function to genutils and changed ? to print usage
 	note through it (it was too long).
 
 	* Added the LazyPython functionality. Works great! I changed the
 	auto-quote escape to ';', it's on home row and next to '. But
 	both auto-quote and auto-paren (still /) escapes are command-line
 	parameters.
 	
 
 2001-11-01  Fernando Perez  <[e-mail]>
 
 	* Version changed to 0.0.7. Fairly large change: configuration now
 	is all stored in a directory, by default .ipython. There, all
 	config files have normal looking names (not .names)
 
 	* Version 0.0.6 Released first to Lucas and Archie as a test
 	run. Since it's the first 'semi-public' release, change version to
 	> 0.0.6 for any changes now.
 
 	* Stuff I had put in the ipplib.py changelog:
 	
 	Changes to InteractiveShell:
 	
 	- Made the usage message a parameter.
 	
 	- Require the name of the shell variable to be given. It's a bit
 	of a hack, but allows the name 'shell' not to be hardwired in the
 	magic (@) handler, which is problematic b/c it requires
 	polluting the global namespace with 'shell'. This in turn is
 	fragile: if a user redefines a variable called shell, things
 	break.
 
 	- magic @: all functions available through @ need to be defined
 	as magic_<name>, even though they can be called simply as
 	@<name>. This allows the special command @magic to gather
 	information automatically about all existing magic functions,
 	even if they are run-time user extensions, by parsing the shell
 	instance __dict__ looking for special magic_ names.
 
 	- mainloop: added *two* local namespace parameters. This allows
 	the class to differentiate between parameters which were there
 	before and after command line initialization was processed. This
 	way, later @who can show things loaded at startup by the
 	user. This trick was necessary to make session saving/reloading
 	really work: ideally after saving/exiting/reloading a session,
 	*everything* should look the same, including the output of @who. I
 	was only able to make this work with this double namespace
 	trick.
 
 	- added a header to the logfile which allows (almost) full
 	session restoring.
 
 	- prepend lines beginning with @ or !, with a and log
 	them. Why?  !lines: may be useful to know what you did @lines:
 	they may affect session state. So when restoring a session, at
 	least inform the user of their presence. I couldn't quite get
 	them to properly re-execute, but at least the user is warned.
 
 	* Started ChangeLog.