From 2f09c2ab3c6929cc9fa266fe666d312643264823 2008-02-16 09:50:47
From: ville <ville@VILLE-PC>
Date: 2008-02-16 09:50:47
Subject: [PATCH] initialization (no svn history)

---

diff --git a/.hgignore b/.hgignore
new file mode 100644
index 0000000..ecc75a2
--- /dev/null
+++ b/.hgignore
@@ -0,0 +1,18 @@
+syntax: glob
+
+*~
+*.tmp
+*.pyc
+*.bak
+*.tgz
+*.org
+*.rej
+.svn/
+.bzr/
+.settings/
+.project
+*.diff
+IPython_crash_report.txt
+
+syntax: regexp
+.*\#.*\#$
diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 0000000..c1db38b
--- /dev/null
+++ b/ChangeLog
@@ -0,0 +1 @@
+link doc/ChangeLog
\ No newline at end of file
diff --git a/IPython/ColorANSI.py b/IPython/ColorANSI.py
new file mode 100644
index 0000000..780e9e9
--- /dev/null
+++ b/IPython/ColorANSI.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+"""Tools for coloring text in ANSI terminals.
+
+$Id: ColorANSI.py 2167 2007-03-21 06:57:50Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2002-2006 Fernando Perez. <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+__all__ = ['TermColors','InputTermColors','ColorScheme','ColorSchemeTable']
+
+import os
+
+from IPython.ipstruct import Struct
+
+def make_color_table(in_class):
+    """Build a set of color attributes in a class.
+
+    Helper function for building the *TermColors classes."""
+    
+    color_templates = (
+        ("Black"       , "0;30"),
+        ("Red"         , "0;31"),
+        ("Green"       , "0;32"),
+        ("Brown"       , "0;33"),
+        ("Blue"        , "0;34"),
+        ("Purple"      , "0;35"),
+        ("Cyan"        , "0;36"),
+        ("LightGray"   , "0;37"),
+        ("DarkGray"    , "1;30"),
+        ("LightRed"    , "1;31"),
+        ("LightGreen"  , "1;32"),
+        ("Yellow"      , "1;33"),
+        ("LightBlue"   , "1;34"),
+        ("LightPurple" , "1;35"),
+        ("LightCyan"   , "1;36"),
+        ("White"       , "1;37"),  )
+
+    for name,value in color_templates:
+        setattr(in_class,name,in_class._base % value)
+
+class TermColors:
+    """Color escape sequences.
+
+    This class defines the escape sequences for all the standard (ANSI?) 
+    colors in terminals. Also defines a NoColor escape which is just the null
+    string, suitable for defining 'dummy' color schemes in terminals which get
+    confused by color escapes.
+
+    This class should be used as a mixin for building color schemes."""
+    
+    NoColor = ''  # for color schemes in color-less terminals.
+    Normal = '\033[0m'   # Reset normal coloring
+    _base  = '\033[%sm'  # Template for all other colors
+
+# Build the actual color table as a set of class attributes:
+make_color_table(TermColors)
+
+class InputTermColors:
+    """Color escape sequences for input prompts.
+
+    This class is similar to TermColors, but the escapes are wrapped in \001
+    and \002 so that readline can properly know the length of each line and
+    can wrap lines accordingly.  Use this class for any colored text which
+    needs to be used in input prompts, such as in calls to raw_input().
+
+    This class defines the escape sequences for all the standard (ANSI?) 
+    colors in terminals. Also defines a NoColor escape which is just the null
+    string, suitable for defining 'dummy' color schemes in terminals which get
+    confused by color escapes.
+
+    This class should be used as a mixin for building color schemes."""
+    
+    NoColor = ''  # for color schemes in color-less terminals.
+
+    if os.name == 'nt' and os.environ.get('TERM','dumb') == 'emacs':
+        # (X)emacs on W32 gets confused with \001 and \002 so we remove them
+        Normal = '\033[0m'   # Reset normal coloring
+        _base  = '\033[%sm'  # Template for all other colors
+    else:
+        Normal = '\001\033[0m\002'   # Reset normal coloring
+        _base  = '\001\033[%sm\002'  # Template for all other colors
+
+# Build the actual color table as a set of class attributes:
+make_color_table(InputTermColors)
+
+class ColorScheme:
+    """Generic color scheme class. Just a name and a Struct."""
+    def __init__(self,__scheme_name_,colordict=None,**colormap):
+        self.name = __scheme_name_
+        if colordict is None:
+            self.colors = Struct(**colormap)
+        else:
+            self.colors = Struct(colordict)
+
+    def copy(self,name=None):
+        """Return a full copy of the object, optionally renaming it."""
+        if name is None:
+            name = self.name
+        return ColorScheme(name,self.colors.__dict__)
+        
+class ColorSchemeTable(dict):
+    """General class to handle tables of color schemes.
+
+    It's basically a dict of color schemes with a couple of shorthand
+    attributes and some convenient methods.
+    
+    active_scheme_name -> obvious
+    active_colors -> actual color table of the active scheme"""
+
+    def __init__(self,scheme_list=None,default_scheme=''):
+        """Create a table of color schemes.
+
+        The table can be created empty and manually filled or it can be
+        created with a list of valid color schemes AND the specification for
+        the default active scheme.
+        """
+        
+        # create object attributes to be set later
+        self.active_scheme_name = ''
+        self.active_colors = None
+        
+        if scheme_list:
+            if default_scheme == '':
+                raise ValueError,'you must specify the default color scheme'
+            for scheme in scheme_list:
+                self.add_scheme(scheme)
+            self.set_active_scheme(default_scheme)
+
+    def copy(self):
+        """Return full copy of object"""
+        return ColorSchemeTable(self.values(),self.active_scheme_name)
+
+    def add_scheme(self,new_scheme):
+        """Add a new color scheme to the table."""
+        if not isinstance(new_scheme,ColorScheme):
+            raise ValueError,'ColorSchemeTable only accepts ColorScheme instances'
+        self[new_scheme.name] = new_scheme
+        
+    def set_active_scheme(self,scheme,case_sensitive=0):
+        """Set the currently active scheme.
+
+        Names are by default compared in a case-insensitive way, but this can
+        be changed by setting the parameter case_sensitive to true."""
+
+        scheme_names = self.keys()
+        if case_sensitive:
+            valid_schemes = scheme_names
+            scheme_test = scheme
+        else:
+            valid_schemes = [s.lower() for s in scheme_names]
+            scheme_test = scheme.lower()
+        try:
+            scheme_idx = valid_schemes.index(scheme_test)
+        except ValueError:
+            raise ValueError,'Unrecognized color scheme: ' + scheme + \
+                  '\nValid schemes: '+str(scheme_names).replace("'', ",'')
+        else:
+            active = scheme_names[scheme_idx]
+            self.active_scheme_name = active
+            self.active_colors = self[active].colors
+            # Now allow using '' as an index for the current active scheme
+            self[''] = self[active]
diff --git a/IPython/ConfigLoader.py b/IPython/ConfigLoader.py
new file mode 100644
index 0000000..10a245a
--- /dev/null
+++ b/IPython/ConfigLoader.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+"""Configuration loader
+
+$Id: ConfigLoader.py 1005 2006-01-12 08:39:26Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+import exceptions
+import os
+from pprint import pprint
+
+from IPython import ultraTB
+from IPython.ipstruct import Struct
+from IPython.genutils import *
+
+class ConfigLoaderError(exceptions.Exception):
+    """Exception for ConfigLoader class."""
+
+    def __init__(self,args=None):
+        self.args = args
+
+class ConfigLoader:
+
+    """Configuration file loader capable of handling recursive inclusions and
+    with parametrized conflict resolution for multiply found keys."""
+
+    def __init__(self,conflict=None,field_sep=None,reclimit=15):
+
+        """The reclimit parameter controls the number of recursive
+        configuration file inclusions. This way we can stop early on (before
+        python's own recursion limit is hit) if there is a circular
+        inclusion.
+
+        - conflict: dictionary for conflict resolutions (see Struct.merge())
+
+        """
+        self.conflict = conflict
+        self.field_sep = field_sep
+        self.reset(reclimit)
+        
+    def reset(self,reclimit=15):
+        self.reclimit = reclimit
+        self.recdepth = 0
+        self.included = []
+        
+    def load(self,fname,convert=None,recurse_key='',incpath = '.',**kw):
+        """Load a configuration file, return the resulting Struct.
+
+        Call: load_config(fname,convert=None,conflict=None,recurse_key='')
+
+         - fname: file to load from.
+         - convert: dictionary of type conversions (see read_dict())
+         - recurse_key: keyword in dictionary to trigger recursive file
+         inclusions.
+         """
+
+        if self.recdepth > self.reclimit:
+            raise ConfigLoaderError, 'maximum recursive inclusion of rcfiles '+\
+                  'exceeded: ' + `self.recdepth` + \
+                  '.\nMaybe you have a circular chain of inclusions?'
+        self.recdepth += 1
+        fname = filefind(fname,incpath)
+        data = Struct()
+        # avoid including the same file more than once
+        if fname in self.included:
+            return data
+        Xinfo = ultraTB.AutoFormattedTB()
+        if convert==None and recurse_key : convert = {qwflat:recurse_key}
+        # for production, change warn to 0:
+        data.merge(read_dict(fname,convert,fs=self.field_sep,strip=1,
+                             warn=0,no_empty=0,**kw))
+        # keep track of successfully loaded files
+        self.included.append(fname)
+        if recurse_key in data.keys():
+            for incfilename in data[recurse_key]:
+                found=0
+                try:
+                    incfile = filefind(incfilename,incpath)
+                except IOError:
+                    if os.name in ['nt','dos']:
+                        try:
+                            # Try again with '.ini' extension
+                            incfilename += '.ini'
+                            incfile = filefind(incfilename,incpath)
+                        except IOError:
+                            found = 0
+                        else:
+                            found = 1
+                    else:
+                        found = 0
+                else:
+                    found = 1
+                if found:
+                    try:
+                        data.merge(self.load(incfile,convert,recurse_key,
+                                             incpath,**kw),
+                                   self.conflict)
+                    except:
+                        Xinfo()
+                        warn('Problem loading included file: '+
+                             `incfilename` + '. Ignoring it...')
+                else:
+                    warn('File `%s` not found. Included by %s' % (incfilename,fname))
+
+        return data
+
+# end ConfigLoader
diff --git a/IPython/CrashHandler.py b/IPython/CrashHandler.py
new file mode 100644
index 0000000..4cb6cb7
--- /dev/null
+++ b/IPython/CrashHandler.py
@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+"""sys.excepthook for IPython itself, leaves a detailed report on disk.
+
+$Id: CrashHandler.py 2908 2007-12-30 21:07:46Z vivainio $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__   = '%s <%s>' % Release.authors['Fernando']
+__license__  = Release.license
+__version__  = Release.version
+
+#****************************************************************************
+# Required modules
+
+# From the standard library
+import os
+import sys
+from pprint import pprint,pformat
+
+# Homebrewed
+from IPython.Itpl import Itpl,itpl,printpl
+from IPython.ColorANSI import ColorScheme,ColorSchemeTable  # too long names
+from IPython import ultraTB
+from IPython.genutils import *
+
+#****************************************************************************
+class CrashHandler:
+    """Customizable crash handlers for IPython-based systems.
+
+    Instances of this class provide a __call__ method which can be used as a
+    sys.excepthook, i.e., the __call__ signature is:
+
+        def __call__(self,etype, evalue, etb)
+
+    """
+
+    def __init__(self,IP,app_name,contact_name,contact_email,
+                 bug_tracker,crash_report_fname,
+                 show_crash_traceback=True):
+        """New crash handler.
+
+        Inputs:
+
+        - IP: a running IPython instance, which will be queried at crash time
+        for internal information.
+
+        - app_name: a string containing the name of your application.
+
+        - contact_name: a string with the name of the person to contact.
+
+        - contact_email: a string with the email address of the contact.
+
+        - bug_tracker: a string with the URL for your project's bug tracker.
+
+        - crash_report_fname: a string with the filename for the crash report
+        to be saved in.  These reports are left in the ipython user directory
+        as determined by the running IPython instance.
+
+        Optional inputs:
+        
+        - show_crash_traceback(True): if false, don't print the crash
+        traceback on stderr, only generate the on-disk report
+
+
+        Non-argument instance attributes:
+
+        These instances contain some non-argument attributes which allow for 
+        further customization of the crash handler's behavior.  Please see the
+        source for further details.
+        """
+
+        # apply args into instance
+        self.IP = IP  # IPython instance
+        self.app_name = app_name
+        self.contact_name = contact_name
+        self.contact_email = contact_email
+        self.bug_tracker = bug_tracker
+        self.crash_report_fname = crash_report_fname
+        self.show_crash_traceback = show_crash_traceback
+        
+        # Hardcoded defaults, which can be overridden either by subclasses or
+        # at runtime for the instance.
+
+        # Template for the user message.  Subclasses which completely override
+        # this, or user apps, can modify it to suit their tastes.  It gets
+        # expanded using itpl, so calls of the kind $self.foo are valid.
+        self.user_message_template = """
+Oops, $self.app_name crashed. We do our best to make it stable, but...
+
+A crash report was automatically generated with the following information:
+  - A verbatim copy of the crash traceback.
+  - A copy of your input history during this session.
+  - Data on your current $self.app_name configuration.
+
+It was left in the file named:
+\t'$self.crash_report_fname'
+If you can email this file to the developers, the information in it will help
+them in understanding and correcting the problem.
+
+You can mail it to: $self.contact_name at $self.contact_email
+with the subject '$self.app_name Crash Report'.
+
+If you want to do it now, the following command will work (under Unix):
+mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
+
+To ensure accurate tracking of this issue, please file a report about it at:
+$self.bug_tracker
+"""
+
+    def __call__(self,etype, evalue, etb):
+        """Handle an exception, call for compatible with sys.excepthook"""
+
+        # Report tracebacks shouldn't use color in general (safer for users)
+        color_scheme = 'NoColor'
+
+        # Use this ONLY for developer debugging (keep commented out for release)
+        #color_scheme = 'Linux'   # dbg
+        
+        try:
+            rptdir = self.IP.rc.ipythondir
+        except:
+            rptdir = os.getcwd()
+        if not os.path.isdir(rptdir):
+            rptdir = os.getcwd()
+        report_name = os.path.join(rptdir,self.crash_report_fname)
+        # write the report filename into the instance dict so it can get
+        # properly expanded out in the user message template
+        self.crash_report_fname = report_name
+        TBhandler = ultraTB.VerboseTB(color_scheme=color_scheme,
+                                           long_header=1)
+        traceback = TBhandler.text(etype,evalue,etb,context=31)
+
+        # print traceback to screen
+        if self.show_crash_traceback:
+            print >> sys.stderr, traceback
+
+        # and generate a complete report on disk
+        try:
+            report = open(report_name,'w')
+        except:
+            print >> sys.stderr, 'Could not create crash report on disk.'
+            return
+
+        # Inform user on stderr of what happened
+        msg = itpl('\n'+'*'*70+'\n'+self.user_message_template)
+        print >> sys.stderr, msg
+
+        # Construct report on disk
+        report.write(self.make_report(traceback))
+        report.close()
+        raw_input("Press enter to exit:")
+
+    def make_report(self,traceback):
+        """Return a string containing a crash report."""
+
+        sec_sep = '\n\n'+'*'*75+'\n\n'
+
+        report = []
+        rpt_add = report.append
+        
+        rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
+        rpt_add('IPython version: %s \n\n' % Release.version)
+        rpt_add('SVN revision   : %s \n\n' % Release.revision)
+        rpt_add('Platform info  : os.name -> %s, sys.platform -> %s' %
+                     (os.name,sys.platform) )
+        rpt_add(sec_sep+'Current user configuration structure:\n\n')
+        rpt_add(pformat(self.IP.rc.dict()))
+        rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
+        try:
+            rpt_add(sec_sep+"History of session input:")
+            for line in self.IP.user_ns['_ih']:
+                rpt_add(line)
+            rpt_add('\n*** Last line of input (may not be in above history):\n')
+            rpt_add(self.IP._last_input_line+'\n')
+        except:
+            pass
+
+        return ''.join(report)
+
+class IPythonCrashHandler(CrashHandler):
+    """sys.excepthook for IPython itself, leaves a detailed report on disk."""
+    
+    def __init__(self,IP):
+
+        # Set here which of the IPython authors should be listed as contact
+        AUTHOR_CONTACT = 'Ville'
+        
+        # Set argument defaults
+        app_name = 'IPython'
+        bug_tracker = 'http://projects.scipy.org/ipython/ipython/report'
+        contact_name,contact_email = Release.authors[AUTHOR_CONTACT][:2]
+        crash_report_fname = 'IPython_crash_report.txt'
+        # Call parent constructor
+        CrashHandler.__init__(self,IP,app_name,contact_name,contact_email,
+                              bug_tracker,crash_report_fname)
+
+    def make_report(self,traceback):
+        """Return a string containing a crash report."""
+
+        sec_sep = '\n\n'+'*'*75+'\n\n'
+
+        report = []
+        rpt_add = report.append
+        
+        rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
+        rpt_add('IPython version: %s \n\n' % Release.version)
+        rpt_add('SVN revision   : %s \n\n' % Release.revision)
+        rpt_add('Platform info  : os.name -> %s, sys.platform -> %s' %
+                     (os.name,sys.platform) )
+        rpt_add(sec_sep+'Current user configuration structure:\n\n')
+        rpt_add(pformat(self.IP.rc.dict()))
+        rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
+        try:
+            rpt_add(sec_sep+"History of session input:")
+            for line in self.IP.user_ns['_ih']:
+                rpt_add(line)
+            rpt_add('\n*** Last line of input (may not be in above history):\n')
+            rpt_add(self.IP._last_input_line+'\n')
+        except:
+            pass
+
+        return ''.join(report)
diff --git a/IPython/DPyGetOpt.py b/IPython/DPyGetOpt.py
new file mode 100644
index 0000000..e9d8ce4
--- /dev/null
+++ b/IPython/DPyGetOpt.py
@@ -0,0 +1,693 @@
+# -*- coding: utf-8 -*-
+"""DPyGetOpt -- Demiurge Python GetOptions Module
+
+ $Id: DPyGetOpt.py 2872 2007-11-25 17:58:05Z fperez $
+
+This module is modeled after perl's Getopt::Long module-- which
+is, in turn, modeled after GNU's extended getopt() function.
+
+Upon instantiation, the option specification should be a sequence
+(list) of option definitions.
+
+Options that take no arguments should simply contain the name of
+the option.  If a ! is post-pended, the option can be negated by
+prepending 'no';  ie 'debug!' specifies that -debug and -nodebug
+should be accepted.
+
+Mandatory arguments to options are specified using a postpended
+'=' + a type specifier.  '=s' specifies a mandatory string
+argument, '=i' specifies a mandatory integer argument, and '=f'
+specifies a mandatory real number.  In all cases, the '=' can be
+substituted with ':' to specify that the argument is optional.
+
+Dashes '-' in option names are allowed.
+
+If an option has the character '@' postpended (after the
+argumentation specification), it can appear multiple times within
+each argument list that is processed. The results will be stored
+in a list.
+
+The option name can actually be a list of names separated by '|'
+characters;  ie-- 'foo|bar|baz=f@' specifies that all -foo, -bar,
+and -baz options that appear on within the parsed argument list
+must have a real number argument and that the accumulated list
+of values will be available under the name 'foo'
+
+$Id: DPyGetOpt.py 2872 2007-11-25 17:58:05Z fperez $"""
+
+#*****************************************************************************
+#
+# Copyright (c) 2001 Bill Bumgarner <bbum@friday.com>
+#
+#
+# Published under the terms of the MIT license, hereby reproduced:
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+#*****************************************************************************
+
+__author__  = 'Bill Bumgarner <bbum@friday.com>'
+__license__ = 'MIT'
+__version__ = '1.2'
+
+# Modified to use re instead of regex and regsub modules.
+# 2001/5/7, Jonathan Hogg <jonathan@onegoodidea.com>
+
+import re
+import string
+import sys
+import types
+
+class Error(Exception):
+    """Base class for exceptions in the DPyGetOpt module."""
+
+class ArgumentError(Error):
+    """Exception indicating an error in the arguments passed to
+    DPyGetOpt.processArguments."""
+
+class SpecificationError(Error):
+    """Exception indicating an error with an option specification."""
+
+class TerminationError(Error):
+    """Exception indicating an error with an option processing terminator."""
+
+specificationExpr = re.compile('(?P<required>.)(?P<type>.)(?P<multi>@?)')
+
+ArgRequired     = 'Requires an Argument'
+ArgOptional     = 'Argument Optional'
+
+# The types modules is not used for these identifiers because there
+# is no identifier for 'boolean' or 'generic'
+StringArgType   = 'String Argument Type'
+IntegerArgType  = 'Integer Argument Type'
+RealArgType             = 'Real Argument Type'
+BooleanArgType  = 'Boolean Argument Type'
+GenericArgType  = 'Generic Argument Type'
+
+# dictionary of conversion functions-- boolean and generic options
+# do not accept arguments and do not need conversion functions;
+# the identity function is used purely for convenience.
+ConversionFunctions = {
+        StringArgType : lambda x: x,
+        IntegerArgType : string.atoi,
+        RealArgType : string.atof,
+        BooleanArgType : lambda x: x,
+        GenericArgType : lambda x: x,
+        }
+
+class DPyGetOpt:
+
+    def __init__(self, spec = None, terminators = ['--']):
+        """
+        Declare and intialize instance variables
+
+        Yes, declaration is not necessary... but one of the things
+        I sorely miss from C/Obj-C is the concept of having an
+        interface definition that clearly declares all instance
+        variables and methods without providing any implementation
+         details.   it is a useful reference!
+
+        all instance variables are initialized to 0/Null/None of
+        the appropriate type-- not even the default value...
+        """
+
+#               sys.stderr.write(string.join(spec) + "\n")
+
+        self.allowAbbreviations = 1  # boolean, 1 if abbreviations will
+                                                                                  # be expanded
+        self.freeValues         = [] # list, contains free values
+        self.ignoreCase         = 0  # boolean, YES if ignoring case
+        self.needsParse         = 0  # boolean, YES if need to reparse parameter spec
+        self.optionNames        = {} # dict, all option names-- value is index of tuple
+        self.optionStartExpr    = None # regexp defining the start of an option (ie; '-', '--')
+        self.optionTuples       = [] # list o' tuples containing defn of options AND aliases
+        self.optionValues       = {} # dict, option names (after alias expansion) -> option value(s)
+        self.orderMixed         = 0  # boolean, YES if options can be mixed with args
+        self.posixCompliance    = 0  # boolean, YES indicates posix like behaviour
+        self.spec               = [] # list, raw specs (in case it must be reparsed)
+        self.terminators        = terminators # list, strings that terminate argument processing
+        self.termValues         = [] # list, values after terminator
+        self.terminator         = None # full name of terminator that ended
+                                               # option processing
+
+        # set up defaults
+        self.setPosixCompliance()
+        self.setIgnoreCase()
+        self.setAllowAbbreviations()
+
+        # parse spec-- if present
+        if spec:
+            self.parseConfiguration(spec)
+
+    def setPosixCompliance(self, aFlag = 0):
+        """
+        Enables and disables posix compliance.
+
+        When enabled, '+' can be used as an option prefix and free
+        values can be mixed with options.
+        """
+        self.posixCompliance = aFlag
+        self.needsParse = 1
+
+        if self.posixCompliance:
+            self.optionStartExpr = re.compile('(--|-)(?P<option>[A-Za-z0-9_-]+)(?P<arg>=.*)?')
+            self.orderMixed = 0
+        else:
+            self.optionStartExpr = re.compile('(--|-|\+)(?P<option>[A-Za-z0-9_-]+)(?P<arg>=.*)?')
+            self.orderMixed = 1
+
+    def isPosixCompliant(self):
+        """
+        Returns the value of the posix compliance flag.
+        """
+        return self.posixCompliance
+
+    def setIgnoreCase(self, aFlag = 1):
+        """
+        Enables and disables ignoring case during option processing.
+        """
+        self.needsParse = 1
+        self.ignoreCase = aFlag
+
+    def ignoreCase(self):
+        """
+        Returns 1 if the option processor will ignore case when
+        processing options.
+        """
+        return self.ignoreCase
+
+    def setAllowAbbreviations(self, aFlag = 1):
+        """
+        Enables and disables the expansion of abbreviations during
+        option processing.
+        """
+        self.allowAbbreviations = aFlag
+
+    def willAllowAbbreviations(self):
+        """
+        Returns 1 if abbreviated options will be automatically
+        expanded to the non-abbreviated form (instead of causing an
+        unrecognized option error).
+        """
+        return self.allowAbbreviations
+
+    def addTerminator(self, newTerm):
+        """
+        Adds newTerm as terminator of option processing.
+
+        Whenever the option processor encounters one of the terminators
+        during option processing, the processing of options terminates
+        immediately, all remaining options are stored in the termValues
+        instance variable and the full name of the terminator is stored
+        in the terminator instance variable.
+        """
+        self.terminators = self.terminators + [newTerm]
+
+    def _addOption(self, oTuple):
+        """
+        Adds the option described by oTuple (name, (type, mode,
+        default), alias) to optionTuples.  Adds index keyed under name
+        to optionNames.  Raises SpecificationError if name already in
+        optionNames
+        """
+        (name, (type, mode, default, multi), realName) = oTuple
+
+        # verify name and add to option names dictionary
+        if self.optionNames.has_key(name):
+            if realName:
+                raise SpecificationError('Alias \'' + name + '\' for \'' +
+                                         realName +
+                                         '\' already used for another option or alias.')
+            else:
+                raise SpecificationError('Option named \'' + name +
+                                         '\' specified more than once. Specification: '
+                                         + option)
+
+        # validated. add to optionNames
+        self.optionNames[name] = self.tupleIndex
+        self.tupleIndex = self.tupleIndex + 1
+
+        # add to optionTuples
+        self.optionTuples = self.optionTuples + [oTuple]
+
+        # if type is boolean, add negation
+        if type == BooleanArgType:
+            alias            = 'no' + name
+            specTuple = (type, mode, 0, multi)
+            oTuple = (alias, specTuple, name)
+
+            # verify name and add to option names dictionary
+            if self.optionNames.has_key(alias):
+                if realName:
+                    raise SpecificationError('Negated alias \'' + name +
+                                             '\' for \'' + realName +
+                                             '\' already used for another option or alias.')
+                else:
+                    raise SpecificationError('Negated option named \'' + name +
+                                             '\' specified more than once. Specification: '
+                                             + option)
+
+            # validated. add to optionNames
+            self.optionNames[alias] = self.tupleIndex
+            self.tupleIndex = self.tupleIndex + 1
+
+            # add to optionTuples
+            self.optionTuples = self.optionTuples + [oTuple]
+
+    def addOptionConfigurationTuple(self, oTuple):
+        (name, argSpec, realName) = oTuple
+        if self.ignoreCase:
+            name = string.lower(name)
+            if realName:
+                realName = string.lower(realName)
+            else:
+                realName = name
+
+            oTuple = (name, argSpec, realName)
+
+        # add option
+        self._addOption(oTuple)
+
+    def addOptionConfigurationTuples(self, oTuple):
+        if type(oTuple) is ListType:
+            for t in oTuple:
+                self.addOptionConfigurationTuple(t)
+        else:
+            self.addOptionConfigurationTuple(oTuple)
+
+    def parseConfiguration(self, spec):
+        # destroy previous stored information + store raw spec
+        self.spec                       = spec
+        self.optionTuples       = []
+        self.optionNames  = {}
+        self.tupleIndex   = 0
+
+        tupleIndex = 0
+
+        # create some regex's for parsing each spec
+        splitExpr = \
+                                 re.compile('(?P<names>\w+[-A-Za-z0-9|]*)?(?P<spec>!|[=:][infs]@?)?')
+        for option in spec:
+ # push to lower case (does not negatively affect
+ # specification)
+            if self.ignoreCase:
+                option = string.lower(option)
+
+            # break into names, specification
+            match = splitExpr.match(option)
+            if match is None:
+                raise SpecificationError('Invalid specification {' + option +
+                                         '}')
+
+            names                     = match.group('names')
+            specification = match.group('spec')
+
+            # break name into name, aliases
+            nlist = string.split(names, '|')
+
+            # get name
+            name      = nlist[0]
+            aliases = nlist[1:]
+
+            # specificationExpr = regex.symcomp('\(<required>.\)\(<type>.\)\(<multi>@?\)')
+            if not specification:
+                #spec tuple is ('type', 'arg mode', 'default value', 'multiple')
+                argType         = GenericArgType
+                argMode         = None
+                argDefault      = 1
+                argMultiple     = 0
+            elif specification == '!':
+                argType         = BooleanArgType
+                argMode         = None
+                argDefault      = 1
+                argMultiple     = 0
+            else:
+                # parse
+                match = specificationExpr.match(specification)
+                if match is None:
+                    # failed to parse, die
+                    raise SpecificationError('Invalid configuration for option \''
+                                             + option + '\'')
+
+                # determine mode
+                required = match.group('required')
+                if required == '=':
+                    argMode = ArgRequired
+                elif required == ':':
+                    argMode = ArgOptional
+                else:
+                    raise SpecificationError('Unknown requirement configuration \''
+                                             + required + '\'')
+
+                # determine type
+                type = match.group('type')
+                if type == 's':
+                    argType   = StringArgType
+                    argDefault = ''
+                elif type == 'i':
+                    argType   = IntegerArgType
+                    argDefault = 1
+                elif type == 'f' or type == 'n':
+                    argType   = RealArgType
+                    argDefault = 1
+                else:
+                    raise SpecificationError('Unknown type specifier \'' +
+                                             type + '\'')
+
+                # determine quantity
+                if match.group('multi') == '@':
+                    argMultiple = 1
+                else:
+                    argMultiple = 0
+            ## end else (of not specification)
+
+            # construct specification tuple
+            specTuple = (argType, argMode, argDefault, argMultiple)
+
+            # add the option-- option tuple is (name, specTuple, real name)
+            oTuple = (name, specTuple, name)
+            self._addOption(oTuple)
+
+            for alias in aliases:
+                # drop to all lower (if configured to do so)
+                if self.ignoreCase:
+                    alias = string.lower(alias)
+                # create configuration tuple
+                oTuple = (alias, specTuple, name)
+                # add
+                self._addOption(oTuple)
+
+        # successfully parsed....
+        self.needsParse = 0
+
+    def _getArgTuple(self, argName):
+        """
+        Returns a list containing all the specification tuples that
+        match argName.  If none match, None is returned.  If one
+        matches, a list with one tuple is returned.  If more than one
+        match, a list containing all the tuples that matched is
+        returned.
+
+        In other words, this function does not pass judgement upon the
+        validity of multiple matches.
+        """
+        # is it in the optionNames dict?
+
+        try:
+#                       sys.stderr.write(argName + string.join(self.optionNames.keys()) + "\n")
+
+            # yes, get index
+            tupleIndex = self.optionNames[argName]
+            # and return tuple as element of list
+            return [self.optionTuples[tupleIndex]]
+        except KeyError:
+            # are abbreviations allowed?
+            if not self.allowAbbreviations:
+                # No! terefore, this cannot be valid argument-- nothing found
+                return None
+
+        # argName might be an abbreviation (and, abbreviations must
+        # be allowed... or this would not have been reached!)
+
+        # create regex for argName
+        argExpr = re.compile('^' + argName)
+
+        tuples = filter(lambda x, argExpr=argExpr: argExpr.search(x[0]) is not None,
+                                                  self.optionTuples)
+
+        if not len(tuples):
+            return None
+        else:
+            return tuples
+
+    def _isTerminator(self, optionName):
+        """
+        Returns the full name of the terminator if optionName is a valid
+        terminator.  If it is, sets self.terminator to the full name of
+        the terminator.
+
+        If more than one terminator matched, raises a TerminationError with a
+        string describing the ambiguity.
+        """
+
+#               sys.stderr.write(optionName + "\n")
+#               sys.stderr.write(repr(self.terminators))
+
+        if optionName in self.terminators:
+            self.terminator = optionName
+        elif not self.allowAbbreviations:
+            return None
+
+# regex thing in bogus
+#               termExpr = regex.compile('^' + optionName)
+
+        terms = filter(lambda x, on=optionName: string.find(x,on) == 0, self.terminators)
+
+        if not len(terms):
+            return None
+        elif len(terms) > 1:
+            raise TerminationError('Ambiguous terminator \'' + optionName +
+                                   '\' matches ' + repr(terms))
+
+        self.terminator = terms[0]
+        return self.terminator
+
+    def processArguments(self, args = None):
+        """
+        Processes args, a list of arguments (including options).
+
+        If args is the same as sys.argv, automatically trims the first
+        argument (the executable name/path).
+
+        If an exception is not raised, the argument list was parsed
+        correctly.
+
+        Upon successful completion, the freeValues instance variable
+        will contain all the arguments that were not associated with an
+        option in the order they were encountered.  optionValues is a
+        dictionary containing the value of each option-- the method
+        valueForOption() can be used to query this dictionary.
+        terminator will contain the argument encountered that terminated
+        option processing (or None, if a terminator was never
+        encountered) and termValues will contain all of the options that
+        appeared after the Terminator (or an empty list).
+        """
+
+        if hasattr(sys, "argv") and args == sys.argv:
+            args = sys.argv[1:]
+
+        max             = len(args) # maximum index + 1
+        self.freeValues = []        # array to hold return values
+        self.optionValues= {}
+        index           = 0         # initial index
+        self.terminator = None
+        self.termValues  = []
+
+        while index < max:
+            # obtain argument
+            arg = args[index]
+            # increment index -- REMEMBER; it is NOW incremented
+            index = index + 1
+
+            # terminate immediately if option terminator encountered
+            if self._isTerminator(arg):
+                self.freeValues = self.freeValues + args[index:]
+                self.termValues = args[index:]
+                return
+
+            # is this possibly an option?
+            match = self.optionStartExpr.match(arg)
+            if match is None:
+                # not an option-- add to freeValues
+                self.freeValues = self.freeValues + [arg]
+                if not self.orderMixed:
+                    # mixing not allowed;  add rest of args as freeValues
+                    self.freeValues = self.freeValues + args[index:]
+                    # return to caller
+                    return
+                else:
+                    continue
+
+            # grab name
+            optName = match.group('option')
+
+            # obtain next argument-- index has already been incremented
+            nextArg = match.group('arg')
+            if nextArg:
+                nextArg = nextArg[1:]
+                index = index - 1 # put it back
+            else:
+                try:
+                    nextArg = args[index]
+                except:
+                    nextArg = None
+
+            # transpose to lower case, if necessary
+            if self.ignoreCase:
+                optName = string.lower(optName)
+
+            # obtain defining tuple
+            tuples = self._getArgTuple(optName)
+
+            if tuples == None:
+                raise ArgumentError('Illegal option \'' + arg + '\'')
+            elif len(tuples) > 1:
+                raise ArgumentError('Ambiguous option \'' + arg +
+                                    '\';  matches ' +
+                                    repr(map(lambda x: x[0], tuples)))
+            else:
+                config = tuples[0]
+
+            # config is now set to the configuration tuple for the
+            # argument
+            (fullName, spec, realName) = config
+            (optType, optMode, optDefault, optMultiple) = spec
+
+            # if opt mode required, but nextArg is none, raise an error
+            if (optMode == ArgRequired):
+                if (not nextArg) or self._isTerminator(nextArg):
+#                                       print nextArg
+                    raise ArgumentError('Option \'' + arg +
+                                        '\' requires an argument of type ' +
+                                        optType)
+
+            if (not optMode == None) and nextArg and (not self._isTerminator(nextArg)):
+                # nextArg defined, option configured to possibly consume arg
+                try:
+                    # grab conversion function-- the try is more for internal diagnostics
+                    func = ConversionFunctions[optType]
+                    try:
+                        optionValue = func(nextArg)
+                        index = index + 1
+                    except:
+                        # only raise conversion error if REQUIRED to consume argument
+                        if optMode == ArgRequired:
+                            raise ArgumentError('Invalid argument to option \''
+                                                + arg + '\';  should be \'' +
+                                                optType + '\'')
+                        else:
+                            optionValue = optDefault
+                except ArgumentError:
+                    raise
+                except:
+                    raise ArgumentError('(' + arg +
+                                        ') Conversion function for \'' +
+                                        optType + '\' not found.')
+            else:
+                optionValue = optDefault
+
+            # add value to options dictionary
+            if optMultiple:
+                # can be multiple values
+                try:
+                    # try to append element
+                    self.optionValues[realName] = self.optionValues[realName] + [optionValue]
+                except:
+                    # failed-- must not exist;  add it
+                    self.optionValues[realName] = [optionValue]
+            else:
+                # only one value per
+                if self.isPosixCompliant and self.optionValues.has_key(realName):
+                    raise ArgumentError('Argument \'' + arg +
+                                        '\' occurs multiple times.')
+
+                self.optionValues[realName] = optionValue
+
+    def valueForOption(self, optionName, defaultValue = None):
+        """
+        Return the value associated with optionName.  If optionName was
+        not encountered during parsing of the arguments, returns the
+        defaultValue (which defaults to None).
+        """
+        try:
+            optionValue = self.optionValues[optionName]
+        except:
+            optionValue = defaultValue
+
+        return optionValue
+
+##
+## test/example section
+##
+test_error = 'Test Run Amok!'
+def _test():
+    """
+    A relatively complete test suite.
+    """
+    try:
+        DPyGetOpt(['foo', 'bar=s', 'foo'])
+    except Error, exc:
+        print 'EXCEPTION (should be \'foo\' already used..): %s' % exc
+
+    try:
+        DPyGetOpt(['foo|bar|apple=s@', 'baz|apple!'])
+    except Error, exc:
+        print 'EXCEPTION (should be duplicate alias/name error): %s' % exc
+
+    x = DPyGetOpt(['apple|atlas=i@', 'application|executable=f@'])
+    try:
+        x.processArguments(['-app', '29.3'])
+    except Error, exc:
+        print 'EXCEPTION (should be ambiguous argument): %s' % exc
+
+    x = DPyGetOpt(['foo'], ['antigravity', 'antithesis'])
+    try:
+        x.processArguments(['-foo', 'anti'])
+    except Error, exc:
+        print 'EXCEPTION (should be ambiguous terminator): %s' % exc
+
+    profile = ['plain-option',
+                              'boolean-option!',
+                              'list-of-integers=i@',
+                              'list-real-option|list-real-alias|list-real-pseudonym=f@',
+                              'optional-string-option:s',
+                              'abbreviated-string-list=s@']
+
+    terminators = ['terminator']
+
+    args = ['-plain-option',
+                      '+noboolean-option',
+                      '--list-of-integers', '1',
+                      '+list-of-integers', '2',
+                      '-list-of-integers', '3',
+                      'freeargone',
+                      '-list-real-option', '1.1',
+                      '+list-real-alias', '1.2',
+                      '--list-real-pseudonym', '1.3',
+                      'freeargtwo',
+                      '-abbreviated-string-list', 'String1',
+                      '--abbreviated-s', 'String2',
+                      '-abbrev', 'String3',
+                      '-a', 'String4',
+                      '-optional-string-option',
+                      'term',
+                      'next option should look like an invalid arg',
+                      '-a']
+
+
+    print 'Using profile: ' + repr(profile)
+    print 'With terminator: ' + repr(terminators)
+    print 'Processing arguments: ' + repr(args)
+
+    go = DPyGetOpt(profile, terminators)
+    go.processArguments(args)
+
+    print 'Options (and values): ' + repr(go.optionValues)
+    print 'free args: ' + repr(go.freeValues)
+    print 'term args: ' + repr(go.termValues)
diff --git a/IPython/Debugger.py b/IPython/Debugger.py
new file mode 100644
index 0000000..669961e
--- /dev/null
+++ b/IPython/Debugger.py
@@ -0,0 +1,517 @@
+# -*- 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 2913 2007-12-31 12:42:14Z vivainio $"""
+
+#*****************************************************************************
+#
+#       This file is licensed under the PSF license.
+#
+#       Copyright (C) 2001 Python Software Foundation, www.python.org
+#       Copyright (C) 2005-2006 Fernando Perez. <fperez@colorado.edu>
+#
+#
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = 'Python'
+
+import bdb
+import cmd
+import linecache
+import os
+import sys
+
+from IPython import PyColorize, ColorANSI, ipapi
+from IPython.genutils import Term
+from IPython.excolors import ExceptionColors
+
+# See if we can use pydb.
+has_pydb = False
+prompt = 'ipdb> '
+#We have to check this directly from sys.argv, config struct not yet available
+if '-pydb' in sys.argv:
+    try:        
+        import pydb
+        if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':
+            # Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we
+            # better protect against it.
+            has_pydb = True
+    except ImportError:
+        print "Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available"
+
+if has_pydb:
+    from pydb import Pdb as OldPdb
+    #print "Using pydb for %run -d and post-mortem" #dbg
+    prompt = 'ipydb> '
+else:
+    from pdb import Pdb as OldPdb
+
+# Allow the set_trace code to operate outside of an ipython instance, even if
+# it does so with some limitations.  The rest of this support is implemented in
+# the Tracer constructor.
+def BdbQuit_excepthook(et,ev,tb):
+    if et==bdb.BdbQuit:
+        print 'Exiting Debugger.'
+    else:
+        BdbQuit_excepthook.excepthook_ori(et,ev,tb)
+
+def BdbQuit_IPython_excepthook(self,et,ev,tb):
+    print 'Exiting Debugger.'
+
+class Tracer(object):
+    """Class for local debugging, similar to pdb.set_trace.
+
+    Instances of this class, when called, behave like pdb.set_trace, but
+    providing IPython's enhanced capabilities.
+
+    This is implemented as a class which must be initialized in your own code
+    and not as a standalone function because we need to detect at runtime
+    whether IPython is already active or not.  That detection is done in the
+    constructor, ensuring that this code plays nicely with a running IPython,
+    while functioning acceptably (though with limitations) if outside of it.
+    """
+
+    def __init__(self,colors=None):
+        """Create a local debugger instance.
+
+        :Parameters:
+
+          - `colors` (None): a string containing the name of the color scheme to
+        use, it must be one of IPython's valid color schemes.  If not given, the
+        function will default to the current IPython scheme when running inside
+        IPython, and to 'NoColor' otherwise.
+
+        Usage example:
+
+        from IPython.Debugger import Tracer; debug_here = Tracer()
+
+        ... later in your code
+        debug_here()  # -> will open up the debugger at that point.
+
+        Once the debugger activates, you can use all of its regular commands to
+        step through code, set breakpoints, etc.  See the pdb documentation
+        from the Python standard library for usage details.
+        """
+
+        global __IPYTHON__
+        try:
+            __IPYTHON__
+        except NameError:
+            # Outside of ipython, we set our own exception hook manually
+            __IPYTHON__ = ipapi.get(True,False)
+            BdbQuit_excepthook.excepthook_ori = sys.excepthook
+            sys.excepthook = BdbQuit_excepthook
+            def_colors = 'NoColor'
+            try:
+                # Limited tab completion support
+                import rlcompleter,readline
+                readline.parse_and_bind('tab: complete')
+            except ImportError:
+                pass
+        else:
+            # In ipython, we use its custom exception handler mechanism
+            ip = ipapi.get()
+            def_colors = ip.options.colors
+            ip.set_custom_exc((bdb.BdbQuit,),BdbQuit_IPython_excepthook)
+
+        if colors is None:
+            colors = def_colors
+        self.debugger = Pdb(colors)
+
+    def __call__(self):
+        """Starts an interactive debugger at the point where called.
+
+        This is similar to the pdb.set_trace() function from the std lib, but
+        using IPython's enhanced debugger."""
+        
+        self.debugger.set_trace(sys._getframe().f_back)
+
+def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
+    """Make new_fn have old_fn's doc string. This is particularly useful
+    for the do_... commands that hook into the help system.
+    Adapted from from a comp.lang.python posting
+    by Duncan Booth."""
+    def wrapper(*args, **kw):
+        return new_fn(*args, **kw)
+    if old_fn.__doc__:
+        wrapper.__doc__ = old_fn.__doc__ + additional_text
+    return wrapper
+
+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(OldPdb):
+    """Modified Pdb class, does not load readline."""
+
+    if sys.version[:3] >= '2.5' or has_pydb:
+        def __init__(self,color_scheme='NoColor',completekey=None,
+                     stdin=None, stdout=None):
+
+            # Parent constructor:
+            if has_pydb and completekey is None:
+                OldPdb.__init__(self,stdin=stdin,stdout=Term.cout)
+            else:
+                OldPdb.__init__(self,completekey,stdin,stdout)
+                
+            self.prompt = prompt # The default prompt is '(Pdb)'
+            
+            # IPython changes...
+            self.is_pydb = has_pydb
+
+            if self.is_pydb:
+
+                # iplib.py's ipalias seems to want pdb's checkline
+                # which located in pydb.fn
+                import pydb.fns
+                self.checkline = lambda filename, lineno: \
+                                 pydb.fns.checkline(self, filename, lineno)
+
+                self.curframe = None
+                self.do_restart = self.new_do_restart
+
+                self.old_all_completions = __IPYTHON__.Completer.all_completions
+                __IPYTHON__.Completer.all_completions=self.all_completions
+
+                self.do_list = decorate_fn_with_doc(self.list_command_pydb,
+                                                    OldPdb.do_list)
+                self.do_l     = self.do_list
+                self.do_frame = decorate_fn_with_doc(self.new_do_frame,
+                                                     OldPdb.do_frame)
+
+            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)
+
+            # Add a python parser so we can syntax highlight source while
+            # debugging.
+            self.parser = PyColorize.Parser()
+
+
+    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
+            ExceptionColors.set_active_scheme(color_scheme)
+            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)
+
+            # Add a python parser so we can syntax highlight source while
+            # debugging.
+            self.parser = PyColorize.Parser()
+        
+    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)
+        OldPdb.interaction(self, frame, traceback)
+
+    def new_do_up(self, arg):
+        OldPdb.do_up(self, arg)
+        __IPYTHON__.set_completer_frame(self.curframe)
+    do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
+
+    def new_do_down(self, arg):
+        OldPdb.do_down(self, arg)
+        __IPYTHON__.set_completer_frame(self.curframe)
+
+    do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
+
+    def new_do_frame(self, arg):
+        OldPdb.do_frame(self, arg)
+        __IPYTHON__.set_completer_frame(self.curframe)
+
+    def new_do_quit(self, arg):
+        
+        if hasattr(self, 'old_all_completions'):
+            __IPYTHON__.Completer.all_completions=self.old_all_completions
+        
+        
+        return OldPdb.do_quit(self, arg)
+
+    do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
+
+    def new_do_restart(self, arg):
+        """Restart command. In the context of ipython this is exactly the same
+        thing as 'quit'."""
+        self.msg("Restart doesn't make sense here. Using 'quit' instead.")
+        return self.do_quit(arg)
+
+    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.
+        if frame is self.curframe:
+            ret.append('> ')
+        else:
+            ret.append('  ')
+        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)
+            linetpl = (frame is self.curframe or show_arrow) \
+                      and tpl_line_em \
+                      or tpl_line
+            ret.append(self.__format_line(linetpl, 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 = ""
+
+        scheme = self.color_scheme_table.active_scheme_name
+        new_line, err = self.parser.format2(line, 'str', scheme)
+        if not err: line = new_line
+
+        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 list_command_pydb(self, arg):
+        """List command to use if we have a newer pydb installed"""
+        filename, first, last = OldPdb.parse_list_cmd(self, arg)
+        if filename is not None:
+            self.print_list_lines(filename, first, last)
+        
+    def print_list_lines(self, filename, first, last):
+        """The printing (as opposed to the parsing part of a 'list'
+        command."""
+        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
+
+    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
+        self.print_list_lines(self.curframe.f_code.co_filename, first, last)
+
+    do_l = do_list
+
+    def do_pdef(self, arg):
+        """The debugger interface to magic_pdef"""
+        namespaces = [('Locals', self.curframe.f_locals),
+                      ('Globals', self.curframe.f_globals)]
+        __IPYTHON__.magic_pdef(arg, namespaces=namespaces)
+
+    def do_pdoc(self, arg):
+        """The debugger interface to magic_pdoc"""
+        namespaces = [('Locals', self.curframe.f_locals),
+                      ('Globals', self.curframe.f_globals)]
+        __IPYTHON__.magic_pdoc(arg, namespaces=namespaces)
+
+    def do_pinfo(self, arg):
+        """The debugger equivalant of ?obj"""
+        namespaces = [('Locals', self.curframe.f_locals),
+                      ('Globals', self.curframe.f_globals)]
+        __IPYTHON__.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)
diff --git a/IPython/Extensions/InterpreterExec.py b/IPython/Extensions/InterpreterExec.py
new file mode 100644
index 0000000..07a3d66
--- /dev/null
+++ b/IPython/Extensions/InterpreterExec.py
@@ -0,0 +1,259 @@
+# -*- coding: utf-8 -*-
+"""Modified input prompt for executing files.
+
+We define a special input line filter to allow typing lines which begin with
+'~', '/' or '.'. If one of those strings is encountered, it is automatically
+executed.
+
+$Id: InterpreterExec.py 2724 2007-09-07 08:05:38Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2004 W.J. van der Laan <gnufnork@hetdigitalegat.nl>
+#       Copyright (C) 2004-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  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__ = 'W.J. van der Laan <gnufnork@hetdigitalegat.nl>, '\
+             '%s <%s>' %  Release.authors['Fernando']
+__license__ = Release.license
+
+# TODO: deprecated
+def prefilter_shell(self,line,continuation):
+    """Alternate prefilter, modified for shell-like functionality.
+
+    - Execute all lines beginning with '~', '/' or '.'
+    - $var=cmd <=> %sc var=cmd
+    - $$var=cmd <=> %sc -l var=cmd
+    """
+
+    if line:
+        l0 = line[0]
+        if l0 in '~/.':
+            return self._prefilter("!%s"%line,continuation)
+        elif l0=='$':
+            lrest = line[1:]
+            if lrest.startswith('$'):
+                # $$var=cmd <=> %sc -l var=cmd
+                return self._prefilter("%ssc -l %s" % (self.ESC_MAGIC,lrest[1:]),
+                                       continuation)
+            else:
+                # $var=cmd <=> %sc var=cmd
+                return self._prefilter("%ssc %s" % (self.ESC_MAGIC,lrest),
+                                       continuation)
+        else:
+            return self._prefilter(line,continuation)
+    else:
+        return self._prefilter(line,continuation)
+
+# Rebind this to be the new IPython prefilter:
+from IPython.iplib import InteractiveShell
+InteractiveShell.prefilter = prefilter_shell
+# Clean up the namespace.
+del InteractiveShell,prefilter_shell
+
+# Provide pysh and further shell-oriented services
+import os,sys,shutil
+from IPython.genutils import system,shell,getoutput,getoutputerror
+
+# Short aliases for getting shell output as a string and a list
+sout = getoutput
+lout = lambda cmd: getoutput(cmd,split=1)
+
+# Empty function, meant as a docstring holder so help(pysh) works.
+def pysh():
+    """Pysh is a set of modules and extensions to IPython which make shell-like
+    usage with Python syntax more convenient.  Keep in mind that pysh is NOT a
+    full-blown shell, so don't try to make it your /etc/passwd entry!
+    
+    In particular, it has no job control, so if you type Ctrl-Z (under Unix),
+    you'll suspend pysh itself, not the process you just started.
+
+    Since pysh is really nothing but a customized IPython, you should
+    familiarize yourself with IPython's features.  This brief help mainly
+    documents areas in which pysh differs from the normal IPython.
+
+    ALIASES
+    -------
+    All of your $PATH has been loaded as IPython aliases, so you should be
+    able to type any normal system command and have it executed.  See %alias? 
+    and %unalias? for details on the alias facilities.
+
+    SPECIAL SYNTAX
+    --------------
+    Any lines which begin with '~', '/' and '.' will be executed as shell
+    commands instead of as Python code. The special escapes below are also
+    recognized.  !cmd is valid in single or multi-line input, all others are
+    only valid in single-line input:
+
+    !cmd      - pass 'cmd' directly to the shell
+    !!cmd     - execute 'cmd' and return output as a list (split on '\\n')
+    $var=cmd  - capture output of cmd into var, as a string
+    $$var=cmd - capture output of cmd into var, as a list (split on '\\n')
+
+    The $/$$ syntaxes make Python variables from system output, which you can
+    later use for further scripting.  The converse is also possible: when
+    executing an alias or calling to the system via !/!!, you can expand any
+    python variable or expression by prepending it with $.  Full details of
+    the allowed syntax can be found in Python's PEP 215.
+
+    A few brief examples will illustrate these:
+
+        fperez[~/test]|3> !ls *s.py
+        scopes.py  strings.py
+
+    ls is an internal alias, so there's no need to use !:
+        fperez[~/test]|4> ls *s.py
+        scopes.py*  strings.py
+
+    !!ls will return the output into a Python variable:
+        fperez[~/test]|5> !!ls *s.py
+                      <5> ['scopes.py', 'strings.py']
+        fperez[~/test]|6> print _5
+        ['scopes.py', 'strings.py']
+
+    $ and $$ allow direct capture to named variables:
+        fperez[~/test]|7> $astr = ls *s.py
+        fperez[~/test]|8> astr
+                      <8> 'scopes.py\\nstrings.py'
+
+        fperez[~/test]|9> $$alist = ls *s.py
+        fperez[~/test]|10> alist
+                      <10> ['scopes.py', 'strings.py']
+
+    alist is now a normal python list you can loop over.  Using $ will expand
+    back the python values when alias calls are made:
+        fperez[~/test]|11> for f in alist:
+                      |..>     print 'file',f,
+                      |..>     wc -l $f
+                      |..>
+        file scopes.py     13 scopes.py
+        file strings.py      4 strings.py
+
+    Note that you may need to protect your variables with braces if you want
+    to append strings to their names.  To copy all files in alist to .bak
+    extensions, you must use:
+        fperez[~/test]|12> for f in alist:
+                      |..>     cp $f ${f}.bak
+
+    If you try using $f.bak, you'll get an AttributeError exception saying
+    that your string object doesn't have a .bak attribute.  This is because
+    the $ expansion mechanism allows you to expand full Python expressions:
+        fperez[~/test]|13> echo "sys.platform is: $sys.platform"
+        sys.platform is: linux2
+
+    IPython's input history handling is still active, which allows you to
+    rerun a single block of multi-line input by simply using exec:    
+        fperez[~/test]|14> $$alist = ls *.eps
+        fperez[~/test]|15> exec _i11
+        file image2.eps    921 image2.eps
+        file image.eps    921 image.eps
+
+    While these are new special-case syntaxes, they are designed to allow very
+    efficient use of the shell with minimal typing.  At an interactive shell
+    prompt, conciseness of expression wins over readability.
+
+    USEFUL FUNCTIONS AND MODULES
+    ----------------------------
+    The os, sys and shutil modules from the Python standard library are
+    automatically loaded.  Some additional functions, useful for shell usage,
+    are listed below.  You can request more help about them with '?'.
+
+    shell   - execute a command in the underlying system shell    
+    system  - like shell(), but return the exit status of the command
+    sout    - capture the output of a command as a string
+    lout    - capture the output of a command as a list (split on '\\n')
+    getoutputerror - capture (output,error) of a shell command
+
+    sout/lout are the functional equivalents of $/$$.  They are provided to
+    allow you to capture system output in the middle of true python code,
+    function definitions, etc (where $ and $$ are invalid).
+
+    DIRECTORY MANAGEMENT
+    --------------------
+    Since each command passed by pysh to the underlying system is executed in
+    a subshell which exits immediately, you can NOT use !cd to navigate the
+    filesystem.
+
+    Pysh provides its own builtin '%cd' magic command to move in the
+    filesystem (the % is not required with automagic on).  It also maintains a
+    list of visited directories (use %dhist to see it) and allows direct
+    switching to any of them.  Type 'cd?' for more details.
+
+    %pushd, %popd and %dirs are provided for directory stack handling.
+
+    PROMPT CUSTOMIZATION
+    --------------------
+    
+    The supplied ipythonrc-pysh profile comes with an example of a very
+    colored and detailed prompt, mainly to serve as an illustration.  The
+    valid escape sequences, besides color names, are:
+
+        \\#  - Prompt number.
+        \\D  - Dots, as many as there are digits in \\# (so they align).
+        \\w  - Current working directory (cwd).
+        \\W  - Basename of current working directory.
+        \\XN - Where N=0..5. N terms of the cwd, with $HOME written as ~.
+        \\YN - Where N=0..5. Like XN, but if ~ is term N+1 it's also shown.
+        \\u  - Username.
+        \\H  - Full hostname.
+        \\h  - Hostname up to first '.'
+        \\$  - Root symbol ($ or #).
+        \\t  - Current time, in H:M:S format.
+        \\v  - IPython release version.
+        \\n  - Newline.
+        \\r  - Carriage return.
+        \\\\ - An explicitly escaped '\\'.
+
+    You can configure your prompt colors using any ANSI color escape.  Each
+    color escape sets the color for any subsequent text, until another escape
+    comes in and changes things.  The valid color escapes are:
+
+        \\C_Black
+        \\C_Blue
+        \\C_Brown
+        \\C_Cyan
+        \\C_DarkGray
+        \\C_Green
+        \\C_LightBlue
+        \\C_LightCyan
+        \\C_LightGray
+        \\C_LightGreen
+        \\C_LightPurple
+        \\C_LightRed
+        \\C_Purple
+        \\C_Red
+        \\C_White
+        \\C_Yellow
+        \\C_Normal - Stop coloring, defaults to your terminal settings.
+    """
+    pass
+
+# Configure a few things.  Much of this is fairly hackish, since IPython
+# doesn't really expose a clean API for it.  Be careful if you start making
+# many modifications here.
+
+
+#  Set the 'cd' command to quiet mode, a more shell-like behavior
+__IPYTHON__.default_option('cd','-q')
+
+# This is redundant, ipy_user_conf.py will determine this
+# Load all of $PATH as aliases
+__IPYTHON__.magic_rehashx()
+
+# Remove %sc,%sx if present as aliases
+__IPYTHON__.magic_unalias('sc')
+__IPYTHON__.magic_unalias('sx')
+
+# We need different criteria for line-splitting, so that aliases such as
+# 'gnome-terminal' are interpreted as a single alias instead of variable
+# 'gnome' minus variable 'terminal'.
+import re
+__IPYTHON__.line_split = re.compile(r'^([\s*,;/])'
+                                    r'([\?\w\.\-\+]+\w*\s*)'
+                                    r'(\(?.*$)')
+
+# Namespace cleanup
+del re
diff --git a/IPython/Extensions/InterpreterPasteInput.py b/IPython/Extensions/InterpreterPasteInput.py
new file mode 100644
index 0000000..8f184d2
--- /dev/null
+++ b/IPython/Extensions/InterpreterPasteInput.py
@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+"""Modified input prompt for entering text with >>> or ... at the start.
+
+We define a special input line filter to allow typing lines which begin with
+'>>> ' or '... '. These two strings, if present at the start of the input
+line, are stripped. This allows for direct pasting of code from examples such
+as those available in the standard Python tutorial.
+
+Normally pasting such code is one chunk is impossible because of the
+extraneous >>> and ..., requiring one to do a line by line paste with careful
+removal of those characters. This module allows pasting that kind of
+multi-line examples in one pass.
+
+Here is an 'screenshot' of a section of the tutorial pasted into IPython with
+this feature enabled:
+
+In [1]: >>> def fib2(n): # return Fibonacci series up to n
+   ...: ...     '''Return a list containing the Fibonacci series up to n.'''
+   ...: ...     result = []
+   ...: ...     a, b = 0, 1
+   ...: ...     while b < n:
+   ...: ...         result.append(b)    # see below
+   ...: ...         a, b = b, a+b
+   ...: ...     return result
+   ...:
+
+In [2]: fib2(10)
+Out[2]: [1, 1, 2, 3, 5, 8]
+
+The >>> and ... are stripped from the input so that the python interpreter
+only sees the real part of the code.
+
+All other input is processed normally.
+
+Notes
+=====
+
+* You can even paste code that has extra initial spaces, such as is common in
+doctests:
+
+In [3]:     >>> a = ['Mary', 'had', 'a', 'little', 'lamb']
+
+In [4]:     >>> for i in range(len(a)):
+   ...:         ...     print i, a[i]
+   ...:     ...
+0 Mary
+1 had
+2 a
+3 little
+4 lamb
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+# This file is an example of how to modify IPython's line-processing behavior
+# without touching the internal code. We'll define an alternate pre-processing
+# stage which allows a special form of input (which is invalid Python syntax)
+# for certain quantities, rewrites a line of proper Python in those cases, and
+# then passes it off to IPython's normal processor for further work.
+
+# With this kind of customization, IPython can be adapted for many
+# special-purpose scenarios providing alternate input syntaxes.
+
+# This file can be imported like a regular module.
+
+# IPython has a prefilter() function that analyzes each input line. We redefine
+# it here to first pre-process certain forms of input
+
+# The prototype of any alternate prefilter must be like this one (the name
+# doesn't matter):
+# - line is a string containing the user input line.
+# - continuation is a parameter which tells us if we are processing a first
+# line of user input or the second or higher of a multi-line statement.
+
+import re
+
+from IPython.iplib import InteractiveShell
+
+PROMPT_RE = re.compile(r'(^[ \t]*>>> |^[ \t]*\.\.\. )')
+
+def prefilter_paste(self,line,continuation):
+    """Alternate prefilter for input of pasted code from an interpreter.
+    """
+    if not line:
+        return ''
+    m = PROMPT_RE.match(line)
+    if m:
+        # In the end, always call the default IPython _prefilter() function.
+        # Note that self must be passed explicitly, b/c we're calling the
+        # unbound class method (since this method will overwrite the instance
+        # prefilter())
+        return self._prefilter(line[len(m.group(0)):],continuation)
+    elif line.strip() == '...':
+        return self._prefilter('',continuation)
+    elif line.isspace():
+        # This allows us to recognize multiple input prompts separated by blank
+        # lines and pasted in a single chunk, very common when pasting doctests
+        # or long tutorial passages.
+        return ''
+    else:
+        return self._prefilter(line,continuation)
+
+def activate_prefilter():
+    """Rebind the input-pasting filter to be the new IPython prefilter"""
+    InteractiveShell.prefilter = prefilter_paste
+
+def deactivate_prefilter():
+    """Reset the filter."""
+    InteractiveShell.prefilter = InteractiveShell._prefilter
+
+# Just a heads up at the console
+activate_prefilter()
+print '*** Pasting of code with ">>>" or "..." has been enabled.'
diff --git a/IPython/Extensions/PhysicalQInput.py b/IPython/Extensions/PhysicalQInput.py
new file mode 100644
index 0000000..b4c1260
--- /dev/null
+++ b/IPython/Extensions/PhysicalQInput.py
@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+"""Modified input prompt for entering quantities with units.
+
+Modify the behavior of the interactive interpreter to allow direct input of
+quantities with units without having to make a function call.
+
+Now the following forms are accepted:
+
+x = 4 m
+y = -.45e3 m/s
+g = 9.8 m/s**2
+a = 2.3 m/s^2   # ^ -> ** automatically
+
+All other input is processed normally.
+"""
+#*****************************************************************************
+#       Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+# This file is an example of how to modify IPython's line-processing behavior
+# without touching the internal code. We'll define an alternate pre-processing
+# stage which allows a special form of input (which is invalid Python syntax)
+# for certain quantities, rewrites a line of proper Python in those cases, and
+# then passes it off to IPython's normal processor for further work.
+
+# With this kind of customization, IPython can be adapted for many
+# special-purpose scenarios providing alternate input syntaxes.
+
+# This file can be imported like a regular module.
+
+# IPython has a prefilter() function that analyzes each input line. We redefine
+# it here to first pre-process certain forms of input
+
+# The prototype of any alternate prefilter must be like this one (the name
+# doesn't matter):
+# - line is a string containing the user input line.
+# - continuation is a parameter which tells us if we are processing a first line of
+#   user input or the second or higher of a multi-line statement.
+
+def prefilter_PQ(self,line,continuation):
+    """Alternate prefilter for input of PhysicalQuantityInteractive objects.
+
+    This assumes that the function PhysicalQuantityInteractive() has been
+    imported."""
+
+    from re import match
+    from IPython.iplib import InteractiveShell
+
+    # This regexp is what does the real work
+    unit_split = match(r'\s*(\w+)\s*=\s*(-?\d*\.?\d*[eE]?-?\d*)\s+([a-zA-Z].*)',
+                       line)
+
+    # If special input was ecnountered, process it:
+    if unit_split:
+        var,val,units = unit_split.groups()
+        if var and val and units:
+            units = units.replace('^','**')
+            # Now a valid line needs to be constructed for IPython to process:
+            line = var +" = PhysicalQuantityInteractive(" + val + ", '" + \
+                   units + "')"
+            #print 'New line:',line   # dbg
+            
+    # In the end, always call the default IPython _prefilter() function.  Note
+    # that self must be passed explicitly, b/c we're calling the unbound class
+    # method (since this method will overwrite the instance prefilter())
+    return InteractiveShell._prefilter(self,line,continuation)
+
+# Rebind this to be the new IPython prefilter:
+from IPython.iplib import InteractiveShell
+InteractiveShell.prefilter = prefilter_PQ
+
+# Clean up the namespace.
+del InteractiveShell,prefilter_PQ
+
+# Just a heads up at the console
+print '*** Simplified input for physical quantities enabled.'
diff --git a/IPython/Extensions/PhysicalQInteractive.py b/IPython/Extensions/PhysicalQInteractive.py
new file mode 100644
index 0000000..d02c74e
--- /dev/null
+++ b/IPython/Extensions/PhysicalQInteractive.py
@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+"""Modify the PhysicalQuantities class for more convenient interactive use.
+
+Also redefine some math functions to operate on PhysQties with no need for
+special method syntax. This just means moving them out to the global
+namespace.
+
+This module should always be loaded *after* math or Numeric, so it can
+overwrite math functions with the versions that handle units."""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+from Scientific.Physics.PhysicalQuantities import PhysicalQuantity
+
+# This code can be set up to work with Numeric or with math for providing the
+# mathematical functions. Uncomment the one you prefer to use below.
+
+# If you use math, sin(x) won't work for x an array, only float or PhysQty
+import math
+
+# If you use Numeric, sin(x) works for x a float, PhysQty an array.
+#import Numeric as math
+
+class PhysicalQuantityFunction:
+    """Generic function wrapper for PhysicalQuantity instances.
+
+    Calls functions from either the math library or the instance's methods as
+    required.  Allows using sin(theta) or sqrt(v**2) syntax irrespective of
+    whether theta is a pure number or a PhysicalQuantity.
+
+    This is *slow*. It's meant for convenient interactive use, not for
+    speed."""
+
+    def __init__(self,name):
+        self.name = name
+        
+    def __call__(self,x):
+        if isinstance(x,PhysicalQuantity):
+            return PhysicalQuantity.__dict__[self.name](x)
+        else:
+            return math.__dict__[self.name](x)
+
+class PhysicalQuantityInteractive(PhysicalQuantity):
+    """Physical quantity with units - modified for Interactive use.
+
+    Basically, the __str__ and __repr__ methods have been swapped for more
+    convenient interactive use. Powers are shown as ^ instead of ** and only 4
+    significant figures are shown.
+
+    Also adds the following aliases for commonly used methods:
+      b = PhysicalQuantity.inBaseUnits
+      u = PhysicalQuantity.inUnitsOf
+      
+    These are useful when doing a lot of interactive calculations.
+    """
+    
+    # shorthands for the most useful unit conversions
+    b = PhysicalQuantity.inBaseUnits  # so you can just type x.b to get base units
+    u = PhysicalQuantity.inUnitsOf
+
+    # This can be done, but it can get dangerous when coupled with IPython's
+    # auto-calling. Everything ends up shown in baseunits and things like x*2
+    # get automatically converted to k(*2), which doesn't work.
+    # Probably not a good idea in general...
+    #__call__ = b
+    
+    def __str__(self):
+        return PhysicalQuantity.__repr__(self)
+ 
+    def __repr__(self):
+        value = '%.4G' % self.value
+        units = self.unit.name().replace('**','^')
+        return value + ' ' + units
+
+# implement the methods defined in PhysicalQuantity as PhysicalQuantityFunctions
+sin = PhysicalQuantityFunction('sin')
+cos = PhysicalQuantityFunction('cos')
+tan = PhysicalQuantityFunction('tan')
+sqrt = PhysicalQuantityFunction('sqrt')
diff --git a/IPython/Extensions/__init__.py b/IPython/Extensions/__init__.py
new file mode 100644
index 0000000..af1e47d
--- /dev/null
+++ b/IPython/Extensions/__init__.py
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+"""This directory is meant for special-purpose extensions to IPython.
+
+This can include things which alter the syntax processing stage (see
+PhysicalQ_Input for an example of how to do this).
+
+Any file located here can be called with an 'execfile =' option as
+
+  execfile = Extensions/filename.py
+
+since the IPython directory itself is already part of the search path for
+files listed as 'execfile ='.
+"""
diff --git a/IPython/Extensions/astyle.py b/IPython/Extensions/astyle.py
new file mode 100644
index 0000000..782a33c
--- /dev/null
+++ b/IPython/Extensions/astyle.py
@@ -0,0 +1,398 @@
+"""
+``astyle`` provides classes for adding style (foreground and background color;
+bold; blink; etc.) to terminal and curses output.
+"""
+
+
+import sys, os
+
+try:
+    import curses
+except ImportError:
+    curses = None
+
+
+COLOR_BLACK   = 0
+COLOR_RED     = 1
+COLOR_GREEN   = 2
+COLOR_YELLOW  = 3
+COLOR_BLUE    = 4
+COLOR_MAGENTA = 5
+COLOR_CYAN    = 6
+COLOR_WHITE   = 7
+
+A_BLINK     = 1<<0 # Blinking text
+A_BOLD      = 1<<1 # Extra bright or bold text
+A_DIM       = 1<<2 # Half bright text
+A_REVERSE   = 1<<3 # Reverse-video text
+A_STANDOUT  = 1<<4 # The best highlighting mode available
+A_UNDERLINE = 1<<5 # Underlined text
+
+
+class Style(object):
+    """
+    Store foreground color, background color and attribute (bold, underlined
+    etc.).
+    """
+    __slots__ = ("fg", "bg", "attrs")
+
+    COLORNAMES = {
+        "black": COLOR_BLACK,
+        "red": COLOR_RED,
+        "green": COLOR_GREEN,
+        "yellow": COLOR_YELLOW,
+        "blue": COLOR_BLUE,
+        "magenta": COLOR_MAGENTA,
+        "cyan": COLOR_CYAN,
+        "white": COLOR_WHITE,
+    }
+    ATTRNAMES = {
+        "blink": A_BLINK,
+        "bold": A_BOLD,
+        "dim": A_DIM,
+        "reverse": A_REVERSE,
+        "standout": A_STANDOUT,
+        "underline": A_UNDERLINE,
+    }
+
+    def __init__(self, fg, bg, attrs=0):
+        """
+        Create a ``Style`` object with ``fg`` as the foreground color,
+        ``bg`` as the background color and ``attrs`` as the attributes.
+
+        Examples:
+
+            >>> Style(COLOR_RED, COLOR_BLACK)
+            >>> Style(COLOR_YELLOW, COLOR_BLUE, A_BOLD|A_UNDERLINE)
+        """
+        self.fg = fg
+        self.bg = bg
+        self.attrs = attrs
+
+    def __call__(self, *args):
+        text = Text()
+        for arg in args:
+            if isinstance(arg, Text):
+                text.extend(arg)
+            else:
+                text.append((self, arg))
+        return text
+
+    def __eq__(self, other):
+        return self.fg == other.fg and self.bg == other.bg and self.attrs == other.attrs
+
+    def __neq__(self, other):
+        return self.fg != other.fg or self.bg != other.bg or self.attrs != other.attrs
+
+    def __repr__(self):
+        color2name = ("black", "red", "green", "yellow", "blue", "magenta", "cyan", "white")
+        attrs2name = ("blink", "bold", "dim", "reverse", "standout", "underline")
+
+        return "<%s fg=%s bg=%s attrs=%s>" % (
+            self.__class__.__name__, color2name[self.fg], color2name[self.bg],
+            "|".join([attrs2name[b] for b in xrange(6) if self.attrs&(1<<b)]) or 0)
+
+    def fromstr(cls, value):
+        """
+        Create a ``Style`` object from a string. The format looks like this:
+        ``"red:black:bold|blink"``.
+        """
+        # defaults
+        fg = COLOR_WHITE
+        bg = COLOR_BLACK
+        attrs = 0
+
+        parts = value.split(":")
+        if len(parts) > 0:
+            fg = cls.COLORNAMES[parts[0].lower()]
+            if len(parts) > 1:
+                bg = cls.COLORNAMES[parts[1].lower()]
+                if len(parts) > 2:
+                    for strattr in parts[2].split("|"):
+                        attrs |= cls.ATTRNAMES[strattr.lower()]
+        return cls(fg, bg, attrs)
+    fromstr = classmethod(fromstr)
+
+    def fromenv(cls, name, default):
+        """
+        Create a ``Style`` from an environment variable named ``name``
+        (using ``default`` if the environment variable doesn't exist).
+        """
+        return cls.fromstr(os.environ.get(name, default))
+    fromenv = classmethod(fromenv)
+
+
+def switchstyle(s1, s2):
+    """
+    Return the ANSI escape sequence needed to switch from style ``s1`` to
+    style ``s2``.
+    """
+    attrmask = (A_BLINK|A_BOLD|A_UNDERLINE|A_REVERSE)
+    a1 = s1.attrs & attrmask
+    a2 = s2.attrs & attrmask
+
+    args = []
+    if s1 != s2:
+        # do we have to get rid of the bold/underline/blink bit?
+        # (can only be done by a reset)
+        # use reset when our target color is the default color
+        # (this is shorter than 37;40)
+        if (a1 & ~a2 or s2==style_default):
+            args.append("0")
+            s1 = style_default
+            a1 = 0
+
+        # now we know that old and new color have the same boldness,
+        # or the new color is bold and the old isn't,
+        # i.e. we only might have to switch bold on, not off
+        if not (a1 & A_BOLD) and (a2 & A_BOLD):
+            args.append("1")
+
+        # Fix underline
+        if not (a1 & A_UNDERLINE) and (a2 & A_UNDERLINE):
+            args.append("4")
+
+        # Fix blink
+        if not (a1 & A_BLINK) and (a2 & A_BLINK):
+            args.append("5")
+
+        # Fix reverse
+        if not (a1 & A_REVERSE) and (a2 & A_REVERSE):
+            args.append("7")
+
+        # Fix foreground color
+        if s1.fg != s2.fg:
+            args.append("3%d" % s2.fg)
+
+        # Finally fix the background color
+        if s1.bg != s2.bg:
+            args.append("4%d" % s2.bg)
+
+        if args:
+            return "\033[%sm" % ";".join(args)
+    return ""
+
+
+class Text(list):
+    """
+    A colored string. A ``Text`` object is a sequence, the sequence
+    items will be ``(style, string)`` tuples.
+    """
+
+    def __init__(self, *args):
+        list.__init__(self)
+        self.append(*args)
+
+    def __repr__(self):
+        return "%s.%s(%s)" % (
+            self.__class__.__module__, self.__class__.__name__,
+            list.__repr__(self)[1:-1])
+
+    def append(self, *args):
+        for arg in args:
+            if isinstance(arg, Text):
+                self.extend(arg)
+            elif isinstance(arg, tuple): # must be (style, string)
+                list.append(self, arg)
+            elif isinstance(arg, unicode):
+                list.append(self, (style_default, arg))
+            else:
+                list.append(self, (style_default, str(arg)))
+
+    def insert(self, index, *args):
+        self[index:index] = Text(*args)
+
+    def __add__(self, other):
+        new = Text()
+        new.append(self)
+        new.append(other)
+        return new
+
+    def __iadd__(self, other):
+        self.append(other)
+        return self
+
+    def format(self, styled=True):
+        """
+        This generator yields the strings that will make up the final
+        colorized string.
+        """
+        if styled:
+            oldstyle = style_default
+            for (style, string) in self:
+                if not isinstance(style, (int, long)):
+                    switch = switchstyle(oldstyle, style)
+                    if switch:
+                        yield switch
+                    if string:
+                        yield string
+                    oldstyle = style
+            switch = switchstyle(oldstyle, style_default)
+            if switch:
+                yield switch
+        else:
+            for (style, string) in self:
+                if not isinstance(style, (int, long)):
+                    yield string
+
+    def string(self, styled=True):
+        """
+        Return the resulting string (with escape sequences, if ``styled``
+        is true).
+        """
+        return "".join(self.format(styled))
+
+    def __str__(self):
+        """
+        Return ``self`` as a string (without ANSI escape sequences).
+        """
+        return self.string(False)
+
+    def write(self, stream, styled=True):
+        """
+        Write ``self`` to the output stream ``stream`` (with escape sequences,
+        if ``styled`` is true).
+        """
+        for part in self.format(styled):
+            stream.write(part)
+
+
+try:
+    import ipipe
+except ImportError:
+    pass
+else:
+    def xrepr_astyle_text(self, mode="default"):
+        yield (-1, True)
+        for info in self:
+            yield info
+    ipipe.xrepr.when_type(Text)(xrepr_astyle_text)
+
+
+def streamstyle(stream, styled=None):
+    """
+    If ``styled`` is ``None``, return whether ``stream`` refers to a terminal.
+    If this can't be determined (either because ``stream`` doesn't refer to a
+    real OS file, or because you're on Windows) return ``False``. If ``styled``
+    is not ``None`` ``styled`` will be returned unchanged.
+    """
+    if styled is None:
+        try:
+            styled = os.isatty(stream.fileno())
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception:
+            styled = False
+    return styled
+
+
+def write(stream, styled, *texts):
+    """
+    Write ``texts`` to ``stream``.
+    """
+    text = Text(*texts)
+    text.write(stream, streamstyle(stream, styled))
+
+
+def writeln(stream, styled, *texts):
+    """
+    Write ``texts`` to ``stream`` and finish with a line feed.
+    """
+    write(stream, styled, *texts)
+    stream.write("\n")
+
+
+class Stream(object):
+    """
+    Stream wrapper that adds color output.
+    """
+    def __init__(self, stream, styled=None):
+        self.stream = stream
+        self.styled = streamstyle(stream, styled)
+
+    def write(self, *texts):
+        write(self.stream, self.styled, *texts)
+
+    def writeln(self, *texts):
+        writeln(self.stream, self.styled, *texts)
+
+    def __getattr__(self, name):
+        return getattr(self.stream, name)
+
+
+class stdout(object):
+    """
+    Stream wrapper for ``sys.stdout`` that adds color output.
+    """
+    def write(self, *texts):
+        write(sys.stdout, None, *texts)
+
+    def writeln(self, *texts):
+        writeln(sys.stdout, None, *texts)
+
+    def __getattr__(self, name):
+        return getattr(sys.stdout, name)
+stdout = stdout()
+
+
+class stderr(object):
+    """
+    Stream wrapper for ``sys.stderr`` that adds color output.
+    """
+    def write(self, *texts):
+        write(sys.stderr, None, *texts)
+
+    def writeln(self, *texts):
+        writeln(sys.stderr, None, *texts)
+
+    def __getattr__(self, name):
+        return getattr(sys.stdout, name)
+stderr = stderr()
+
+
+if curses is not None:
+    # This is probably just range(8)
+    COLOR2CURSES = [
+        COLOR_BLACK,
+        COLOR_RED,
+        COLOR_GREEN,
+        COLOR_YELLOW,
+        COLOR_BLUE,
+        COLOR_MAGENTA,
+        COLOR_CYAN,
+        COLOR_WHITE,
+    ]
+
+    A2CURSES = {
+        A_BLINK: curses.A_BLINK,
+        A_BOLD: curses.A_BOLD,
+        A_DIM: curses.A_DIM,
+        A_REVERSE: curses.A_REVERSE,
+        A_STANDOUT: curses.A_STANDOUT,
+        A_UNDERLINE: curses.A_UNDERLINE,
+    }
+
+
+# default style
+style_default = Style.fromstr("white:black")
+
+# Styles for datatypes
+style_type_none = Style.fromstr("magenta:black")
+style_type_bool = Style.fromstr("magenta:black")
+style_type_number = Style.fromstr("yellow:black")
+style_type_datetime = Style.fromstr("magenta:black")
+style_type_type = Style.fromstr("cyan:black")
+
+# Style for URLs and file/directory names
+style_url = Style.fromstr("green:black")
+style_dir = Style.fromstr("cyan:black")
+style_file = Style.fromstr("green:black")
+
+# Style for ellipsis (when an output has been shortened
+style_ellisis = Style.fromstr("red:black")
+
+# Style for displaying exceptions
+style_error = Style.fromstr("red:black")
+
+# Style for displaying non-existing attributes
+style_nodata = Style.fromstr("red:black")
diff --git a/IPython/Extensions/clearcmd.py b/IPython/Extensions/clearcmd.py
new file mode 100644
index 0000000..49fbd59
--- /dev/null
+++ b/IPython/Extensions/clearcmd.py
@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+""" IPython extension: add %clear magic """
+
+import IPython.ipapi
+import gc
+ip = IPython.ipapi.get()
+
+
+def clear_f(self,arg):
+    """ Clear various data (e.g. stored history data)
+    
+    %clear out - clear output history
+    %clear in  - clear input history
+    %clear shadow_compress - Compresses shadow history (to speed up ipython)
+    %clear shadow_nuke - permanently erase all entries in shadow history
+    %clear dhist - clear dir history
+    """
+    
+    api = self.getapi()
+    for target in arg.split():
+        if target == 'out':
+            print "Flushing output cache (%d entries)" % len(api.user_ns['_oh'])
+            self.outputcache.flush()
+        elif target == 'in':
+            print "Flushing input history"
+            from IPython import iplib
+            pc = self.outputcache.prompt_count + 1
+            for n in range(1, pc):
+                key = '_i'+`n`
+                try:
+                    del self.user_ns[key]
+                except: pass
+            # must be done in-place
+            self.input_hist[:] = ['\n'] * pc 
+            self.input_hist_raw[:] = ['\n'] * pc
+        elif target == 'array':
+            try:
+                pylab=ip.IP.pylab
+                for x in self.user_ns.keys():
+                    if isinstance(self.user_ns[x],pylab.arraytype):
+                        del self.user_ns[x]
+            except AttributeError:
+                print "Clear array only available in -pylab mode"
+            gc.collect()                
+
+        elif target == 'shadow_compress':
+            print "Compressing shadow history"
+            api.db.hcompress('shadowhist')
+            
+        elif target == 'shadow_nuke':
+            print "Erased all keys from shadow history "
+            for k in ip.db.keys('shadowhist/*'):
+                del ip.db[k]
+        elif target == 'dhist':
+            print "Clearing directory history"
+            del ip.user_ns['_dh'][:]
+
+            
+ip.expose_magic("clear",clear_f)
+import ipy_completers
+ipy_completers.quick_completer(
+ '%clear','in out shadow_nuke shadow_compress dhist')
+    
+
+
+
diff --git a/IPython/Extensions/envpersist.py b/IPython/Extensions/envpersist.py
new file mode 100644
index 0000000..ee4c139
--- /dev/null
+++ b/IPython/Extensions/envpersist.py
@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+""" %env magic command for storing environment variables persistently
+"""
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import os,sys
+
+def restore_env(self):    
+    ip = self.getapi()
+    env = ip.db.get('stored_env', {'set' : {}, 'add' : [], 'pre' : []})
+    for k,v in env['set'].items():
+        os.environ[k] = v
+    for k,v in env['add']:
+        os.environ[k] = os.environ.get(k,"") + v
+    for k,v in env['pre']:
+        os.environ[k] = v + os.environ.get(k,"")
+    raise IPython.ipapi.TryNext
+  
+ip.set_hook('late_startup_hook', restore_env)
+
+def persist_env(self, parameter_s=''):
+    """ Store environment variables persistently
+    
+    IPython remembers the values across sessions, which is handy to avoid 
+    editing startup files.
+    
+    %env - Show all environment variables
+    %env VISUAL=jed  - set VISUAL to jed
+    %env PATH+=;/foo - append ;foo to PATH
+    %env PATH+=;/bar - also append ;bar to PATH
+    %env PATH-=/wbin; - prepend /wbin; to PATH
+    %env -d VISUAL   - forget VISUAL persistent val
+    %env -p          - print all persistent env modifications 
+    """
+    
+    if not parameter_s.strip():
+        return os.environ.data
+    
+    ip = self.getapi()
+    db = ip.db
+    env = ip.db.get('stored_env', {'set' : {}, 'add' : [], 'pre' : []})
+
+    if parameter_s.startswith('-p'):
+        return env
+        
+    elif parameter_s.startswith('-d'):
+        parts = (parameter_s.split()[1], '<del>')
+        
+    else:
+        parts = parameter_s.strip().split('=')    
+    
+    if len(parts) == 2:
+        k,v = [p.strip() for p in parts]
+    
+    if v == '<del>':
+        if k in env['set']:
+            del env['set'][k]
+        env['add'] = [el for el in env['add'] if el[0] != k]
+        env['pre'] = [el for el in env['pre'] if el[0] != k]
+        
+        print "Forgot '%s' (for next session)" % k
+        
+    elif k.endswith('+'):
+        k = k[:-1]
+        env['add'].append((k,v))
+        os.environ[k] += v
+        print k,"after append =",os.environ[k]
+    elif k.endswith('-'):
+        k = k[:-1]
+        env['pre'].append((k,v))
+        os.environ[k] = v + os.environ.get(k,"")
+        print k,"after prepend =",os.environ[k]
+        
+        
+    else:
+        env['set'][k] = v
+        print "Setting",k,"to",v
+        os.environ[k] = v
+        
+    db['stored_env'] = env
+
+def env_completer(self,event):
+    """ Custom completer that lists all env vars """
+    return os.environ.keys()
+
+ip.expose_magic('env', persist_env)
+ip.set_hook('complete_command',env_completer, str_key = '%env')
+
diff --git a/IPython/Extensions/ext_rescapture.py b/IPython/Extensions/ext_rescapture.py
new file mode 100644
index 0000000..eae7cb9
--- /dev/null
+++ b/IPython/Extensions/ext_rescapture.py
@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+""" IPython extension: new prefilters for output grabbing 
+
+Provides 
+
+var = %magic blah blah
+
+var = !ls
+
+$Id: genutils.py 1077 2006-01-24 18:15:27Z vivainio $
+
+"""
+
+import IPython.ipapi
+from IPython.genutils import *
+
+ip = IPython.ipapi.get()
+
+import re
+
+def hnd_magic(line,mo):
+    """ Handle a = %mymagic blah blah """
+    #cmd = genutils.make_quoted_expr(mo.group('syscmd'))
+    #mag = 'ipmagic
+    #return "%s = %s"
+    var = mo.group('varname')
+    cmd = mo.group('cmd')
+    expr = make_quoted_expr(cmd)
+    return itpl('$var = _ip.magic($expr)')
+
+def hnd_syscmd(line,mo):
+    """ Handle a = !ls """
+    #cmd = genutils.make_quoted_expr(mo.group('syscmd'))
+    #mag = 'ipmagic
+    #return "%s = %s"
+    var = mo.group('varname')
+    cmd = mo.group('cmd')
+    expr = make_quoted_expr(itpl("sc -l =$cmd"))
+    return itpl('$var = _ip.magic($expr)')
+
+def install_re_handler(pat, hnd):
+    ip.meta.re_prefilters.append((re.compile(pat), hnd))
+
+def init_handlers():
+
+    ip.meta.re_prefilters = []
+
+    install_re_handler('(?P<varname>[\w\.]+)\s*=\s*%(?P<cmd>.*)',
+                       hnd_magic
+                       )
+    
+    install_re_handler('(?P<varname>[\w\.]+)\s*=\s*!(?P<cmd>.*)',
+                       hnd_syscmd
+                       )
+
+init_handlers()
+
+def regex_prefilter_f(self,line):    
+    for pat, handler in ip.meta.re_prefilters:
+        mo = pat.match(line)
+        if mo:
+            return handler(line,mo)
+    
+    raise IPython.ipapi.TryNext
+
+ip.set_hook('input_prefilter', regex_prefilter_f)     
diff --git a/IPython/Extensions/ibrowse.py b/IPython/Extensions/ibrowse.py
new file mode 100644
index 0000000..68a07c1
--- /dev/null
+++ b/IPython/Extensions/ibrowse.py
@@ -0,0 +1,1767 @@
+# -*- coding: iso-8859-1 -*-
+
+import curses, fcntl, signal, struct, tty, textwrap, inspect
+
+from IPython import ipapi
+
+import astyle, ipipe
+
+
+# Python 2.3 compatibility
+try:
+    set
+except NameError:
+    import sets
+    set = sets.Set
+
+# Python 2.3 compatibility
+try:
+    sorted
+except NameError:
+    from ipipe import sorted
+
+
+class UnassignedKeyError(Exception):
+    """
+    Exception that is used for reporting unassigned keys.
+    """
+
+
+class UnknownCommandError(Exception):
+    """
+    Exception that is used for reporting unknown commands (this should never
+    happen).
+    """
+
+
+class CommandError(Exception):
+    """
+    Exception that is used for reporting that a command can't be executed.
+    """
+
+
+class Keymap(dict):
+    """
+    Stores mapping of keys to commands.
+    """
+    def __init__(self):
+        self._keymap = {}
+
+    def __setitem__(self, key, command):
+        if isinstance(key, str):
+            for c in key:
+                dict.__setitem__(self, ord(c), command)
+        else:
+            dict.__setitem__(self, key, command)
+
+    def __getitem__(self, key):
+        if isinstance(key, str):
+            key = ord(key)
+        return dict.__getitem__(self, key)
+
+    def __detitem__(self, key):
+        if isinstance(key, str):
+            key = ord(key)
+        dict.__detitem__(self, key)
+
+    def register(self, command, *keys):
+        for key in keys:
+            self[key] = command
+
+    def get(self, key, default=None):
+        if isinstance(key, str):
+            key = ord(key)
+        return dict.get(self, key, default)
+
+    def findkey(self, command, default=ipipe.noitem):
+        for (key, commandcandidate) in self.iteritems():
+            if commandcandidate == command:
+                return key
+        if default is ipipe.noitem:
+            raise KeyError(command)
+        return default
+
+
+class _BrowserCachedItem(object):
+    # This is used internally by ``ibrowse`` to store a item together with its
+    # marked status.
+    __slots__ = ("item", "marked")
+
+    def __init__(self, item):
+        self.item = item
+        self.marked = False
+
+
+class _BrowserHelp(object):
+    style_header = astyle.Style.fromstr("yellow:black:bold")
+    # This is used internally by ``ibrowse`` for displaying the help screen.
+    def __init__(self, browser):
+        self.browser = browser
+
+    def __xrepr__(self, mode):
+        yield (-1, True)
+        if mode == "header" or mode == "footer":
+            yield (astyle.style_default, "ibrowse help screen")
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __iter__(self):
+        # Get reverse key mapping
+        allkeys = {}
+        for (key, cmd) in self.browser.keymap.iteritems():
+            allkeys.setdefault(cmd, []).append(key)
+
+        fields = ("key", "description")
+
+        commands = []
+        for name in dir(self.browser):
+            if name.startswith("cmd_"):
+                command = getattr(self.browser, name)
+                commands.append((inspect.getsourcelines(command)[-1], name[4:], command))
+        commands.sort()
+        commands = [(c[1], c[2]) for c in commands]
+        for (i, (name, command)) in enumerate(commands):
+            if i:
+                yield ipipe.Fields(fields, key="", description="")
+
+            description = command.__doc__
+            if description is None:
+                lines = []
+            else:
+                lines = [l.strip() for l in description.splitlines() if l.strip()]
+                description = "\n".join(lines)
+                lines = textwrap.wrap(description, 60)
+            keys = allkeys.get(name, [])
+
+            yield ipipe.Fields(fields, key="", description=astyle.Text((self.style_header, name)))
+            for i in xrange(max(len(keys), len(lines))):
+                try:
+                    key = self.browser.keylabel(keys[i])
+                except IndexError:
+                    key = ""
+                try:
+                    line = lines[i]
+                except IndexError:
+                    line = ""
+                yield ipipe.Fields(fields, key=key, description=line)
+
+
+class _BrowserLevel(object):
+    # This is used internally to store the state (iterator, fetch items,
+    # position of cursor and screen, etc.) of one browser level
+    # An ``ibrowse`` object keeps multiple ``_BrowserLevel`` objects in
+    # a stack.
+    def __init__(self, browser, input, mainsizey, *attrs):
+        self.browser = browser
+        self.input = input
+        self.header = [x for x in ipipe.xrepr(input, "header") if not isinstance(x[0], int)]
+        # iterator for the input
+        self.iterator = ipipe.xiter(input)
+
+        # is the iterator exhausted?
+        self.exhausted = False
+
+        # attributes to be display (autodetected if empty)
+        self.attrs = attrs
+
+        # fetched items (+ marked flag)
+        self.items = ipipe.deque()
+
+        # Number of marked objects
+        self.marked = 0
+
+        # Vertical cursor position
+        self.cury = 0
+
+        # Horizontal cursor position
+        self.curx = 0
+
+        # Index of first data column
+        self.datastartx = 0
+
+        # Index of first data line
+        self.datastarty = 0
+
+        # height of the data display area
+        self.mainsizey = mainsizey
+
+        # width of the data display area (changes when scrolling)
+        self.mainsizex = 0
+
+        # Size of row number (changes when scrolling)
+        self.numbersizex = 0
+
+        # Attributes to display (in this order)
+        self.displayattrs = []
+
+        # index and attribute under the cursor
+        self.displayattr = (None, ipipe.noitem)
+
+        # Maps attributes to column widths
+        self.colwidths = {}
+
+        # Set of hidden attributes
+        self.hiddenattrs = set()
+
+        # This takes care of all the caches etc.
+        self.moveto(0, 0, refresh=True)
+
+    def fetch(self, count):
+        # Try to fill ``self.items`` with at least ``count`` objects.
+        have = len(self.items)
+        while not self.exhausted and have < count:
+            try:
+                item = self.iterator.next()
+            except StopIteration:
+                self.exhausted = True
+                break
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, exc:
+                have += 1
+                self.items.append(_BrowserCachedItem(exc))
+                self.exhausted = True
+                break
+            else:
+                have += 1
+                self.items.append(_BrowserCachedItem(item))
+
+    def calcdisplayattrs(self):
+        # Calculate which attributes are available from the objects that are
+        # currently visible on screen (and store it in ``self.displayattrs``)
+
+        attrs = set()
+        self.displayattrs = []
+        if self.attrs:
+            # If the browser object specifies a fixed list of attributes,
+            # simply use it (removing hidden attributes).
+            for attr in self.attrs:
+                attr = ipipe.upgradexattr(attr)
+                if attr not in attrs and attr not in self.hiddenattrs:
+                    self.displayattrs.append(attr)
+                    attrs.add(attr)
+        else:
+            endy = min(self.datastarty+self.mainsizey, len(self.items))
+            for i in xrange(self.datastarty, endy):
+                for attr in ipipe.xattrs(self.items[i].item, "default"):
+                    if attr not in attrs and attr not in self.hiddenattrs:
+                        self.displayattrs.append(attr)
+                        attrs.add(attr)
+
+    def getrow(self, i):
+        # Return a dictionary with the attributes for the object
+        # ``self.items[i]``. Attribute names are taken from
+        # ``self.displayattrs`` so ``calcdisplayattrs()`` must have been
+        # called before.
+        row = {}
+        item = self.items[i].item
+        for attr in self.displayattrs:
+            try:
+                value = attr.value(item)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, exc:
+                value = exc
+            # only store attribute if it exists (or we got an exception)
+            if value is not ipipe.noitem:
+                # remember alignment, length and colored text
+                row[attr] = ipipe.xformat(value, "cell", self.browser.maxattrlength)
+        return row
+
+    def calcwidths(self):
+        # Recalculate the displayed fields and their widths.
+        # ``calcdisplayattrs()'' must have been called and the cache
+        # for attributes of the objects on screen (``self.displayrows``)
+        # must have been filled. This sets ``self.colwidths`` which maps
+        # attribute descriptors to widths.
+        self.colwidths = {}
+        for row in self.displayrows:
+            for attr in self.displayattrs:
+                try:
+                    length = row[attr][1]
+                except KeyError:
+                    length = 0
+                # always add attribute to colwidths, even if it doesn't exist
+                if attr not in self.colwidths:
+                    self.colwidths[attr] = len(attr.name())
+                newwidth = max(self.colwidths[attr], length)
+                self.colwidths[attr] = newwidth
+
+        # How many characters do we need to paint the largest item number?
+        self.numbersizex = len(str(self.datastarty+self.mainsizey-1))
+        # How must space have we got to display data?
+        self.mainsizex = self.browser.scrsizex-self.numbersizex-3
+        # width of all columns
+        self.datasizex = sum(self.colwidths.itervalues()) + len(self.colwidths)
+
+    def calcdisplayattr(self):
+        # Find out which attribute the cursor is on and store this
+        # information in ``self.displayattr``.
+        pos = 0
+        for (i, attr) in enumerate(self.displayattrs):
+            if pos+self.colwidths[attr] >= self.curx:
+                self.displayattr = (i, attr)
+                break
+            pos += self.colwidths[attr]+1
+        else:
+            self.displayattr = (None, ipipe.noitem)
+
+    def moveto(self, x, y, refresh=False):
+        # Move the cursor to the position ``(x,y)`` (in data coordinates,
+        # not in screen coordinates). If ``refresh`` is true, all cached
+        # values will be recalculated (e.g. because the list has been
+        # resorted, so screen positions etc. are no longer valid).
+        olddatastarty = self.datastarty
+        oldx = self.curx
+        oldy = self.cury
+        x = int(x+0.5)
+        y = int(y+0.5)
+        newx = x # remember where we wanted to move
+        newy = y # remember where we wanted to move
+
+        scrollbordery = min(self.browser.scrollbordery, self.mainsizey//2)
+        scrollborderx = min(self.browser.scrollborderx, self.mainsizex//2)
+
+        # Make sure that the cursor didn't leave the main area vertically
+        if y < 0:
+            y = 0
+        # try to get enough items to fill the screen
+        self.fetch(max(y+scrollbordery+1, self.mainsizey))
+        if y >= len(self.items):
+            y = max(0, len(self.items)-1)
+
+        # Make sure that the cursor stays on screen vertically
+        if y < self.datastarty+scrollbordery:
+            self.datastarty = max(0, y-scrollbordery)
+        elif y >= self.datastarty+self.mainsizey-scrollbordery:
+            self.datastarty = max(0, min(y-self.mainsizey+scrollbordery+1,
+                                         len(self.items)-self.mainsizey))
+
+        if refresh: # Do we need to refresh the complete display?
+            self.calcdisplayattrs()
+            endy = min(self.datastarty+self.mainsizey, len(self.items))
+            self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
+            self.calcwidths()
+        # Did we scroll vertically => update displayrows
+        # and various other attributes
+        elif self.datastarty != olddatastarty:
+            # Recalculate which attributes we have to display
+            olddisplayattrs = self.displayattrs
+            self.calcdisplayattrs()
+            # If there are new attributes, recreate the cache
+            if self.displayattrs != olddisplayattrs:
+                endy = min(self.datastarty+self.mainsizey, len(self.items))
+                self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
+            elif self.datastarty<olddatastarty: # we did scroll up
+                # drop rows from the end
+                del self.displayrows[self.datastarty-olddatastarty:]
+                # fetch new items
+                for i in xrange(min(olddatastarty, self.datastarty+self.mainsizey)-1,
+                                self.datastarty-1, -1):
+                    try:
+                        row = self.getrow(i)
+                    except IndexError:
+                        # we didn't have enough objects to fill the screen
+                        break
+                    self.displayrows.insert(0, row)
+            else: # we did scroll down
+                # drop rows from the start
+                del self.displayrows[:self.datastarty-olddatastarty]
+                # fetch new items
+                for i in xrange(max(olddatastarty+self.mainsizey, self.datastarty),
+                                self.datastarty+self.mainsizey):
+                    try:
+                        row = self.getrow(i)
+                    except IndexError:
+                        # we didn't have enough objects to fill the screen
+                        break
+                    self.displayrows.append(row)
+            self.calcwidths()
+
+        # Make sure that the cursor didn't leave the data area horizontally
+        if x < 0:
+            x = 0
+        elif x >= self.datasizex:
+            x = max(0, self.datasizex-1)
+
+        # Make sure that the cursor stays on screen horizontally
+        if x < self.datastartx+scrollborderx:
+            self.datastartx = max(0, x-scrollborderx)
+        elif x >= self.datastartx+self.mainsizex-scrollborderx:
+            self.datastartx = max(0, min(x-self.mainsizex+scrollborderx+1,
+                                         self.datasizex-self.mainsizex))
+
+        if x == oldx and y == oldy and (x != newx or y != newy): # couldn't move
+            self.browser.beep()
+        else:
+            self.curx = x
+            self.cury = y
+            self.calcdisplayattr()
+
+    def sort(self, key, reverse=False):
+        """
+        Sort the currently list of items using the key function ``key``. If
+        ``reverse`` is true the sort order is reversed.
+        """
+        curitem = self.items[self.cury] # Remember where the cursor is now
+
+        # Sort items
+        def realkey(item):
+            return key(item.item)
+        self.items = ipipe.deque(sorted(self.items, key=realkey, reverse=reverse))
+
+        # Find out where the object under the cursor went
+        cury = self.cury
+        for (i, item) in enumerate(self.items):
+            if item is curitem:
+                cury = i
+                break
+
+        self.moveto(self.curx, cury, refresh=True)
+
+    def refresh(self):
+        """
+        Restart iterating the input.
+        """
+        self.iterator = ipipe.xiter(self.input)
+        self.items.clear()
+        self.exhausted = False
+        self.datastartx = self.datastarty = 0
+        self.moveto(0, 0, refresh=True)
+
+    def refreshfind(self):
+        """
+        Restart iterating the input and go back to the same object as before
+        (if it can be found in the new iterator).
+        """
+        try:
+            oldobject = self.items[self.cury].item
+        except IndexError:
+            oldobject = ipipe.noitem
+        self.iterator = ipipe.xiter(self.input)
+        self.items.clear()
+        self.exhausted = False
+        while True:
+            self.fetch(len(self.items)+1)
+            if self.exhausted:
+                curses.beep()
+                self.datastartx = self.datastarty = 0
+                self.moveto(self.curx, 0, refresh=True)
+                break
+            if self.items[-1].item == oldobject:
+                self.datastartx = self.datastarty = 0
+                self.moveto(self.curx, len(self.items)-1, refresh=True)
+                break
+
+
+class _CommandInput(object):
+    keymap = Keymap()
+    keymap.register("left", curses.KEY_LEFT)
+    keymap.register("right", curses.KEY_RIGHT)
+    keymap.register("home", curses.KEY_HOME, "\x01") # Ctrl-A
+    keymap.register("end", curses.KEY_END, "\x05") # Ctrl-E
+    # FIXME: What's happening here?
+    keymap.register("backspace", curses.KEY_BACKSPACE, "\x08\x7f")
+    keymap.register("delete", curses.KEY_DC)
+    keymap.register("delend", 0x0b) # Ctrl-K
+    keymap.register("execute", "\r\n")
+    keymap.register("up", curses.KEY_UP)
+    keymap.register("down", curses.KEY_DOWN)
+    keymap.register("incsearchup", curses.KEY_PPAGE)
+    keymap.register("incsearchdown", curses.KEY_NPAGE)
+    keymap.register("exit", "\x18"), # Ctrl-X
+
+    def __init__(self, prompt):
+        self.prompt = prompt
+        self.history = []
+        self.maxhistory = 100
+        self.input = ""
+        self.curx = 0
+        self.cury = -1 # blank line
+
+    def start(self):
+        self.input = ""
+        self.curx = 0
+        self.cury = -1 # blank line
+
+    def handlekey(self, browser, key):
+        cmdname = self.keymap.get(key, None)
+        if cmdname is not None:
+            cmdfunc = getattr(self, "cmd_%s" % cmdname, None)
+            if cmdfunc is not None:
+                return cmdfunc(browser)
+            curses.beep()
+        elif key != -1:
+            try:
+                char = chr(key)
+            except ValueError:
+                curses.beep()
+            else:
+                return self.handlechar(browser, char)
+
+    def handlechar(self, browser, char):
+        self.input = self.input[:self.curx] + char + self.input[self.curx:]
+        self.curx += 1
+        return True
+
+    def dohistory(self):
+        self.history.insert(0, self.input)
+        del self.history[:-self.maxhistory]
+
+    def cmd_backspace(self, browser):
+        if self.curx:
+            self.input = self.input[:self.curx-1] + self.input[self.curx:]
+            self.curx -= 1
+            return True
+        else:
+            curses.beep()
+
+    def cmd_delete(self, browser):
+        if self.curx<len(self.input):
+            self.input = self.input[:self.curx] + self.input[self.curx+1:]
+            return True
+        else:
+            curses.beep()
+
+    def cmd_delend(self, browser):
+        if self.curx<len(self.input):
+            self.input = self.input[:self.curx]
+            return True
+
+    def cmd_left(self, browser):
+        if self.curx:
+            self.curx -= 1
+            return True
+        else:
+            curses.beep()
+
+    def cmd_right(self, browser):
+        if self.curx < len(self.input):
+            self.curx += 1
+            return True
+        else:
+            curses.beep()
+
+    def cmd_home(self, browser):
+        if self.curx:
+            self.curx = 0
+            return True
+        else:
+            curses.beep()
+
+    def cmd_end(self, browser):
+        if self.curx < len(self.input):
+            self.curx = len(self.input)
+            return True
+        else:
+            curses.beep()
+
+    def cmd_up(self, browser):
+        if self.cury < len(self.history)-1:
+            self.cury += 1
+            self.input = self.history[self.cury]
+            self.curx = len(self.input)
+            return True
+        else:
+            curses.beep()
+
+    def cmd_down(self, browser):
+        if self.cury >= 0:
+            self.cury -= 1
+            if self.cury>=0:
+                self.input = self.history[self.cury]
+            else:
+                self.input = ""
+            self.curx = len(self.input)
+            return True
+        else:
+            curses.beep()
+
+    def cmd_incsearchup(self, browser):
+        prefix = self.input[:self.curx]
+        cury = self.cury
+        while True:
+            cury += 1
+            if cury >= len(self.history):
+                break
+            if self.history[cury].startswith(prefix):
+                self.input = self.history[cury]
+                self.cury = cury
+                return True
+        curses.beep()
+
+    def cmd_incsearchdown(self, browser):
+        prefix = self.input[:self.curx]
+        cury = self.cury
+        while True:
+            cury -= 1
+            if cury <= 0:
+                break
+            if self.history[cury].startswith(prefix):
+                self.input = self.history[self.cury]
+                self.cury = cury
+                return True
+        curses.beep()
+
+    def cmd_exit(self, browser):
+        browser.mode = "default"
+        return True
+
+    def cmd_execute(self, browser):
+        raise NotImplementedError
+
+
+class _CommandGoto(_CommandInput):
+    def __init__(self):
+        _CommandInput.__init__(self, "goto object #")
+
+    def handlechar(self, browser, char):
+        # Only accept digits
+        if not "0" <= char <= "9":
+            curses.beep()
+        else:
+            return _CommandInput.handlechar(self, browser, char)
+
+    def cmd_execute(self, browser):
+        level = browser.levels[-1]
+        if self.input:
+            self.dohistory()
+            level.moveto(level.curx, int(self.input))
+        browser.mode = "default"
+        return True
+
+
+class _CommandFind(_CommandInput):
+    def __init__(self):
+        _CommandInput.__init__(self, "find expression")
+
+    def cmd_execute(self, browser):
+        level = browser.levels[-1]
+        if self.input:
+            self.dohistory()
+            while True:
+                cury = level.cury
+                level.moveto(level.curx, cury+1)
+                if cury == level.cury:
+                    curses.beep()
+                    break # hit end
+                item = level.items[level.cury].item
+                try:
+                    globals = ipipe.getglobals(None)
+                    if eval(self.input, globals, ipipe.AttrNamespace(item)):
+                        break # found something
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except Exception, exc:
+                    browser.report(exc)
+                    curses.beep()
+                    break  # break on error
+        browser.mode = "default"
+        return True
+
+
+class _CommandFindBackwards(_CommandInput):
+    def __init__(self):
+        _CommandInput.__init__(self, "find backwards expression")
+
+    def cmd_execute(self, browser):
+        level = browser.levels[-1]
+        if self.input:
+            self.dohistory()
+            while level.cury:
+                level.moveto(level.curx, level.cury-1)
+                item = level.items[level.cury].item
+                try:
+                    globals = ipipe.getglobals(None)
+                    if eval(self.input, globals, ipipe.AttrNamespace(item)):
+                        break # found something
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except Exception, exc:
+                    browser.report(exc)
+                    curses.beep()
+                    break # break on error
+            else:
+                curses.beep()
+        browser.mode = "default"
+        return True
+
+
+class ibrowse(ipipe.Display):
+    # Show this many lines from the previous screen when paging horizontally
+    pageoverlapx = 1
+
+    # Show this many lines from the previous screen when paging vertically
+    pageoverlapy = 1
+
+    # Start scrolling when the cursor is less than this number of columns
+    # away from the left or right screen edge
+    scrollborderx = 10
+
+    # Start scrolling when the cursor is less than this number of lines
+    # away from the top or bottom screen edge
+    scrollbordery = 5
+
+    # Accelerate by this factor when scrolling horizontally
+    acceleratex = 1.05
+
+    # Accelerate by this factor when scrolling vertically
+    acceleratey = 1.05
+
+    # The maximum horizontal scroll speed
+    # (as a factor of the screen width (i.e. 0.5 == half a screen width)
+    maxspeedx = 0.5
+
+    # The maximum vertical scroll speed
+    # (as a factor of the screen height (i.e. 0.5 == half a screen height)
+    maxspeedy = 0.5
+
+    # The maximum number of header lines for browser level
+    # if the nesting is deeper, only the innermost levels are displayed
+    maxheaders = 5
+
+    # The approximate maximum length of a column entry
+    maxattrlength = 200
+
+    # Styles for various parts of the GUI
+    style_objheadertext = astyle.Style.fromstr("white:black:bold|reverse")
+    style_objheadernumber = astyle.Style.fromstr("white:blue:bold|reverse")
+    style_objheaderobject = astyle.Style.fromstr("white:black:reverse")
+    style_colheader = astyle.Style.fromstr("blue:white:reverse")
+    style_colheaderhere = astyle.Style.fromstr("green:black:bold|reverse")
+    style_colheadersep = astyle.Style.fromstr("blue:black:reverse")
+    style_number = astyle.Style.fromstr("blue:white:reverse")
+    style_numberhere = astyle.Style.fromstr("green:black:bold|reverse")
+    style_sep = astyle.Style.fromstr("blue:black")
+    style_data = astyle.Style.fromstr("white:black")
+    style_datapad = astyle.Style.fromstr("blue:black:bold")
+    style_footer = astyle.Style.fromstr("black:white")
+    style_report = astyle.Style.fromstr("white:black")
+
+    # Column separator in header
+    headersepchar = "|"
+
+    # Character for padding data cell entries
+    datapadchar = "."
+
+    # Column separator in data area
+    datasepchar = "|"
+
+    # Character to use for "empty" cell (i.e. for non-existing attributes)
+    nodatachar = "-"
+
+    # Prompts for modes that require keyboard input
+    prompts = {
+        "goto": _CommandGoto(),
+        "find": _CommandFind(),
+        "findbackwards": _CommandFindBackwards()
+    }
+
+    # Maps curses key codes to "function" names
+    keymap = Keymap()
+    keymap.register("quit", "q")
+    keymap.register("up", curses.KEY_UP)
+    keymap.register("down", curses.KEY_DOWN)
+    keymap.register("pageup", curses.KEY_PPAGE)
+    keymap.register("pagedown", curses.KEY_NPAGE)
+    keymap.register("left", curses.KEY_LEFT)
+    keymap.register("right", curses.KEY_RIGHT)
+    keymap.register("home", curses.KEY_HOME, "\x01")
+    keymap.register("end", curses.KEY_END, "\x05")
+    keymap.register("prevattr", "<\x1b")
+    keymap.register("nextattr", ">\t")
+    keymap.register("pick", "p")
+    keymap.register("pickattr", "P")
+    keymap.register("pickallattrs", "C")
+    keymap.register("pickmarked", "m")
+    keymap.register("pickmarkedattr", "M")
+    keymap.register("pickinput", "i")
+    keymap.register("pickinputattr", "I")
+    keymap.register("hideattr", "h")
+    keymap.register("unhideattrs", "H")
+    keymap.register("help", "?")
+    keymap.register("enter", "\r\n")
+    keymap.register("enterattr", "E")
+    # FIXME: What's happening here?
+    keymap.register("leave", curses.KEY_BACKSPACE, "x\x08\x7f")
+    keymap.register("detail", "d")
+    keymap.register("detailattr", "D")
+    keymap.register("tooglemark", " ")
+    keymap.register("markrange", "%")
+    keymap.register("sortattrasc", "v")
+    keymap.register("sortattrdesc", "V")
+    keymap.register("goto", "g")
+    keymap.register("find", "f")
+    keymap.register("findbackwards", "b")
+    keymap.register("refresh", "r")
+    keymap.register("refreshfind", "R")
+
+    def __init__(self, input=None, *attrs):
+        """
+        Create a new browser. If ``attrs`` is not empty, it is the list
+        of attributes that will be displayed in the browser, otherwise
+        these will be determined by the objects on screen.
+        """
+        ipipe.Display.__init__(self, input)
+
+        self.attrs = attrs
+
+        # Stack of browser levels
+        self.levels = []
+        # how many colums to scroll (Changes when accelerating)
+        self.stepx = 1.
+
+        # how many rows to scroll (Changes when accelerating)
+        self.stepy = 1.
+
+        # Beep on the edges of the data area? (Will be set to ``False``
+        # once the cursor hits the edge of the screen, so we don't get
+        # multiple beeps).
+        self._dobeep = True
+
+        # Cache for registered ``curses`` colors and styles.
+        self._styles = {}
+        self._colors = {}
+        self._maxcolor = 1
+
+        # How many header lines do we want to paint (the numbers of levels
+        # we have, but with an upper bound)
+        self._headerlines = 1
+
+        # Index of first header line
+        self._firstheaderline = 0
+
+        # curses window
+        self.scr = None
+        # report in the footer line (error, executed command etc.)
+        self._report = None
+
+        # value to be returned to the caller (set by commands)
+        self.returnvalue = None
+
+        # The mode the browser is in
+        # e.g. normal browsing or entering an argument for a command
+        self.mode = "default"
+
+        # set by the SIGWINCH signal handler
+        self.resized = False
+
+    def nextstepx(self, step):
+        """
+        Accelerate horizontally.
+        """
+        return max(1., min(step*self.acceleratex,
+                           self.maxspeedx*self.levels[-1].mainsizex))
+
+    def nextstepy(self, step):
+        """
+        Accelerate vertically.
+        """
+        return max(1., min(step*self.acceleratey,
+                           self.maxspeedy*self.levels[-1].mainsizey))
+
+    def getstyle(self, style):
+        """
+        Register the ``style`` with ``curses`` or get it from the cache,
+        if it has been registered before.
+        """
+        try:
+            return self._styles[style.fg, style.bg, style.attrs]
+        except KeyError:
+            attrs = 0
+            for b in astyle.A2CURSES:
+                if style.attrs & b:
+                    attrs |= astyle.A2CURSES[b]
+            try:
+                color = self._colors[style.fg, style.bg]
+            except KeyError:
+                curses.init_pair(
+                    self._maxcolor,
+                    astyle.COLOR2CURSES[style.fg],
+                    astyle.COLOR2CURSES[style.bg]
+                )
+                color = curses.color_pair(self._maxcolor)
+                self._colors[style.fg, style.bg] = color
+                self._maxcolor += 1
+            c = color | attrs
+            self._styles[style.fg, style.bg, style.attrs] = c
+            return c
+
+    def addstr(self, y, x, begx, endx, text, style):
+        """
+        A version of ``curses.addstr()`` that can handle ``x`` coordinates
+        that are outside the screen.
+        """
+        text2 = text[max(0, begx-x):max(0, endx-x)]
+        if text2:
+            self.scr.addstr(y, max(x, begx), text2, self.getstyle(style))
+        return len(text)
+
+    def addchr(self, y, x, begx, endx, c, l, style):
+        x0 = max(x, begx)
+        x1 = min(x+l, endx)
+        if x1>x0:
+            self.scr.addstr(y, x0, c*(x1-x0), self.getstyle(style))
+        return l
+
+    def _calcheaderlines(self, levels):
+        # Calculate how many headerlines do we have to display, if we have
+        # ``levels`` browser levels
+        if levels is None:
+            levels = len(self.levels)
+        self._headerlines = min(self.maxheaders, levels)
+        self._firstheaderline = levels-self._headerlines
+
+    def getstylehere(self, style):
+        """
+        Return a style for displaying the original style ``style``
+        in the row the cursor is on.
+        """
+        return astyle.Style(style.fg, astyle.COLOR_BLUE, style.attrs | astyle.A_BOLD)
+
+    def report(self, msg):
+        """
+        Store the message ``msg`` for display below the footer line. This
+        will be displayed as soon as the screen is redrawn.
+        """
+        self._report = msg
+
+    def enter(self, item, *attrs):
+        """
+        Enter the object ``item``. If ``attrs`` is specified, it will be used
+        as a fixed list of attributes to display.
+        """
+        if self.levels and item is self.levels[-1].input:
+            curses.beep()
+            self.report(CommandError("Recursion on input object"))
+        else:
+            oldlevels = len(self.levels)
+            self._calcheaderlines(oldlevels+1)
+            try:
+                level = _BrowserLevel(
+                    self,
+                    item,
+                    self.scrsizey-1-self._headerlines-2,
+                    *attrs
+                )
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, exc:
+                if not self.levels:
+                    raise
+                self._calcheaderlines(oldlevels)
+                curses.beep()
+                self.report(exc)
+            else:
+                self.levels.append(level)
+
+    def startkeyboardinput(self, mode):
+        """
+        Enter mode ``mode``, which requires keyboard input.
+        """
+        self.mode = mode
+        self.prompts[mode].start()
+
+    def keylabel(self, keycode):
+        """
+        Return a pretty name for the ``curses`` key ``keycode`` (used in the
+        help screen and in reports about unassigned keys).
+        """
+        if keycode <= 0xff:
+            specialsnames = {
+                ord("\n"): "RETURN",
+                ord(" "): "SPACE",
+                ord("\t"): "TAB",
+                ord("\x7f"): "DELETE",
+                ord("\x08"): "BACKSPACE",
+            }
+            if keycode in specialsnames:
+                return specialsnames[keycode]
+            elif 0x00 < keycode < 0x20:
+                return "CTRL-%s" % chr(keycode + 64)
+            return repr(chr(keycode))
+        for name in dir(curses):
+            if name.startswith("KEY_") and getattr(curses, name) == keycode:
+                return name
+        return str(keycode)
+
+    def beep(self, force=False):
+        if force or self._dobeep:
+            curses.beep()
+            # don't beep again (as long as the same key is pressed)
+            self._dobeep = False
+
+    def cmd_up(self):
+        """
+        Move the cursor to the previous row.
+        """
+        level = self.levels[-1]
+        self.report("up")
+        level.moveto(level.curx, level.cury-self.stepy)
+
+    def cmd_down(self):
+        """
+        Move the cursor to the next row.
+        """
+        level = self.levels[-1]
+        self.report("down")
+        level.moveto(level.curx, level.cury+self.stepy)
+
+    def cmd_pageup(self):
+        """
+        Move the cursor up one page.
+        """
+        level = self.levels[-1]
+        self.report("page up")
+        level.moveto(level.curx, level.cury-level.mainsizey+self.pageoverlapy)
+
+    def cmd_pagedown(self):
+        """
+        Move the cursor down one page.
+        """
+        level = self.levels[-1]
+        self.report("page down")
+        level.moveto(level.curx, level.cury+level.mainsizey-self.pageoverlapy)
+
+    def cmd_left(self):
+        """
+        Move the cursor left.
+        """
+        level = self.levels[-1]
+        self.report("left")
+        level.moveto(level.curx-self.stepx, level.cury)
+
+    def cmd_right(self):
+        """
+        Move the cursor right.
+        """
+        level = self.levels[-1]
+        self.report("right")
+        level.moveto(level.curx+self.stepx, level.cury)
+
+    def cmd_home(self):
+        """
+        Move the cursor to the first column.
+        """
+        level = self.levels[-1]
+        self.report("home")
+        level.moveto(0, level.cury)
+
+    def cmd_end(self):
+        """
+        Move the cursor to the last column.
+        """
+        level = self.levels[-1]
+        self.report("end")
+        level.moveto(level.datasizex+level.mainsizey-self.pageoverlapx, level.cury)
+
+    def cmd_prevattr(self):
+        """
+        Move the cursor one attribute column to the left.
+        """
+        level = self.levels[-1]
+        if level.displayattr[0] is None or level.displayattr[0] == 0:
+            self.beep()
+        else:
+            self.report("prevattr")
+            pos = 0
+            for (i, attrname) in enumerate(level.displayattrs):
+                if i == level.displayattr[0]-1:
+                    break
+                pos += level.colwidths[attrname] + 1
+            level.moveto(pos, level.cury)
+
+    def cmd_nextattr(self):
+        """
+        Move the cursor one attribute column to the right.
+        """
+        level = self.levels[-1]
+        if level.displayattr[0] is None or level.displayattr[0] == len(level.displayattrs)-1:
+            self.beep()
+        else:
+            self.report("nextattr")
+            pos = 0
+            for (i, attrname) in enumerate(level.displayattrs):
+                if i == level.displayattr[0]+1:
+                    break
+                pos += level.colwidths[attrname] + 1
+            level.moveto(pos, level.cury)
+
+    def cmd_pick(self):
+        """
+        'Pick' the object under the cursor (i.e. the row the cursor is on).
+        This leaves the browser and returns the picked object to the caller.
+        (In IPython this object will be available as the ``_`` variable.)
+        """
+        level = self.levels[-1]
+        self.returnvalue = level.items[level.cury].item
+        return True
+
+    def cmd_pickattr(self):
+        """
+        'Pick' the attribute under the cursor (i.e. the row/column the
+        cursor is on).
+        """
+        level = self.levels[-1]
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
+            curses.beep()
+            self.report(CommandError("no column under cursor"))
+            return
+        value = attr.value(level.items[level.cury].item)
+        if value is ipipe.noitem:
+            curses.beep()
+            self.report(AttributeError(attr.name()))
+        else:
+            self.returnvalue = value
+            return True
+
+    def cmd_pickallattrs(self):
+        """
+        Pick' the complete column under the cursor (i.e. the attribute under
+        the cursor) from all currently fetched objects. These attributes
+        will be returned as a list.
+        """
+        level = self.levels[-1]
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
+            curses.beep()
+            self.report(CommandError("no column under cursor"))
+            return
+        result = []
+        for cache in level.items:
+            value = attr.value(cache.item)
+            if value is not ipipe.noitem:
+                result.append(value)
+        self.returnvalue = result
+        return True
+
+    def cmd_pickmarked(self):
+        """
+        'Pick' marked objects. Marked objects will be returned as a list.
+        """
+        level = self.levels[-1]
+        self.returnvalue = [cache.item for cache in level.items if cache.marked]
+        return True
+
+    def cmd_pickmarkedattr(self):
+        """
+        'Pick' the attribute under the cursor from all marked objects
+        (This returns a list).
+        """
+
+        level = self.levels[-1]
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
+            curses.beep()
+            self.report(CommandError("no column under cursor"))
+            return
+        result = []
+        for cache in level.items:
+            if cache.marked:
+                value = attr.value(cache.item)
+                if value is not ipipe.noitem:
+                    result.append(value)
+        self.returnvalue = result
+        return True
+
+    def cmd_pickinput(self):
+        """
+        Use the object under the cursor (i.e. the row the cursor is on) as
+        the next input line. This leaves the browser and puts the picked object
+        in the input.
+        """
+        level = self.levels[-1]
+        value = level.items[level.cury].item
+        self.returnvalue = None
+        api = ipapi.get()
+        api.set_next_input(str(value))
+        return True
+
+    def cmd_pickinputattr(self):
+        """
+        Use the attribute under the cursor i.e. the row/column the cursor is on)
+        as the next input line. This leaves the browser and puts the picked
+        object in the input.
+        """
+        level = self.levels[-1]
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
+            curses.beep()
+            self.report(CommandError("no column under cursor"))
+            return
+        value = attr.value(level.items[level.cury].item)
+        if value is ipipe.noitem:
+            curses.beep()
+            self.report(AttributeError(attr.name()))
+        self.returnvalue = None
+        api = ipapi.get()
+        api.set_next_input(str(value))
+        return True
+
+    def cmd_markrange(self):
+        """
+        Mark all objects from the last marked object before the current cursor
+        position to the cursor position.
+        """
+        level = self.levels[-1]
+        self.report("markrange")
+        start = None
+        if level.items:
+            for i in xrange(level.cury, -1, -1):
+                if level.items[i].marked:
+                    start = i
+                    break
+        if start is None:
+            self.report(CommandError("no mark before cursor"))
+            curses.beep()
+        else:
+            for i in xrange(start, level.cury+1):
+                cache = level.items[i]
+                if not cache.marked:
+                    cache.marked = True
+                    level.marked += 1
+
+    def cmd_enter(self):
+        """
+        Enter the object under the cursor. (what this mean depends on the object
+        itself (i.e. how it implements iteration). This opens a new browser 'level'.
+        """
+        level = self.levels[-1]
+        try:
+            item = level.items[level.cury].item
+        except IndexError:
+            self.report(CommandError("No object"))
+            curses.beep()
+        else:
+            self.report("entering object...")
+            self.enter(item)
+
+    def cmd_leave(self):
+        """
+        Leave the current browser level and go back to the previous one.
+        """
+        self.report("leave")
+        if len(self.levels) > 1:
+            self._calcheaderlines(len(self.levels)-1)
+            self.levels.pop(-1)
+        else:
+            self.report(CommandError("This is the last level"))
+            curses.beep()
+
+    def cmd_enterattr(self):
+        """
+        Enter the attribute under the cursor.
+        """
+        level = self.levels[-1]
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
+            curses.beep()
+            self.report(CommandError("no column under cursor"))
+            return
+        try:
+            item = level.items[level.cury].item
+        except IndexError:
+            self.report(CommandError("No object"))
+            curses.beep()
+        else:
+            value = attr.value(item)
+            name = attr.name()
+            if value is ipipe.noitem:
+                self.report(AttributeError(name))
+            else:
+                self.report("entering object attribute %s..." % name)
+                self.enter(value)
+
+    def cmd_detail(self):
+        """
+        Show a detail view of the object under the cursor. This shows the
+        name, type, doc string and value of the object attributes (and it
+        might show more attributes than in the list view, depending on
+        the object).
+        """
+        level = self.levels[-1]
+        try:
+            item = level.items[level.cury].item
+        except IndexError:
+            self.report(CommandError("No object"))
+            curses.beep()
+        else:
+            self.report("entering detail view for object...")
+            attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
+            self.enter(attrs)
+
+    def cmd_detailattr(self):
+        """
+        Show a detail view of the attribute under the cursor.
+        """
+        level = self.levels[-1]
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
+            curses.beep()
+            self.report(CommandError("no attribute"))
+            return
+        try:
+            item = level.items[level.cury].item
+        except IndexError:
+            self.report(CommandError("No object"))
+            curses.beep()
+        else:
+            try:
+                item = attr.value(item)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, exc:
+                self.report(exc)
+            else:
+                self.report("entering detail view for attribute %s..." % attr.name())
+                attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
+                self.enter(attrs)
+
+    def cmd_tooglemark(self):
+        """
+        Mark/unmark the object under the cursor. Marked objects have a '!'
+        after the row number).
+        """
+        level = self.levels[-1]
+        self.report("toggle mark")
+        try:
+            item = level.items[level.cury]
+        except IndexError: # no items?
+            pass
+        else:
+            if item.marked:
+                item.marked = False
+                level.marked -= 1
+            else:
+                item.marked = True
+                level.marked += 1
+
+    def cmd_sortattrasc(self):
+        """
+        Sort the objects (in ascending order) using the attribute under
+        the cursor as the sort key.
+        """
+        level = self.levels[-1]
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
+            curses.beep()
+            self.report(CommandError("no column under cursor"))
+            return
+        self.report("sort by %s (ascending)" % attr.name())
+        def key(item):
+            try:
+                return attr.value(item)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception:
+                return None
+        level.sort(key)
+
+    def cmd_sortattrdesc(self):
+        """
+        Sort the objects (in descending order) using the attribute under
+        the cursor as the sort key.
+        """
+        level = self.levels[-1]
+        attr = level.displayattr[1]
+        if attr is ipipe.noitem:
+            curses.beep()
+            self.report(CommandError("no column under cursor"))
+            return
+        self.report("sort by %s (descending)" % attr.name())
+        def key(item):
+            try:
+                return attr.value(item)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception:
+                return None
+        level.sort(key, reverse=True)
+
+    def cmd_hideattr(self):
+        """
+        Hide the attribute under the cursor.
+        """
+        level = self.levels[-1]
+        if level.displayattr[0] is None:
+            self.beep()
+        else:
+            self.report("hideattr")
+            level.hiddenattrs.add(level.displayattr[1])
+            level.moveto(level.curx, level.cury, refresh=True)
+
+    def cmd_unhideattrs(self):
+        """
+        Make all attributes visible again.
+        """
+        level = self.levels[-1]
+        self.report("unhideattrs")
+        level.hiddenattrs.clear()
+        level.moveto(level.curx, level.cury, refresh=True)
+
+    def cmd_goto(self):
+        """
+        Jump to a row. The row number can be entered at the
+        bottom of the screen.
+        """
+        self.startkeyboardinput("goto")
+
+    def cmd_find(self):
+        """
+        Search forward for a row. The search condition can be entered at the
+        bottom of the screen.
+        """
+        self.startkeyboardinput("find")
+
+    def cmd_findbackwards(self):
+        """
+        Search backward for a row. The search condition can be entered at the
+        bottom of the screen.
+        """
+        self.startkeyboardinput("findbackwards")
+
+    def cmd_refresh(self):
+        """
+        Refreshes the display by restarting the iterator.
+        """
+        level = self.levels[-1]
+        self.report("refresh")
+        level.refresh()
+
+    def cmd_refreshfind(self):
+        """
+        Refreshes the display by restarting the iterator and goes back to the
+        same object the cursor was on before restarting (if this object can't be
+        found the cursor jumps back to the first object).
+        """
+        level = self.levels[-1]
+        self.report("refreshfind")
+        level.refreshfind()
+
+    def cmd_help(self):
+        """
+        Opens the help screen as a new browser level, describing keyboard
+        shortcuts.
+        """
+        for level in self.levels:
+            if isinstance(level.input, _BrowserHelp):
+                curses.beep()
+                self.report(CommandError("help already active"))
+                return
+
+        self.enter(_BrowserHelp(self))
+
+    def cmd_quit(self):
+        """
+        Quit the browser and return to the IPython prompt.
+        """
+        self.returnvalue = None
+        return True
+
+    def sigwinchhandler(self, signal, frame):
+        self.resized = True
+
+    def _dodisplay(self, scr):
+        """
+        This method is the workhorse of the browser. It handles screen
+        drawing and the keyboard.
+        """
+        self.scr = scr
+        curses.halfdelay(1)
+        footery = 2
+
+        keys = []
+        for cmd in ("quit", "help"):
+            key = self.keymap.findkey(cmd, None)
+            if key is not None:
+                keys.append("%s=%s" % (self.keylabel(key), cmd))
+        helpmsg = " | %s" % " ".join(keys)
+
+        scr.clear()
+        msg = "Fetching first batch of objects..."
+        (self.scrsizey, self.scrsizex) = scr.getmaxyx()
+        scr.addstr(self.scrsizey//2, (self.scrsizex-len(msg))//2, msg)
+        scr.refresh()
+
+        lastc = -1
+
+        self.levels = []
+        # enter the first level
+        self.enter(self.input, *self.attrs)
+
+        self._calcheaderlines(None)
+
+        while True:
+            level = self.levels[-1]
+            (self.scrsizey, self.scrsizex) = scr.getmaxyx()
+            level.mainsizey = self.scrsizey-1-self._headerlines-footery
+
+            # Paint object header
+            for i in xrange(self._firstheaderline, self._firstheaderline+self._headerlines):
+                lv = self.levels[i]
+                posx = 0
+                posy = i-self._firstheaderline
+                endx = self.scrsizex
+                if i: # not the first level
+                    msg = " (%d/%d" % (self.levels[i-1].cury, len(self.levels[i-1].items))
+                    if not self.levels[i-1].exhausted:
+                        msg += "+"
+                    msg += ") "
+                    endx -= len(msg)+1
+                posx += self.addstr(posy, posx, 0, endx, " ibrowse #%d: " % i, self.style_objheadertext)
+                for (style, text) in lv.header:
+                    posx += self.addstr(posy, posx, 0, endx, text, self.style_objheaderobject)
+                    if posx >= endx:
+                        break
+                if i:
+                    posx += self.addstr(posy, posx, 0, self.scrsizex, msg, self.style_objheadernumber)
+                posx += self.addchr(posy, posx, 0, self.scrsizex, " ", self.scrsizex-posx, self.style_objheadernumber)
+
+            if not level.items:
+                self.addchr(self._headerlines, 0, 0, self.scrsizex, " ", self.scrsizex, self.style_colheader)
+                self.addstr(self._headerlines+1, 0, 0, self.scrsizex, " <empty>", astyle.style_error)
+                scr.clrtobot()
+            else:
+                # Paint column headers
+                scr.move(self._headerlines, 0)
+                scr.addstr(" %*s " % (level.numbersizex, "#"), self.getstyle(self.style_colheader))
+                scr.addstr(self.headersepchar, self.getstyle(self.style_colheadersep))
+                begx = level.numbersizex+3
+                posx = begx-level.datastartx
+                for attr in level.displayattrs:
+                    attrname = attr.name()
+                    cwidth = level.colwidths[attr]
+                    header = attrname.ljust(cwidth)
+                    if attr is level.displayattr[1]:
+                        style = self.style_colheaderhere
+                    else:
+                        style = self.style_colheader
+                    posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, header, style)
+                    posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, self.headersepchar, self.style_colheadersep)
+                    if posx >= self.scrsizex:
+                        break
+                else:
+                    scr.addstr(" "*(self.scrsizex-posx), self.getstyle(self.style_colheader))
+
+                # Paint rows
+                posy = self._headerlines+1+level.datastarty
+                for i in xrange(level.datastarty, min(level.datastarty+level.mainsizey, len(level.items))):
+                    cache = level.items[i]
+                    if i == level.cury:
+                        style = self.style_numberhere
+                    else:
+                        style = self.style_number
+
+                    posy = self._headerlines+1+i-level.datastarty
+                    posx = begx-level.datastartx
+
+                    scr.move(posy, 0)
+                    scr.addstr(" %*d%s" % (level.numbersizex, i, " !"[cache.marked]), self.getstyle(style))
+                    scr.addstr(self.headersepchar, self.getstyle(self.style_sep))
+
+                    for attrname in level.displayattrs:
+                        cwidth = level.colwidths[attrname]
+                        try:
+                            (align, length, parts) = level.displayrows[i-level.datastarty][attrname]
+                        except KeyError:
+                            align = 2
+                            style = astyle.style_nodata
+                            if i == level.cury:
+                                style = self.getstylehere(style)
+                        padstyle = self.style_datapad
+                        sepstyle = self.style_sep
+                        if i == level.cury:
+                            padstyle = self.getstylehere(padstyle)
+                            sepstyle = self.getstylehere(sepstyle)
+                        if align == 2:
+                            posx += self.addchr(posy, posx, begx, self.scrsizex, self.nodatachar, cwidth, style)
+                        else:
+                            if align == 1:
+                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
+                            elif align == 0:
+                                pad1 = (cwidth-length)//2
+                                pad2 = cwidth-length-len(pad1)
+                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad1, padstyle)
+                            for (style, text) in parts:
+                                if i == level.cury:
+                                    style = self.getstylehere(style)
+                                posx += self.addstr(posy, posx, begx, self.scrsizex, text, style)
+                                if posx >= self.scrsizex:
+                                    break
+                            if align == -1:
+                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
+                            elif align == 0:
+                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad2, padstyle)
+                        posx += self.addstr(posy, posx, begx, self.scrsizex, self.datasepchar, sepstyle)
+                    else:
+                        scr.clrtoeol()
+
+                # Add blank row headers for the rest of the screen
+                for posy in xrange(posy+1, self.scrsizey-2):
+                    scr.addstr(posy, 0, " " * (level.numbersizex+2), self.getstyle(self.style_colheader))
+                    scr.clrtoeol()
+
+            posy = self.scrsizey-footery
+            # Display footer
+            scr.addstr(posy, 0, " "*self.scrsizex, self.getstyle(self.style_footer))
+
+            if level.exhausted:
+                flag = ""
+            else:
+                flag = "+"
+
+            endx = self.scrsizex-len(helpmsg)-1
+            scr.addstr(posy, endx, helpmsg, self.getstyle(self.style_footer))
+
+            posx = 0
+            msg = " %d%s objects (%d marked): " % (len(level.items), flag, level.marked)
+            posx += self.addstr(posy, posx, 0, endx, msg, self.style_footer)
+            try:
+                item = level.items[level.cury].item
+            except IndexError: # empty
+                pass
+            else:
+                for (nostyle, text) in ipipe.xrepr(item, "footer"):
+                    if not isinstance(nostyle, int):
+                        posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
+                        if posx >= endx:
+                            break
+
+                attrstyle = [(astyle.style_default, "no attribute")]
+                attr = level.displayattr[1]
+                if attr is not ipipe.noitem and not isinstance(attr, ipipe.SelfDescriptor):
+                    posx += self.addstr(posy, posx, 0, endx, " | ", self.style_footer)
+                    posx += self.addstr(posy, posx, 0, endx, attr.name(), self.style_footer)
+                    posx += self.addstr(posy, posx, 0, endx, ": ", self.style_footer)
+                    try:
+                        value = attr.value(item)
+                    except (SystemExit, KeyboardInterrupt):
+                        raise
+                    except Exception, exc:
+                        value = exc
+                    if value is not ipipe.noitem:
+                        attrstyle = ipipe.xrepr(value, "footer")
+                    for (nostyle, text) in attrstyle:
+                        if not isinstance(nostyle, int):
+                            posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
+                            if posx >= endx:
+                                break
+
+            try:
+                # Display input prompt
+                if self.mode in self.prompts:
+                    history = self.prompts[self.mode]
+                    posx = 0
+                    posy = self.scrsizey-1
+                    posx += self.addstr(posy, posx, 0, endx, history.prompt, astyle.style_default)
+                    posx += self.addstr(posy, posx, 0, endx, " [", astyle.style_default)
+                    if history.cury==-1:
+                        text = "new"
+                    else:
+                        text = str(history.cury+1)
+                    posx += self.addstr(posy, posx, 0, endx, text, astyle.style_type_number)
+                    if history.history:
+                        posx += self.addstr(posy, posx, 0, endx, "/", astyle.style_default)
+                        posx += self.addstr(posy, posx, 0, endx, str(len(history.history)), astyle.style_type_number)
+                    posx += self.addstr(posy, posx, 0, endx, "]: ", astyle.style_default)
+                    inputstartx = posx
+                    posx += self.addstr(posy, posx, 0, endx, history.input, astyle.style_default)
+                # Display report
+                else:
+                    if self._report is not None:
+                        if isinstance(self._report, Exception):
+                            style = self.getstyle(astyle.style_error)
+                            if self._report.__class__.__module__ == "exceptions":
+                                msg = "%s: %s" % \
+                                      (self._report.__class__.__name__, self._report)
+                            else:
+                                msg = "%s.%s: %s" % \
+                                      (self._report.__class__.__module__,
+                                       self._report.__class__.__name__, self._report)
+                        else:
+                            style = self.getstyle(self.style_report)
+                            msg = self._report
+                        scr.addstr(self.scrsizey-1, 0, msg[:self.scrsizex], style)
+                        self._report = None
+                    else:
+                        scr.move(self.scrsizey-1, 0)
+            except curses.error:
+                # Protect against errors from writing to the last line
+                pass
+            scr.clrtoeol()
+
+            # Position cursor
+            if self.mode in self.prompts:
+                history = self.prompts[self.mode]
+                scr.move(self.scrsizey-1, inputstartx+history.curx)
+            else:
+                scr.move(
+                    1+self._headerlines+level.cury-level.datastarty,
+                    level.numbersizex+3+level.curx-level.datastartx
+                )
+            scr.refresh()
+
+            # Check keyboard
+            while True:
+                c = scr.getch()
+                if self.resized:
+                    size = fcntl.ioctl(0, tty.TIOCGWINSZ, "12345678")
+                    size = struct.unpack("4H", size)
+                    oldsize = scr.getmaxyx()
+                    scr.erase()
+                    curses.resize_term(size[0], size[1])
+                    newsize = scr.getmaxyx()
+                    scr.erase()
+                    for l in self.levels:
+                        l.mainsizey += newsize[0]-oldsize[0]
+                        l.moveto(l.curx, l.cury, refresh=True)
+                    scr.refresh()
+                    self.resized = False
+                    break # Redisplay
+                if self.mode in self.prompts:
+                    if self.prompts[self.mode].handlekey(self, c):
+                       break # Redisplay
+                else:
+                    # if no key is pressed slow down and beep again
+                    if c == -1:
+                        self.stepx = 1.
+                        self.stepy = 1.
+                        self._dobeep = True
+                    else:
+                        # if a different key was pressed slow down and beep too
+                        if c != lastc:
+                            lastc = c
+                            self.stepx = 1.
+                            self.stepy = 1.
+                            self._dobeep = True
+                        cmdname = self.keymap.get(c, None)
+                        if cmdname is None:
+                            self.report(
+                                UnassignedKeyError("Unassigned key %s" %
+                                                   self.keylabel(c)))
+                        else:
+                            cmdfunc = getattr(self, "cmd_%s" % cmdname, None)
+                            if cmdfunc is None:
+                                self.report(
+                                    UnknownCommandError("Unknown command %r" %
+                                                        (cmdname,)))
+                            elif cmdfunc():
+                                returnvalue = self.returnvalue
+                                self.returnvalue = None
+                                return returnvalue
+                        self.stepx = self.nextstepx(self.stepx)
+                        self.stepy = self.nextstepy(self.stepy)
+                        curses.flushinp() # get rid of type ahead
+                        break # Redisplay
+        self.scr = None
+
+    def display(self):
+        if hasattr(curses, "resize_term"):
+            oldhandler = signal.signal(signal.SIGWINCH, self.sigwinchhandler)
+            try:
+                return curses.wrapper(self._dodisplay)
+            finally:
+                signal.signal(signal.SIGWINCH, oldhandler)
+        else:
+            return curses.wrapper(self._dodisplay)
diff --git a/IPython/Extensions/igrid.py b/IPython/Extensions/igrid.py
new file mode 100644
index 0000000..a2d317f
--- /dev/null
+++ b/IPython/Extensions/igrid.py
@@ -0,0 +1,1126 @@
+# -*- coding: iso-8859-1 -*-
+
+import ipipe, os, webbrowser, urllib
+from IPython import ipapi
+import wx
+import wx.grid, wx.html
+
+try:
+    sorted
+except NameError:
+    from ipipe import sorted
+try:
+    set
+except:
+    from sets import Set as set
+
+
+__all__ = ["igrid"]
+
+
+help = """
+<?xml version='1.0' encoding='iso-8859-1'?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+<link rel="stylesheet" href="igrid_help.css" type="text/css" />
+<title>igrid help</title>
+</head>
+<body>
+<h1>igrid help</h1>
+
+
+<h2>Commands</h2>
+
+
+<h3>pick (P)</h3>
+<p>Pick the whole row (object is available as "_")</p>
+
+<h3>pickattr (Shift-P)</h3>
+<p>Pick the attribute under the cursor</p>
+
+<h3>pickallattrs (Shift-C)</h3>
+<p>Pick the complete column under the cursor (i.e. the attribute under the
+cursor) from all currently fetched objects. These attributes will be returned
+as a list.</p>
+
+<h3>pickinput (I)</h3>
+<p>Pick the current row as next input line in IPython. Additionally the row is stored as "_"</p>
+
+<h3>pickinputattr (Shift-I)</h3>
+<p>Pick the attribute under the cursor as next input line in IPython. Additionally the row is stored as "_"</p>
+
+<h3>enter (E)</h3>
+<p>Enter the object under the cursor. (what this mean depends on the object
+itself, i.e. how it implements iteration). This opens a new browser 'level'.</p>
+
+<h3>enterattr (Shift-E)</h3>
+<p>Enter the attribute under the cursor.</p>
+
+<h3>detail (D)</h3>
+<p>Show a detail view of the object under the cursor. This shows the name,
+type, doc string and value of the object attributes (and it might show more
+attributes than in the list view, depending on the object).</p>
+
+<h3>detailattr (Shift-D)</h3>
+<p>Show a detail view of the attribute under the cursor.</p>
+
+<h3>pickrows (M)</h3>
+<p>Pick multiple selected rows (M)</p>
+
+<h3>pickrowsattr (CTRL-M)</h3>
+<p>From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)</p>
+
+<h3>find (CTRL-F)</h3>
+<p>Find text</p>
+
+<h3>find_expression (CTRL-Shift-F)</h3>
+<p>Find entries matching an expression</p>
+
+<h3>find_next (F3)</h3>
+<p>Find next occurrence</p>
+
+<h3>find_previous (Shift-F3)</h3>
+<p>Find previous occurrence</p>
+
+<h3>sortattrasc (V)</h3>
+<p>Sort the objects (in ascending order) using the attribute under the cursor as the sort key.</p>
+
+<h3>sortattrdesc (Shift-V)</h3>
+<p>Sort the objects (in descending order) using the attribute under the cursor as the sort key.</p>
+
+<h3>refresh_once (R, F5)</h3>
+<p>Refreshes the display by restarting the iterator</p>
+
+<h3>refresh_every_second</h3>
+<p>Refreshes the display by restarting the iterator every second until stopped by stop_refresh.</p>
+
+<h3>refresh_interval</h3>
+<p>Refreshes the display by restarting the iterator every X ms (X is a custom interval set by the user) until stopped by stop_refresh.</p>
+
+<h3>stop_refresh</h3>
+<p>Stops all refresh timers.</p>
+
+<h3>leave (Backspace, DEL, X)</h3>
+<p>Close current tab (and all the tabs to the right of the current one).</h3>
+
+<h3>quit (ESC,Q)</h3>
+<p>Quit igrid and return to the IPython prompt.</p>
+
+
+<h2>Navigation</h2>
+
+
+<h3>Jump to the last column of the current row (END, CTRL-E, CTRL-Right)</h3>
+
+<h3>Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)</h3>
+
+<h3>Move the cursor one column to the left (&lt;)</h3>
+
+<h3>Move the cursor one column to the right (&gt;)</h3>
+
+<h3>Jump to the first row in the current column (CTRL-Up)</h3>
+
+<h3>Jump to the last row in the current column (CTRL-Down)</h3>
+
+</body>
+</html>
+
+"""
+
+
+class IGridRenderer(wx.grid.PyGridCellRenderer):
+    """
+    This is a custom renderer for our IGridGrid
+    """
+    def __init__(self, table):
+        self.maxchars = 200
+        self.table = table
+        self.colormap = (
+            (  0,   0,   0),
+            (174,   0,   0),
+            (  0, 174,   0),
+            (174, 174,   0),
+            (  0,   0, 174),
+            (174,   0, 174),
+            (  0, 174, 174),
+            ( 64,  64,  64)
+        )
+
+        wx.grid.PyGridCellRenderer.__init__(self)
+
+    def _getvalue(self, row, col):
+        try:
+            value = self.table._displayattrs[col].value(self.table.items[row])
+            (align, width, text) = ipipe.xformat(value, "cell", self.maxchars)
+        except Exception, exc:
+            (align, width, text) = ipipe.xformat(exc, "cell", self.maxchars)
+        return (align, text)
+
+    def GetBestSize(self, grid, attr, dc, row, col):
+        text = grid.GetCellValue(row, col)
+        (align, text) = self._getvalue(row, col)
+        dc.SetFont(attr.GetFont())
+        (w, h) = dc.GetTextExtent(str(text))
+        return wx.Size(min(w+2, 600), h+2) # add border
+
+    def Draw(self, grid, attr, dc, rect, row, col, isSelected):
+        """
+        Takes care of drawing everything in the cell; aligns the text
+        """
+        text = grid.GetCellValue(row, col)
+        (align, text) = self._getvalue(row, col)
+        if isSelected:
+            bg = grid.GetSelectionBackground()
+        else:
+            bg = ["white", (240, 240, 240)][row%2]
+        dc.SetTextBackground(bg)
+        dc.SetBrush(wx.Brush(bg, wx.SOLID))
+        dc.SetPen(wx.TRANSPARENT_PEN)
+        dc.SetFont(attr.GetFont())
+        dc.DrawRectangleRect(rect)
+        dc.SetClippingRect(rect)
+        # Format the text
+        if align == -1: # left alignment
+            (width, height) = dc.GetTextExtent(str(text))
+            x = rect[0]+1
+            y = rect[1]+0.5*(rect[3]-height)
+
+            for (style, part) in text:
+                if isSelected:
+                    fg = grid.GetSelectionForeground()
+                else:
+                    fg = self.colormap[style.fg]
+                dc.SetTextForeground(fg)
+                (w, h) = dc.GetTextExtent(part)
+                dc.DrawText(part, x, y)
+                x += w
+        elif align == 0: # center alignment
+            (width, height) = dc.GetTextExtent(str(text))
+            x = rect[0]+0.5*(rect[2]-width)
+            y = rect[1]+0.5*(rect[3]-height)
+            for (style, part) in text:
+                if isSelected:
+                    fg = grid.GetSelectionForeground()
+                else:
+                    fg = self.colormap[style.fg]
+                dc.SetTextForeground(fg)
+                (w, h) = dc.GetTextExtent(part)
+                dc.DrawText(part, x, y)
+                x += w
+        else:  # right alignment
+            (width, height) = dc.GetTextExtent(str(text))
+            x = rect[0]+rect[2]-1
+            y = rect[1]+0.5*(rect[3]-height)
+            for (style, part) in reversed(text):
+                (w, h) = dc.GetTextExtent(part)
+                x -= w
+                if isSelected:
+                    fg = grid.GetSelectionForeground()
+                else:
+                    fg = self.colormap[style.fg]
+                dc.SetTextForeground(fg)
+                dc.DrawText(part, x, y)
+        dc.DestroyClippingRegion()
+
+    def Clone(self):
+        return IGridRenderer(self.table)
+
+
+class IGridTable(wx.grid.PyGridTableBase):
+    # The data table for the ``IGridGrid``. Some dirty tricks were used here:
+    # ``GetValue()`` does not get any values (or at least it does not return
+    # anything, accessing the values is done by the renderer)
+    # but rather tries to fetch the objects which were requested into the table.
+    # General behaviour is: Fetch the first X objects. If the user scrolls down
+    # to the last object another bunch of X objects is fetched (if possible)
+    def __init__(self, input, fontsize, *attrs):
+        wx.grid.PyGridTableBase.__init__(self)
+        self.input = input
+        self.iterator = ipipe.xiter(input)
+        self.items = []
+        self.attrs = [ipipe.upgradexattr(attr) for attr in attrs]
+        self._displayattrs = self.attrs[:]
+        self._displayattrset = set(self.attrs)
+        self.fontsize = fontsize
+        self._fetch(1)
+        self.timer = wx.Timer()
+        self.timer.Bind(wx.EVT_TIMER, self.refresh_content)
+
+    def GetAttr(self, *args):
+        attr = wx.grid.GridCellAttr()
+        attr.SetFont(wx.Font(self.fontsize, wx.TELETYPE, wx.NORMAL, wx.NORMAL))
+        return attr
+
+    def GetNumberRows(self):
+        return len(self.items)
+
+    def GetNumberCols(self):
+        return len(self._displayattrs)
+
+    def GetColLabelValue(self, col):
+        if col < len(self._displayattrs):
+            return self._displayattrs[col].name()
+        else:
+            return ""
+
+    def GetRowLabelValue(self, row):
+        return str(row)
+
+    def IsEmptyCell(self, row, col):
+        return False
+
+    def _append(self, item):
+        self.items.append(item)
+        # Nothing to do if the set of attributes has been fixed by the user
+        if not self.attrs:
+            for attr in ipipe.xattrs(item):
+                attr = ipipe.upgradexattr(attr)
+                if attr not in self._displayattrset:
+                    self._displayattrs.append(attr)
+                    self._displayattrset.add(attr)
+
+    def _fetch(self, count):
+        # Try to fill ``self.items`` with at least ``count`` objects.
+        have = len(self.items)
+        while self.iterator is not None and have < count:
+            try:
+                item = self.iterator.next()
+            except StopIteration:
+                self.iterator = None
+                break
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, exc:
+                have += 1
+                self._append(exc)
+                self.iterator = None
+                break
+            else:
+                have += 1
+                self._append(item)
+
+    def GetValue(self, row, col):
+        # some kind of dummy-function: does not return anything but "";
+        # (The value isn't use anyway)
+        # its main task is to trigger the fetch of new objects
+        sizing_needed = False
+        had_cols = len(self._displayattrs)
+        had_rows = len(self.items)
+        if row == had_rows - 1 and self.iterator is not None:
+            self._fetch(row + 20)
+            sizing_needed = True
+        have_rows = len(self.items)
+        have_cols = len(self._displayattrs)
+        if have_rows > had_rows:
+            msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, have_rows - had_rows)
+            self.GetView().ProcessTableMessage(msg)
+            sizing_needed = True
+        if row >= have_rows:
+            return ""
+        if have_cols != had_cols:
+            msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_COLS_APPENDED, have_cols - had_cols)
+            self.GetView().ProcessTableMessage(msg)
+            sizing_needed = True
+        if sizing_needed:
+            self.GetView().AutoSizeColumns(False)
+        return ""
+
+    def SetValue(self, row, col, value):
+        pass
+
+    def refresh_content(self, event):
+        msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED, 0, self.GetNumberRows())
+        self.GetView().ProcessTableMessage(msg)
+        self.iterator = ipipe.xiter(self.input)
+        self.items = []
+        self.attrs = [] # _append will calculate new displayattrs
+        self._fetch(1) # fetch one...
+        if self.items:
+            msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, 1)
+            self.GetView().ProcessTableMessage(msg)
+            self.GetValue(0, 0) # and trigger "fetch next 20"
+            item = self.items[0]
+            self.GetView().AutoSizeColumns(False)
+            panel = self.GetView().GetParent()
+            nb = panel.GetParent()
+            current = nb.GetSelection()
+            if nb.GetPage(current) == panel:
+                self.GetView().set_footer(item)
+
+class IGridGrid(wx.grid.Grid):
+    # The actual grid
+    # all methods for selecting/sorting/picking/... data are implemented here
+    def __init__(self, panel, input, *attrs):
+        wx.grid.Grid.__init__(self, panel)
+        fontsize = 9
+        self.input = input
+        self.table = IGridTable(self.input, fontsize, *attrs)
+        self.SetTable(self.table, True)
+        self.SetSelectionMode(wx.grid.Grid.wxGridSelectRows)
+        self.SetDefaultRenderer(IGridRenderer(self.table))
+        self.EnableEditing(False)
+        self.Bind(wx.EVT_KEY_DOWN, self.key_pressed)
+        self.Bind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK, self.cell_doubleclicked)
+        self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.cell_leftclicked)
+        self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_DCLICK, self.label_doubleclicked)
+        self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_label_leftclick)
+        self.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self._on_selected_range)
+        self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self._on_selected_cell)
+        self.current_selection = set()
+        self.maxchars = 200
+
+    def on_label_leftclick(self, event):
+        event.Skip()
+
+    def error_output(self, text):
+        wx.Bell()
+        frame = self.GetParent().GetParent().GetParent()
+        frame.SetStatusText(str(text))
+
+    def _on_selected_range(self, event):
+        # Internal update to the selection tracking lists
+        if event.Selecting():
+            # adding to the list...
+            self.current_selection.update(xrange(event.GetTopRow(), event.GetBottomRow()+1))
+        else:
+            # removal from list
+            for index in xrange(event.GetTopRow(), event.GetBottomRow()+1):
+                self.current_selection.discard(index)
+        event.Skip()
+
+    def _on_selected_cell(self, event):
+        # Internal update to the selection tracking list
+        self.current_selection = set([event.GetRow()])
+        event.Skip()
+
+    def sort(self, key, reverse=False):
+        """
+        Sort the current list of items using the key function ``key``. If
+        ``reverse`` is true the sort order is reversed.
+        """
+        row = self.GetGridCursorRow()
+        col = self.GetGridCursorCol()
+        curitem = self.table.items[row] # Remember where the cursor is now
+        # Sort items
+        def realkey(item):
+            try:
+                return key(item)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception:
+                return None
+        try:
+            self.table.items = ipipe.deque(sorted(self.table.items, key=realkey, reverse=reverse))
+        except TypeError, exc:
+            self.error_output("Exception encountered: %s" % exc)
+            return
+        # Find out where the object under the cursor went
+        for (i, item) in enumerate(self.table.items):
+            if item is curitem:
+                self.SetGridCursor(i,col)
+                self.MakeCellVisible(i,col)
+                self.Refresh()
+
+    def sortattrasc(self):
+        """
+        Sort in ascending order; sorting criteria is the current attribute
+        """
+        col = self.GetGridCursorCol()
+        attr = self.table._displayattrs[col]
+        frame = self.GetParent().GetParent().GetParent()
+        if attr is ipipe.noitem:
+            self.error_output("no column under cursor")
+            return
+        frame.SetStatusText("sort by %s (ascending)" % attr.name())
+        def key(item):
+            try:
+                return attr.value(item)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception:
+                return None
+        self.sort(key)
+
+    def sortattrdesc(self):
+        """
+        Sort in descending order; sorting criteria is the current attribute
+        """
+        col = self.GetGridCursorCol()
+        attr = self.table._displayattrs[col]
+        frame = self.GetParent().GetParent().GetParent()
+        if attr is ipipe.noitem:
+            self.error_output("no column under cursor")
+            return
+        frame.SetStatusText("sort by %s (descending)" % attr.name())
+        def key(item):
+            try:
+                return attr.value(item)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception:
+                return None
+        self.sort(key, reverse=True)
+
+    def label_doubleclicked(self, event):
+        row = event.GetRow()
+        col = event.GetCol()
+        if col == -1:
+            self.enter(row)
+
+    def _getvalue(self, row, col):
+        """
+        Gets the text which is displayed at ``(row, col)``
+        """
+        try:
+            value = self.table._displayattrs[col].value(self.table.items[row])
+            (align, width, text) = ipipe.xformat(value, "cell", self.maxchars)
+        except IndexError:
+            raise IndexError
+        except Exception, exc:
+            (align, width, text) = ipipe.xformat(exc, "cell", self.maxchars)
+        return text
+
+    def searchexpression(self, searchexp, startrow=None, search_forward=True ):
+        """
+        Find by expression
+        """
+        frame = self.GetParent().GetParent().GetParent()
+        if searchexp:
+            if search_forward:
+                if not startrow:
+                    row = self.GetGridCursorRow()+1
+                else:
+                    row = startrow + 1
+                while True:
+                    try:
+                        foo = self.table.GetValue(row, 0)
+                        item = self.table.items[row]
+                        try:
+                            globals = ipipe.getglobals(None)
+                            if eval(searchexp, globals, ipipe.AttrNamespace(item)):
+                                self.SetGridCursor(row, 0) # found something
+                                self.MakeCellVisible(row, 0)
+                                break
+                        except (KeyboardInterrupt, SystemExit):
+                            raise
+                        except Exception, exc:
+                            frame.SetStatusText(str(exc))
+                            wx.Bell()
+                            break  # break on error
+                    except IndexError:
+                        return
+                    row += 1
+            else:
+                if not startrow:
+                    row = self.GetGridCursorRow() - 1
+                else:
+                    row = startrow - 1
+                while True:
+                    try:
+                        foo = self.table.GetValue(row, 0)
+                        item = self.table.items[row]
+                        try:
+                            globals = ipipe.getglobals(None)
+                            if eval(searchexp, globals, ipipe.AttrNamespace(item)):
+                                self.SetGridCursor(row, 0) # found something
+                                self.MakeCellVisible(row, 0)
+                                break
+                        except (KeyboardInterrupt, SystemExit):
+                            raise
+                        except Exception, exc:
+                            frame.SetStatusText(str(exc))
+                            wx.Bell()
+                            break  # break on error
+                    except IndexError:
+                        return
+                    row -= 1
+
+
+    def search(self, searchtext, startrow=None, startcol=None, search_forward=True):
+        """
+        search for ``searchtext``, starting in ``(startrow, startcol)``;
+        if ``search_forward`` is true the direction is "forward"
+        """
+        searchtext = searchtext.lower()
+        if search_forward:
+            if startrow is not None and startcol is not None:
+                row = startrow
+            else:
+                startcol = self.GetGridCursorCol() + 1
+                row = self.GetGridCursorRow()
+                if startcol >= self.GetNumberCols():
+                    startcol = 0
+                    row += 1
+            while True:
+                for col in xrange(startcol, self.table.GetNumberCols()):
+                    try:
+                        foo = self.table.GetValue(row, col)
+                        text = self._getvalue(row, col)
+                        if searchtext in text.string().lower():
+                            self.SetGridCursor(row, col)
+                            self.MakeCellVisible(row, col)
+                            return
+                    except IndexError:
+                        return
+                startcol = 0
+                row += 1
+        else:
+            if startrow is not None and startcol is not None:
+                row = startrow
+            else:
+                startcol = self.GetGridCursorCol() - 1
+                row = self.GetGridCursorRow()
+                if startcol < 0:
+                    startcol = self.GetNumberCols() - 1
+                    row -= 1
+            while True:
+                for col in xrange(startcol, -1, -1):
+                    try:
+                        foo = self.table.GetValue(row, col)
+                        text = self._getvalue(row, col)
+                        if searchtext in text.string().lower():
+                            self.SetGridCursor(row, col)
+                            self.MakeCellVisible(row, col)
+                            return
+                    except IndexError:
+                        return
+                startcol = self.table.GetNumberCols()-1
+                row -= 1
+
+    def key_pressed(self, event):
+        """
+        Maps pressed keys to functions
+        """
+        frame = self.GetParent().GetParent().GetParent()
+        frame.SetStatusText("")
+        sh = event.ShiftDown()
+        ctrl = event.ControlDown()
+
+        keycode = event.GetKeyCode()
+        if keycode == ord("P"):
+            row = self.GetGridCursorRow()
+            if sh:
+                col = self.GetGridCursorCol()
+                self.pickattr(row, col)
+            else:
+                self.pick(row)
+        elif keycode == ord("M"):
+            if ctrl:
+                col = self.GetGridCursorCol()
+                self.pickrowsattr(sorted(self.current_selection), col)
+            else:
+                self.pickrows(sorted(self.current_selection))
+        elif keycode in (wx.WXK_BACK, wx.WXK_DELETE, ord("X")) and not (ctrl or sh):
+            self.delete_current_notebook()
+        elif keycode in (ord("E"), ord("\r")):
+            row = self.GetGridCursorRow()
+            if sh:
+                col = self.GetGridCursorCol()
+                self.enterattr(row, col)
+            else:
+                self.enter(row)
+        elif keycode == ord("E") and ctrl:
+            row = self.GetGridCursorRow()
+            self.SetGridCursor(row, self.GetNumberCols()-1)
+        elif keycode == wx.WXK_HOME or (keycode == ord("A") and ctrl):
+            row = self.GetGridCursorRow()
+            self.SetGridCursor(row, 0)
+        elif keycode == ord("C") and sh:
+            col = self.GetGridCursorCol()
+            attr = self.table._displayattrs[col]
+            result = []
+            for i in xrange(self.GetNumberRows()):
+                result.append(self.table._displayattrs[col].value(self.table.items[i]))
+            self.quit(result)
+        elif keycode in (wx.WXK_ESCAPE, ord("Q")) and not (ctrl or sh):
+            self.quit()
+        elif keycode == ord("<"):
+            row = self.GetGridCursorRow()
+            col = self.GetGridCursorCol()
+            if not event.ShiftDown():
+                newcol = col - 1
+                if newcol >= 0:
+                    self.SetGridCursor(row, col - 1)
+            else:
+                newcol = col + 1
+                if newcol < self.GetNumberCols():
+                    self.SetGridCursor(row, col + 1)
+        elif keycode == ord("D"):
+            col = self.GetGridCursorCol()
+            row = self.GetGridCursorRow()
+            if not sh:
+                self.detail(row, col)
+            else:
+                self.detail_attr(row, col)
+        elif keycode == ord("F") and ctrl:
+            if sh:
+                frame.enter_searchexpression(event)
+            else:
+                frame.enter_searchtext(event)
+        elif keycode == wx.WXK_F3:
+            if sh:
+                frame.find_previous(event)
+            else:
+                frame.find_next(event)
+        elif keycode == ord("V"):
+            if sh:
+                self.sortattrdesc()
+            else:
+                self.sortattrasc()
+        elif keycode == wx.WXK_DOWN:
+            row = self.GetGridCursorRow()
+            try:
+                item = self.table.items[row+1]
+            except IndexError:
+                item = self.table.items[row]
+            self.set_footer(item)
+            event.Skip()
+        elif keycode == wx.WXK_UP:
+            row = self.GetGridCursorRow()
+            if row >= 1:
+                item = self.table.items[row-1]
+            else:
+                item = self.table.items[row]
+            self.set_footer(item)
+            event.Skip()
+        elif keycode == wx.WXK_RIGHT:
+            row = self.GetGridCursorRow()
+            item = self.table.items[row]
+            self.set_footer(item)
+            event.Skip()
+        elif keycode == wx.WXK_LEFT:
+            row = self.GetGridCursorRow()
+            item = self.table.items[row]
+            self.set_footer(item)
+            event.Skip()
+        elif keycode == ord("R") or keycode == wx.WXK_F5:
+            self.table.refresh_content(event)
+        elif keycode == ord("I"):
+            row = self.GetGridCursorRow()
+            if not sh:
+                self.pickinput(row)
+            else:
+                col = self.GetGridCursorCol()
+                self.pickinputattr(row, col)
+        else:
+            event.Skip()
+
+    def delete_current_notebook(self):
+        """
+        deletes the current notebook tab
+        """
+        panel = self.GetParent()
+        nb = panel.GetParent()
+        current = nb.GetSelection()
+        count = nb.GetPageCount()
+        if count > 1:
+            for i in xrange(count-1, current-1, -1):
+                nb.DeletePage(i)
+            nb.GetCurrentPage().grid.SetFocus()
+        else:
+            frame = nb.GetParent()
+            frame.SetStatusText("This is the last level!")
+
+    def _doenter(self, value, *attrs):
+        """
+        "enter" a special item resulting in a new notebook tab
+        """
+        panel = self.GetParent()
+        nb = panel.GetParent()
+        frame = nb.GetParent()
+        current = nb.GetSelection()
+        count = nb.GetPageCount()
+        try: # if we want to enter something non-iterable, e.g. a function
+            if current + 1 == count and value is not self.input: # we have an event in the last tab
+                frame._add_notebook(value, *attrs)
+            elif value != self.input: # we have to delete all tabs newer than [panel] first
+                for i in xrange(count-1, current, -1): # some tabs don't close if we don't close in *reverse* order
+                    nb.DeletePage(i)
+                frame._add_notebook(value)
+        except TypeError, exc:
+            if exc.__class__.__module__ == "exceptions":
+                msg = "%s: %s" % (exc.__class__.__name__, exc)
+            else:
+                msg = "%s.%s: %s" % (exc.__class__.__module__, exc.__class__.__name__, exc)
+            frame.SetStatusText(msg)
+
+    def enterattr(self, row, col):
+        try:
+            attr = self.table._displayattrs[col]
+            value = attr.value(self.table.items[row])
+        except Exception, exc:
+            self.error_output(str(exc))
+        else:
+            self._doenter(value)
+
+    def set_footer(self, item):
+        frame = self.GetParent().GetParent().GetParent()
+        frame.SetStatusText(" ".join([str(text) for (style, text) in ipipe.xformat(item, "footer", 20)[2]]), 0)
+
+    def enter(self, row):
+        try:
+            value = self.table.items[row]
+        except Exception, exc:
+            self.error_output(str(exc))
+        else:
+            self._doenter(value)
+
+    def detail(self, row, col):
+        """
+        shows a detail-view of the current cell
+        """
+        try:
+            attr = self.table._displayattrs[col]
+            item = self.table.items[row]
+        except Exception, exc:
+            self.error_output(str(exc))
+        else:
+            attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
+            self._doenter(attrs)
+
+    def detail_attr(self, row, col):
+        try:
+            attr = self.table._displayattrs[col]
+            item = attr.value(self.table.items[row])
+        except Exception, exc:
+            self.error_output(str(exc))
+        else:
+            attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
+            self._doenter(attrs)
+
+    def quit(self, result=None):
+        """
+        quit
+        """
+        frame = self.GetParent().GetParent().GetParent()
+        if frame.helpdialog:
+            frame.helpdialog.Destroy()
+        app = frame.parent
+        if app is not None:
+            app.result = result
+        frame.Close()
+        frame.Destroy()
+
+    def cell_doubleclicked(self, event):
+        self.enterattr(event.GetRow(), event.GetCol())
+        event.Skip()
+
+    def cell_leftclicked(self, event):
+        row = event.GetRow()
+        item = self.table.items[row]
+        self.set_footer(item)
+        event.Skip()
+
+    def pick(self, row):
+        """
+        pick a single row and return to the IPython prompt
+        """
+        try:
+            value = self.table.items[row]
+        except Exception, exc:
+            self.error_output(str(exc))
+        else:
+            self.quit(value)
+
+    def pickinput(self, row):
+        try:
+            value = self.table.items[row]
+        except Exception, exc:
+            self.error_output(str(exc))
+        else:
+            api = ipapi.get()
+            api.set_next_input(str(value))
+            self.quit(value)
+
+    def pickinputattr(self, row, col):
+        try:
+            attr = self.table._displayattrs[col]
+            value = attr.value(self.table.items[row])
+        except Exception, exc:
+            self.error_output(str(exc))
+        else:
+            api = ipapi.get()
+            api.set_next_input(str(value))
+            self.quit(value)
+
+    def pickrows(self, rows):
+        """
+        pick multiple rows and return to the IPython prompt
+        """
+        try:
+            value = [self.table.items[row] for row in rows]
+        except Exception, exc:
+            self.error_output(str(exc))
+        else:
+            self.quit(value)
+
+    def pickrowsattr(self, rows, col):
+        """"
+        pick one column from multiple rows
+        """
+        values = []
+        try:
+            attr = self.table._displayattrs[col]
+            for row in rows:
+                try:
+                    values.append(attr.value(self.table.items[row]))
+                except (SystemExit, KeyboardInterrupt):
+                    raise
+                except Exception:
+                    raise #pass
+        except Exception, exc:
+            self.error_output(str(exc))
+        else:
+            self.quit(values)
+
+    def pickattr(self, row, col):
+        try:
+            attr = self.table._displayattrs[col]
+            value = attr.value(self.table.items[row])
+        except Exception, exc:
+            self.error_output(str(exc))
+        else:
+            self.quit(value)
+
+
+class IGridPanel(wx.Panel):
+    # Each IGridPanel contains an IGridGrid
+    def __init__(self, parent, input, *attrs):
+        wx.Panel.__init__(self, parent, -1)
+        self.grid = IGridGrid(self, input, *attrs)
+        self.grid.FitInside()
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(self.grid, proportion=1, flag=wx.EXPAND | wx.ALL, border=10)
+        self.SetSizer(sizer)
+        sizer.Fit(self)
+        sizer.SetSizeHints(self)
+
+
+class IGridHTMLHelp(wx.Frame):
+    def __init__(self, parent, title, size):
+        wx.Frame.__init__(self, parent, -1, title, size=size)
+        html = wx.html.HtmlWindow(self)
+        if "gtk2" in wx.PlatformInfo:
+            html.SetStandardFonts()
+        html.SetPage(help)
+
+
+class IGridFrame(wx.Frame):
+    maxtitlelen = 30
+
+    def __init__(self, parent, input):
+        title =  " ".join([str(text) for (style, text) in ipipe.xformat(input, "header", 20)[2]])
+        wx.Frame.__init__(self, None, title=title, size=(640, 480))
+        self.menubar = wx.MenuBar()
+        self.menucounter = 100
+        self.m_help = wx.Menu()
+        self.m_search = wx.Menu()
+        self.m_sort = wx.Menu()
+        self.m_refresh = wx.Menu()
+        self.notebook = wx.Notebook(self, -1, style=0)
+        self.statusbar = self.CreateStatusBar(1, wx.ST_SIZEGRIP)
+        self.statusbar.SetFieldsCount(2)
+        self.SetStatusWidths([-1, 200])
+        self.parent = parent
+        self._add_notebook(input)
+        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+        self.makemenu(self.m_sort, "&Sort (asc)\tV", "Sort ascending", self.sortasc)
+        self.makemenu(self.m_sort, "Sort (&desc)\tShift-V", "Sort descending", self.sortdesc)
+        self.makemenu(self.m_help, "&Help\tF1", "Help", self.display_help)
+#        self.makemenu(self.m_help, "&Show help in browser", "Show help in browser", self.display_help_in_browser)
+        self.makemenu(self.m_search, "&Find text\tCTRL-F", "Find text", self.enter_searchtext)
+        self.makemenu(self.m_search, "Find by &expression\tCTRL-Shift-F", "Find by expression", self.enter_searchexpression)
+        self.makemenu(self.m_search, "Find &next\tF3", "Find next", self.find_next)
+        self.makemenu(self.m_search, "Find &previous\tShift-F3", "Find previous", self.find_previous)
+        self.makemenu(self.m_refresh, "&Refresh once \tF5", "Refresh once", self.refresh_once)
+        self.makemenu(self.m_refresh, "Refresh every &1s", "Refresh every second", self.refresh_every_second)
+        self.makemenu(self.m_refresh, "Refresh every &X seconds", "Refresh every X seconds", self.refresh_interval)
+        self.makemenu(self.m_refresh, "&Stop all refresh timers", "Stop refresh timers", self.stop_refresh)
+        self.menubar.Append(self.m_search, "&Find")
+        self.menubar.Append(self.m_sort, "&Sort")
+        self.menubar.Append(self.m_refresh, "&Refresh")
+        self.menubar.Append(self.m_help, "&Help")
+        self.SetMenuBar(self.menubar)
+        self.searchtext = ""
+        self.searchexpression = ""
+        self.helpdialog = None
+        self.refresh_interval = 1000
+        self.SetStatusText("Refreshing inactive", 1)
+
+    def refresh_once(self, event):
+        table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
+        table.refresh_content(event)
+
+    def refresh_interval(self, event):
+        table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
+        dlg = wx.TextEntryDialog(self, "Enter refresh interval (milliseconds):", "Refresh timer:", defaultValue=str(self.refresh_interval))
+        if dlg.ShowModal() == wx.ID_OK:
+            try:
+                milliseconds = int(dlg.GetValue())
+            except ValueError, exc:
+                self.SetStatusText(str(exc))
+            else:
+                table.timer.Start(milliseconds=milliseconds, oneShot=False)
+                self.SetStatusText("Refresh timer set to %s ms" % milliseconds)
+                self.SetStatusText("Refresh interval: %s ms" % milliseconds, 1)
+                self.refresh_interval = milliseconds
+        dlg.Destroy()
+
+    def stop_refresh(self, event):
+        for i in xrange(self.notebook.GetPageCount()):
+            nb = self.notebook.GetPage(i)
+            nb.grid.table.timer.Stop()
+            self.SetStatusText("Refreshing inactive", 1)
+
+    def refresh_every_second(self, event):
+        table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
+        table.timer.Start(milliseconds=1000, oneShot=False)
+        self.SetStatusText("Refresh interval: 1000 ms", 1)
+
+    def sortasc(self, event):
+        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
+        grid.sortattrasc()
+
+    def sortdesc(self, event):
+        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
+        grid.sortattrdesc()
+
+    def find_previous(self, event):
+        """
+        find previous occurrences
+        """
+        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
+        if self.searchtext:
+            row = grid.GetGridCursorRow()
+            col = grid.GetGridCursorCol()
+            self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
+            if col-1 >= 0:
+                grid.search(self.searchtext, row, col-1, False)
+            else:
+                grid.search(self.searchtext, row-1, grid.table.GetNumberCols()-1, False)
+        elif self.searchexpression:
+            self.SetStatusText("Search mode: expression; looking for %s" % repr(self.searchexpression)[2:-1])
+            grid.searchexpression(searchexp=self.searchexpression, search_forward=False)
+        else:
+            self.SetStatusText("No search yet: please enter search-text or -expression")
+
+    def find_next(self, event):
+        """
+        find the next occurrence
+        """
+        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
+        if self.searchtext != "":
+            row = grid.GetGridCursorRow()
+            col = grid.GetGridCursorCol()
+            self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
+            if col+1 < grid.table.GetNumberCols():
+                grid.search(self.searchtext, row, col+1)
+            else:
+                grid.search(self.searchtext, row+1, 0)
+        elif self.searchexpression != "":
+            self.SetStatusText('Search mode: expression; looking for %s' % repr(self.searchexpression)[2:-1])
+            grid.searchexpression(searchexp=self.searchexpression)
+        else:
+            self.SetStatusText("No search yet: please enter search-text or -expression")
+
+    def display_help(self, event):
+        """
+        Display a help dialog
+        """
+        if self.helpdialog:
+            self.helpdialog.Destroy()
+        self.helpdialog = IGridHTMLHelp(None, title="Help", size=wx.Size(600,400))
+        self.helpdialog.Show()
+
+    def display_help_in_browser(self, event):
+        """
+        Show the help-HTML in a browser (as a ``HtmlWindow`` does not understand
+        CSS this looks better)
+        """
+        filename = urllib.pathname2url(os.path.abspath(os.path.join(os.path.dirname(__file__), "igrid_help.html")))
+        if not filename.startswith("file"):
+            filename = "file:" + filename
+        webbrowser.open(filename, new=1, autoraise=True)
+
+    def enter_searchexpression(self, event):
+        dlg = wx.TextEntryDialog(self, "Find:", "Find matching expression:", defaultValue=self.searchexpression)
+        if dlg.ShowModal() == wx.ID_OK:
+            self.searchexpression = dlg.GetValue()
+            self.searchtext = ""
+            self.SetStatusText('Search mode: expression; looking for %s' % repr(self.searchexpression)[2:-1])
+            self.notebook.GetPage(self.notebook.GetSelection()).grid.searchexpression(self.searchexpression)
+        dlg.Destroy()
+
+    def makemenu(self, menu, label, help, cmd):
+        menu.Append(self.menucounter, label, help)
+        self.Bind(wx.EVT_MENU, cmd, id=self.menucounter)
+        self.menucounter += 1
+
+    def _add_notebook(self, input, *attrs):
+        # Adds another notebook which has the starting object ``input``
+        panel = IGridPanel(self.notebook, input, *attrs)
+        text = str(ipipe.xformat(input, "header", self.maxtitlelen)[2])
+        if len(text) >= self.maxtitlelen:
+            text = text[:self.maxtitlelen].rstrip(".") + "..."
+        self.notebook.AddPage(panel, text, True)
+        panel.grid.SetFocus()
+        self.Layout()
+
+    def OnCloseWindow(self, event):
+        self.Destroy()
+
+    def enter_searchtext(self, event):
+        # Displays a dialog asking for the searchtext
+        dlg = wx.TextEntryDialog(self, "Find:", "Find in list", defaultValue=self.searchtext)
+        if dlg.ShowModal() == wx.ID_OK:
+            self.searchtext = dlg.GetValue()
+            self.searchexpression = ""
+            self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
+            self.notebook.GetPage(self.notebook.GetSelection()).grid.search(self.searchtext)
+        dlg.Destroy()
+
+
+class App(wx.App):
+    def __init__(self, input):
+        self.input = input
+        self.result = None # Result to be returned to IPython. Set by quit().
+        wx.App.__init__(self)
+
+    def OnInit(self):
+        frame = IGridFrame(self, self.input)
+        frame.Show()
+        self.SetTopWindow(frame)
+        frame.Raise()
+        return True
+
+
+class igrid(ipipe.Display):
+    """
+    This is a wx-based display object that can be used instead of ``ibrowse``
+    (which is curses-based) or ``idump`` (which simply does a print).
+    """
+
+    if wx.VERSION < (2, 7):
+        def display(self):
+            try:
+                # Try to create a "standalone" frame. If this works we're probably
+                # running with -wthread.
+                # Note that this sets the parent of the frame to None, but we can't
+                # pass a result object back to the shell anyway.
+                frame = IGridFrame(None, self.input)
+                frame.Show()
+                frame.Raise()
+            except wx.PyNoAppError:
+                # There's no wx application yet => create one.
+                app = App(self.input)
+                app.MainLoop()
+                return app.result
+    else:
+        # With wx 2.7 it gets simpler.
+        def display(self):
+            app = App(self.input)
+            app.MainLoop()
+            return app.result
+
diff --git a/IPython/Extensions/igrid_help.css b/IPython/Extensions/igrid_help.css
new file mode 100644
index 0000000..c875f4d
--- /dev/null
+++ b/IPython/Extensions/igrid_help.css
@@ -0,0 +1,45 @@
+body
+{
+	background-color: #fff;
+	color: #000;
+	font-family: "Verdana", "Arial", "XHelvetica", "Helvetica", sans-serif;
+	padding: 20px 30px;
+	margin: 0px;
+	font-size: 11px;
+}
+h1
+{
+	font-family: "Trebuchet MS", sans-serif;
+	font-size: 24px;
+	margin: -20px -30px 4px -30px;
+	padding: 6px 30px;
+	font-weight: normal;
+	border-bottom: 1px solid #000;
+	letter-spacing: 1px;
+	background-color: #666;
+	color: #fff;
+}
+h2
+{
+	font-family: "Trebuchet MS", sans-serif;
+	font-size: 20px;
+	padding: 14px 0px 2px 0px;
+	margin: 0px;
+	font-weight: bold;
+	color: #333;
+}
+h3
+{
+	font-family: "Trebuchet MS", sans-serif;
+	font-size: 14px;
+	padding: 12px 0px 2px 0px;
+	margin: 0px;
+	font-weight: bold;
+	color: #333;
+}
+p
+{
+	line-height: 120%;
+	margin: 0px 0px 6px 0px;
+	padding: 0px;
+}
diff --git a/IPython/Extensions/igrid_help.html b/IPython/Extensions/igrid_help.html
new file mode 100644
index 0000000..f11068e
--- /dev/null
+++ b/IPython/Extensions/igrid_help.html
@@ -0,0 +1,86 @@
+<?xml version='1.0' encoding='iso-8859-1'?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+<link rel="stylesheet" href="igrid_help.css" type="text/css" />
+<title>igrid help</title>
+</head>
+<body>
+<h1>igrid help</h1>
+
+
+<h2>Commands</h2>
+
+
+<h3>pick (P)</h3>
+<p>Pick the whole row (object is available as "_")</p>
+
+<h3>pickattr (Shift-P)</h3>
+<p>Pick the attribute under the cursor</p>
+
+<h3>pickallattrs (Shift-C)</h3>
+<p>Pick' the complete column under the cursor (i.e. the attribute under the
+cursor) from all currently fetched objects. These attributes will be returned
+as a list.</p>
+
+<h3>enter (E)</h3>
+<p>Enter the object under the cursor. (what this mean depends on the object
+itself, i.e. how it implements iteration). This opens a new browser 'level'.</p>
+
+<h3>enterattr (Shift-E)</h3>
+<p>Enter the attribute under the cursor.</p>
+
+<h3>detail (D)</h3>
+<p>Show a detail view of the object under the cursor. This shows the name,
+type, doc string and value of the object attributes (and it might show more
+attributes than in the list view, depending on the object).</p>
+
+<h3>detailattr (Shift-D)</h3>
+<p>Show a detail view of the attribute under the cursor.</p>
+
+<h3>pickrows (M)</h3>
+<p>Pick multiple selected rows (M)</p>
+
+<h3>pickrowsattr (CTRL-M)</h3>
+<p>From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)</p>
+
+<h3>find (CTRL-F)</h3>
+<p>Find text</p>
+
+<h3>find_next (F3)</h3>
+<p>Find next occurrence of the searchtext</p>
+
+<h3>find_previous (Shift-F3)</h3>
+<p>Find previous occurrence of the searchtext </p>
+
+<h3>sortattrasc (V)</h3>
+<p>Sort the objects (in ascending order) using the attribute under the cursor as the sort key.</p>
+
+<h3>sortattrdesc (Shift-V)</h3>
+<p>Sort the objects (in descending order) using the attribute under the cursor as the sort key.</p>
+
+<h3>leave (Backspace, DEL, X)</h3>
+<p>Close current tab (and all the tabs to the right of the current one).</h3>
+
+<h3>quit (ESC,Q)</h3>
+<p>Quit igrid and return to the IPython prompt.</p>
+
+
+<h2>Navigation</h2>
+
+
+<h3>Jump to the last column of the current row (END, CTRL-E, CTRL-Right)</h3>
+
+<h3>Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)</h3>
+
+<h3>Move the cursor one column to the left (&lt;)</h3>
+
+<h3>Move the cursor one column to the right (&gt;)</h3>
+
+<h3>Jump to the first row in the current column (CTRL-Up)</h3>
+
+<h3>Jump to the last row in the current column (CTRL-Down)</h3>
+
+</body>
+</html>
diff --git a/IPython/Extensions/ipipe.py b/IPython/Extensions/ipipe.py
new file mode 100644
index 0000000..1d2eedf
--- /dev/null
+++ b/IPython/Extensions/ipipe.py
@@ -0,0 +1,2292 @@
+# -*- coding: iso-8859-1 -*-
+
+"""
+``ipipe`` provides classes to be used in an interactive Python session. Doing a
+``from ipipe import *`` is the preferred way to do this. The name of all
+objects imported this way starts with ``i`` to minimize collisions.
+
+``ipipe`` supports "pipeline expressions", which is something resembling Unix
+pipes. An example is::
+
+    >>> ienv | isort("key.lower()")
+
+This gives a listing of all environment variables sorted by name.
+
+
+There are three types of objects in a pipeline expression:
+
+* ``Table``s: These objects produce items. Examples are ``ils`` (listing the
+  current directory, ``ienv`` (listing environment variables), ``ipwd`` (listing
+  user accounts) and ``igrp`` (listing user groups). A ``Table`` must be the
+  first object in a pipe expression.
+
+* ``Pipe``s: These objects sit in the middle of a pipe expression. They
+  transform the input in some way (e.g. filtering or sorting it). Examples are:
+  ``ifilter`` (which filters the input pipe), ``isort`` (which sorts the input
+  pipe) and ``ieval`` (which evaluates a function or expression for each object
+  in the input pipe).
+
+* ``Display``s: These objects can be put as the last object in a pipeline
+  expression. There are responsible for displaying the result of the pipeline
+  expression. If a pipeline expression doesn't end in a display object a default
+  display objects will be used. One example is ``ibrowse`` which is a ``curses``
+  based browser.
+
+
+Adding support for pipeline expressions to your own objects can be done through
+three extensions points (all of them optional):
+
+* An object that will be displayed as a row by a ``Display`` object should
+  implement the method ``__xattrs__(self, mode)`` method or register an
+  implementation of the generic function ``xattrs``. For more info see ``xattrs``.
+
+* When an object ``foo`` is displayed by a ``Display`` object, the generic
+  function ``xrepr`` is used.
+
+* Objects that can be iterated by ``Pipe``s must iterable. For special cases,
+  where iteration for display is different than the normal iteration a special
+  implementation can be registered with the generic function ``xiter``. This
+  makes it possible to use dictionaries and modules in pipeline expressions,
+  for example::
+
+      >>> import sys
+      >>> sys | ifilter("isinstance(value, int)") | idump
+      key        |value
+      api_version|      1012
+      dllhandle  | 503316480
+      hexversion |  33817328
+      maxint     |2147483647
+      maxunicode |     65535
+      >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
+      ...
+
+  Note: The expression strings passed to ``ifilter()`` and ``isort()`` can
+  refer to the object to be filtered or sorted via the variable ``_`` and to any
+  of the attributes of the object, i.e.::
+
+      >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
+
+  does the same as::
+
+      >>> sys.modules | ifilter("value is not None") | isort("key.lower()")
+
+  In addition to expression strings, it's possible to pass callables (taking
+  the object as an argument) to ``ifilter()``, ``isort()`` and ``ieval()``::
+
+      >>> sys | ifilter(lambda _:isinstance(_.value, int)) \
+      ...     | ieval(lambda _: (_.key, hex(_.value))) | idump
+      0          |1
+      api_version|0x3f4
+      dllhandle  |0x1e000000
+      hexversion |0x20402f0
+      maxint     |0x7fffffff
+      maxunicode |0xffff
+"""
+
+import sys, os, os.path, stat, glob, new, csv, datetime, types
+import itertools, mimetypes, StringIO
+
+try: # Python 2.3 compatibility
+    import collections
+except ImportError:
+    deque = list
+else:
+    deque = collections.deque
+
+try: # Python 2.3 compatibility
+    set
+except NameError:
+    import sets
+    set = sets.Set
+
+try: # Python 2.3 compatibility
+    sorted
+except NameError:
+    def sorted(iterator, key=None, reverse=False):
+        items = list(iterator)
+        if key is not None:
+            items.sort(lambda i1, i2: cmp(key(i1), key(i2)))
+        else:
+            items.sort()
+        if reverse:
+            items.reverse()
+        return items
+
+try:
+    import pwd
+except ImportError:
+    pwd = None
+
+try:
+    import grp
+except ImportError:
+    grp = None
+
+from IPython.external import simplegeneric
+
+import path
+
+try:
+    from IPython import genutils, generics
+except ImportError:
+    genutils = None
+    generics = None
+
+from IPython import ipapi
+
+
+__all__ = [
+    "ifile", "ils", "iglob", "iwalk", "ipwdentry", "ipwd", "igrpentry", "igrp",
+    "icsv", "ix", "ichain", "isort", "ifilter", "ieval", "ienum",
+    "ienv", "ihist", "ialias", "icap", "idump", "iless"
+]
+
+
+os.stat_float_times(True) # enable microseconds
+
+
+class AttrNamespace(object):
+    """
+    Helper class that is used for providing a namespace for evaluating
+    expressions containing attribute names of an object.
+    """
+    def __init__(self, wrapped):
+        self.wrapped = wrapped
+
+    def __getitem__(self, name):
+        if name == "_":
+            return self.wrapped
+        try:
+            return getattr(self.wrapped, name)
+        except AttributeError:
+            raise KeyError(name)
+
+# Python 2.3 compatibility
+# use eval workaround to find out which names are used in the
+# eval string and put them into the locals. This works for most
+# normal uses case, bizarre ones like accessing the locals()
+# will fail
+try:
+    eval("_", None, AttrNamespace(None))
+except TypeError:
+    real_eval = eval
+    def eval(codestring, _globals, _locals):
+        """
+        eval(source[, globals[, locals]]) -> value
+
+        Evaluate the source in the context of globals and locals.
+        The source may be a string representing a Python expression
+        or a code object as returned by compile().
+        The globals must be a dictionary and locals can be any mappping.
+
+        This function is a workaround for the shortcomings of
+        Python 2.3's eval.
+        """
+
+        if isinstance(codestring, basestring):
+            code = compile(codestring, "_eval", "eval")
+        else:
+            code = codestring
+        newlocals = {}
+        for name in code.co_names:
+            try:
+                newlocals[name] = _locals[name]
+            except KeyError:
+                pass
+        return real_eval(code, _globals, newlocals)
+
+
+noitem = object()
+
+
+def item(iterator, index, default=noitem):
+    """
+    Return the ``index``th item from the iterator ``iterator``.
+    ``index`` must be an integer (negative integers are relative to the
+    end (i.e. the last items produced by the iterator)).
+
+    If ``default`` is given, this will be the default value when
+    the iterator doesn't contain an item at this position. Otherwise an
+    ``IndexError`` will be raised.
+
+    Note that using this function will partially or totally exhaust the
+    iterator.
+    """
+    i = index
+    if i>=0:
+        for item in iterator:
+            if not i:
+                return item
+            i -= 1
+    else:
+        i = -index
+        cache = deque()
+        for item in iterator:
+            cache.append(item)
+            if len(cache)>i:
+                cache.popleft()
+        if len(cache)==i:
+            return cache.popleft()
+    if default is noitem:
+        raise IndexError(index)
+    else:
+        return default
+
+
+def getglobals(g):
+    """
+    Return the global namespace that is used for expression strings in
+    ``ifilter`` and others. This is ``g`` or (if ``g`` is ``None``) IPython's
+    user namespace.
+    """
+    if g is None:
+        if ipapi is not None:
+            api = ipapi.get()
+            if api is not None:
+                return api.user_ns
+        return globals()
+    return g
+
+
+class Descriptor(object):
+    """
+    A ``Descriptor`` object is used for describing the attributes of objects.
+    """
+    def __hash__(self):
+        return hash(self.__class__) ^ hash(self.key())
+
+    def __eq__(self, other):
+        return self.__class__ is other.__class__ and self.key() == other.key()
+
+    def __ne__(self, other):
+        return self.__class__ is not other.__class__ or self.key() != other.key()
+
+    def key(self):
+        pass
+
+    def name(self):
+        """
+        Return the name of this attribute for display by a ``Display`` object
+        (e.g. as a column title).
+        """
+        key = self.key()
+        if key is None:
+            return "_"
+        return str(key)
+
+    def attrtype(self, obj):
+        """
+        Return the type of this attribute (i.e. something like "attribute" or
+        "method").
+        """
+
+    def valuetype(self, obj):
+        """
+        Return the type of this attribute value of the object ``obj``.
+        """
+
+    def value(self, obj):
+        """
+        Return the value of this attribute of the object ``obj``.
+        """
+
+    def doc(self, obj):
+        """
+        Return the documentation for this attribute.
+        """
+
+    def shortdoc(self, obj):
+        """
+        Return a short documentation for this attribute (defaulting to the
+        first line).
+        """
+        doc = self.doc(obj)
+        if doc is not None:
+            doc = doc.strip().splitlines()[0].strip()
+        return doc
+
+    def iter(self, obj):
+        """
+        Return an iterator for this attribute of the object ``obj``.
+        """
+        return xiter(self.value(obj))
+
+
+class SelfDescriptor(Descriptor):
+    """
+    A ``SelfDescriptor`` describes the object itself.
+    """
+    def key(self):
+        return None
+
+    def attrtype(self, obj):
+        return "self"
+
+    def valuetype(self, obj):
+        return type(obj)
+
+    def value(self, obj):
+        return obj
+
+    def __repr__(self):
+        return "Self"
+
+selfdescriptor = SelfDescriptor() # there's no need for more than one
+
+
+class AttributeDescriptor(Descriptor):
+    """
+    An ``AttributeDescriptor`` describes a simple attribute of an object.
+    """
+    __slots__ = ("_name", "_doc")
+
+    def __init__(self, name, doc=None):
+        self._name = name
+        self._doc = doc
+
+    def key(self):
+        return self._name
+
+    def doc(self, obj):
+        return self._doc
+
+    def attrtype(self, obj):
+        return "attr"
+
+    def valuetype(self, obj):
+        return type(getattr(obj, self._name))
+
+    def value(self, obj):
+        return getattr(obj, self._name)
+
+    def __repr__(self):
+        if self._doc is None:
+            return "Attribute(%r)" % self._name
+        else:
+            return "Attribute(%r, %r)" % (self._name, self._doc)
+
+
+class IndexDescriptor(Descriptor):
+    """
+    An ``IndexDescriptor`` describes an "attribute" of an object that is fetched
+    via ``__getitem__``.
+    """
+    __slots__ = ("_index",)
+
+    def __init__(self, index):
+        self._index = index
+
+    def key(self):
+        return self._index
+
+    def attrtype(self, obj):
+        return "item"
+
+    def valuetype(self, obj):
+        return type(obj[self._index])
+
+    def value(self, obj):
+        return obj[self._index]
+
+    def __repr__(self):
+        return "Index(%r)" % self._index
+
+
+class MethodDescriptor(Descriptor):
+    """
+    A ``MethodDescriptor`` describes a method of an object that can be called
+    without argument. Note that this method shouldn't change the object.
+    """
+    __slots__ = ("_name", "_doc")
+
+    def __init__(self, name, doc=None):
+        self._name = name
+        self._doc = doc
+
+    def key(self):
+        return self._name
+
+    def doc(self, obj):
+        if self._doc is None:
+            return getattr(obj, self._name).__doc__
+        return self._doc
+
+    def attrtype(self, obj):
+        return "method"
+
+    def valuetype(self, obj):
+        return type(self.value(obj))
+
+    def value(self, obj):
+        return getattr(obj, self._name)()
+
+    def __repr__(self):
+        if self._doc is None:
+            return "Method(%r)" % self._name
+        else:
+            return "Method(%r, %r)" % (self._name, self._doc)
+
+
+class IterAttributeDescriptor(Descriptor):
+    """
+    An ``IterAttributeDescriptor`` works like an ``AttributeDescriptor`` but
+    doesn't return an attribute values (because this value might be e.g. a large
+    list).
+    """
+    __slots__ = ("_name", "_doc")
+
+    def __init__(self, name, doc=None):
+        self._name = name
+        self._doc = doc
+
+    def key(self):
+        return self._name
+
+    def doc(self, obj):
+        return self._doc
+
+    def attrtype(self, obj):
+        return "iter"
+
+    def valuetype(self, obj):
+        return noitem
+
+    def value(self, obj):
+        return noitem
+
+    def iter(self, obj):
+        return xiter(getattr(obj, self._name))
+
+    def __repr__(self):
+        if self._doc is None:
+            return "IterAttribute(%r)" % self._name
+        else:
+            return "IterAttribute(%r, %r)" % (self._name, self._doc)
+
+
+class IterMethodDescriptor(Descriptor):
+    """
+    An ``IterMethodDescriptor`` works like an ``MethodDescriptor`` but doesn't
+    return an attribute values (because this value might be e.g. a large list).
+    """
+    __slots__ = ("_name", "_doc")
+
+    def __init__(self, name, doc=None):
+        self._name = name
+        self._doc = doc
+
+    def key(self):
+        return self._name
+
+    def doc(self, obj):
+        if self._doc is None:
+            return getattr(obj, self._name).__doc__
+        return self._doc
+
+    def attrtype(self, obj):
+        return "itermethod"
+
+    def valuetype(self, obj):
+        return noitem
+
+    def value(self, obj):
+        return noitem
+
+    def iter(self, obj):
+        return xiter(getattr(obj, self._name)())
+
+    def __repr__(self):
+        if self._doc is None:
+            return "IterMethod(%r)" % self._name
+        else:
+            return "IterMethod(%r, %r)" % (self._name, self._doc)
+
+
+class FunctionDescriptor(Descriptor):
+    """
+    A ``FunctionDescriptor`` turns a function into a descriptor. The function
+    will be called with the object to get the type and value of the attribute.
+    """
+    __slots__ = ("_function", "_name", "_doc")
+
+    def __init__(self, function, name=None, doc=None):
+        self._function = function
+        self._name = name
+        self._doc = doc
+
+    def key(self):
+        return self._function
+
+    def name(self):
+        if self._name is not None:
+            return self._name
+        return getattr(self._function, "__xname__", self._function.__name__)
+
+    def doc(self, obj):
+        if self._doc is None:
+            return self._function.__doc__
+        return self._doc
+
+    def attrtype(self, obj):
+        return "function"
+
+    def valuetype(self, obj):
+        return type(self._function(obj))
+
+    def value(self, obj):
+        return self._function(obj)
+
+    def __repr__(self):
+        if self._doc is None:
+            return "Function(%r)" % self._name
+        else:
+            return "Function(%r, %r)" % (self._name, self._doc)
+
+
+class Table(object):
+    """
+    A ``Table`` is an object that produces items (just like a normal Python
+    iterator/generator does) and can be used as the first object in a pipeline
+    expression. The displayhook will open the default browser for such an object
+    (instead of simply printing the ``repr()`` result).
+    """
+
+    # We want to support ``foo`` and ``foo()`` in pipeline expression:
+    # So we implement the required operators (``|`` and ``+``) in the metaclass,
+    # instantiate the class and forward the operator to the instance
+    class __metaclass__(type):
+        def __iter__(self):
+            return iter(self())
+
+        def __or__(self, other):
+            return self() | other
+
+        def __add__(self, other):
+            return self() + other
+
+        def __radd__(self, other):
+            return other + self()
+
+        def __getitem__(self, index):
+            return self()[index]
+
+    def __getitem__(self, index):
+        return item(self, index)
+
+    def __contains__(self, item):
+        for haveitem in self:
+            if item == haveitem:
+                return True
+        return False
+
+    def __or__(self, other):
+        # autoinstantiate right hand side
+        if isinstance(other, type) and issubclass(other, (Table, Display)):
+            other = other()
+        # treat simple strings and functions as ``ieval`` instances
+        elif not isinstance(other, Display) and not isinstance(other, Table):
+            other = ieval(other)
+        # forward operations to the right hand side
+        return other.__ror__(self)
+
+    def __add__(self, other):
+        # autoinstantiate right hand side
+        if isinstance(other, type) and issubclass(other, Table):
+            other = other()
+        return ichain(self, other)
+
+    def __radd__(self, other):
+        # autoinstantiate left hand side
+        if isinstance(other, type) and issubclass(other, Table):
+            other = other()
+        return ichain(other, self)
+
+
+class Pipe(Table):
+    """
+    A ``Pipe`` is an object that can be used in a pipeline expression. It
+    processes the objects it gets from its input ``Table``/``Pipe``. Note that
+    a ``Pipe`` object can't be used as the first object in a pipeline
+    expression, as it doesn't produces items itself.
+    """
+    class __metaclass__(Table.__metaclass__):
+        def __ror__(self, input):
+            return input | self()
+
+    def __ror__(self, input):
+        # autoinstantiate left hand side
+        if isinstance(input, type) and issubclass(input, Table):
+            input = input()
+        self.input = input
+        return self
+
+
+def xrepr(item, mode="default"):
+    """
+    Generic function that adds color output and different display modes to ``repr``.
+
+    The result of an ``xrepr`` call is iterable and consists of ``(style, string)``
+    tuples. The ``style`` in this tuple must be a ``Style`` object from the
+    ``astring`` module. To reconfigure the output the first yielded tuple can be
+    a ``(aligment, full)`` tuple instead of a ``(style, string)`` tuple.
+    ``alignment``  can be -1 for left aligned, 0 for centered and 1 for right
+    aligned (the default is left alignment). ``full`` is a boolean that specifies
+    whether the complete output must be displayed or the ``Display`` object is
+    allowed to stop output after enough text has been produced (e.g. a syntax
+    highlighted text line would use ``True``, but for a large data structure
+    (i.e. a nested list, tuple or dictionary) ``False`` would be used).
+    The default is full output.
+
+    There are four different possible values for ``mode`` depending on where
+    the ``Display`` object will display ``item``:
+
+    ``"header"``
+        ``item`` will be displayed in a header line (this is used by ``ibrowse``).
+
+    ``"footer"``
+        ``item`` will be displayed in a footer line (this is used by ``ibrowse``).
+
+    ``"cell"``
+        ``item`` will be displayed in a table cell/list.
+
+    ``"default"``
+        default mode. If an ``xrepr`` implementation recursively outputs objects,
+        ``"default"`` must be passed in the recursive calls to ``xrepr``.
+
+    If no implementation is registered for ``item``, ``xrepr`` will try the
+    ``__xrepr__`` method on ``item``. If ``item`` doesn't have an ``__xrepr__``
+    method it falls back to ``repr``/``__repr__`` for all modes.
+    """
+    try:
+        func = item.__xrepr__
+    except AttributeError:
+        yield (astyle.style_default, repr(item))
+    else:
+        try:
+            for x in func(mode):
+                yield x
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception:
+            yield (astyle.style_default, repr(item))
+xrepr = simplegeneric.generic(xrepr)
+
+
+def xrepr_none(self, mode="default"):
+    yield (astyle.style_type_none, repr(self))
+xrepr.when_object(None)(xrepr_none)
+
+
+def xrepr_noitem(self, mode="default"):
+    yield (2, True)
+    yield (astyle.style_nodata, "<?>")
+xrepr.when_object(noitem)(xrepr_noitem)
+
+
+def xrepr_bool(self, mode="default"):
+    yield (astyle.style_type_bool, repr(self))
+xrepr.when_type(bool)(xrepr_bool)
+
+
+def xrepr_str(self, mode="default"):
+    if mode == "cell":
+        yield (astyle.style_default, repr(self.expandtabs(tab))[1:-1])
+    else:
+        yield (astyle.style_default, repr(self))
+xrepr.when_type(str)(xrepr_str)
+
+
+def xrepr_unicode(self, mode="default"):
+    if mode == "cell":
+        yield (astyle.style_default, repr(self.expandtabs(tab))[2:-1])
+    else:
+        yield (astyle.style_default, repr(self))
+xrepr.when_type(unicode)(xrepr_unicode)
+
+
+def xrepr_number(self, mode="default"):
+    yield (1, True)
+    yield (astyle.style_type_number, repr(self))
+xrepr.when_type(int)(xrepr_number)
+xrepr.when_type(long)(xrepr_number)
+xrepr.when_type(float)(xrepr_number)
+
+
+def xrepr_complex(self, mode="default"):
+    yield (astyle.style_type_number, repr(self))
+xrepr.when_type(complex)(xrepr_number)
+
+
+def xrepr_datetime(self, mode="default"):
+    if mode == "cell":
+        # Don't use strftime() here, as this requires year >= 1900
+        yield (astyle.style_type_datetime,
+               "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
+                    (self.year, self.month, self.day,
+                     self.hour, self.minute, self.second,
+                     self.microsecond),
+                )
+    else:
+        yield (astyle.style_type_datetime, repr(self))
+xrepr.when_type(datetime.datetime)(xrepr_datetime)
+
+
+def xrepr_date(self, mode="default"):
+    if mode == "cell":
+        yield (astyle.style_type_datetime,
+               "%04d-%02d-%02d" % (self.year, self.month, self.day))
+    else:
+        yield (astyle.style_type_datetime, repr(self))
+xrepr.when_type(datetime.date)(xrepr_date)
+
+
+def xrepr_time(self, mode="default"):
+    if mode == "cell":
+        yield (astyle.style_type_datetime,
+                "%02d:%02d:%02d.%06d" % \
+                    (self.hour, self.minute, self.second, self.microsecond))
+    else:
+        yield (astyle.style_type_datetime, repr(self))
+xrepr.when_type(datetime.time)(xrepr_time)
+
+
+def xrepr_timedelta(self, mode="default"):
+    yield (astyle.style_type_datetime, repr(self))
+xrepr.when_type(datetime.timedelta)(xrepr_timedelta)
+
+
+def xrepr_type(self, mode="default"):
+    if self.__module__ == "__builtin__":
+        yield (astyle.style_type_type, self.__name__)
+    else:
+        yield (astyle.style_type_type, "%s.%s" % (self.__module__, self.__name__))
+xrepr.when_type(type)(xrepr_type)
+
+
+def xrepr_exception(self, mode="default"):
+    if self.__class__.__module__ == "exceptions":
+        classname = self.__class__.__name__
+    else:
+        classname = "%s.%s" % \
+            (self.__class__.__module__, self.__class__.__name__)
+    if mode == "header" or mode == "footer":
+        yield (astyle.style_error, "%s: %s" % (classname, self))
+    else:
+        yield (astyle.style_error, classname)
+xrepr.when_type(Exception)(xrepr_exception)
+
+
+def xrepr_listtuple(self, mode="default"):
+    if mode == "header" or mode == "footer":
+        if self.__class__.__module__ == "__builtin__":
+            classname = self.__class__.__name__
+        else:
+            classname = "%s.%s" % \
+                (self.__class__.__module__,self.__class__.__name__)
+        yield (astyle.style_default,
+               "<%s object with %d items at 0x%x>" % \
+                   (classname, len(self), id(self)))
+    else:
+        yield (-1, False)
+        if isinstance(self, list):
+            yield (astyle.style_default, "[")
+            end = "]"
+        else:
+            yield (astyle.style_default, "(")
+            end = ")"
+        for (i, subself) in enumerate(self):
+            if i:
+                yield (astyle.style_default, ", ")
+            for part in xrepr(subself, "default"):
+                yield part
+        yield (astyle.style_default, end)
+xrepr.when_type(list)(xrepr_listtuple)
+xrepr.when_type(tuple)(xrepr_listtuple)
+
+
+def xrepr_dict(self, mode="default"):
+    if mode == "header" or mode == "footer":
+        if self.__class__.__module__ == "__builtin__":
+            classname = self.__class__.__name__
+        else:
+            classname = "%s.%s" % \
+                (self.__class__.__module__,self.__class__.__name__)
+        yield (astyle.style_default,
+               "<%s object with %d items at 0x%x>" % \
+                (classname, len(self), id(self)))
+    else:
+        yield (-1, False)
+        if isinstance(self, dict):
+            yield (astyle.style_default, "{")
+            end = "}"
+        else:
+            yield (astyle.style_default, "dictproxy((")
+            end = "})"
+        for (i, (key, value)) in enumerate(self.iteritems()):
+            if i:
+                yield (astyle.style_default, ", ")
+            for part in xrepr(key, "default"):
+                yield part
+            yield (astyle.style_default, ": ")
+            for part in xrepr(value, "default"):
+                yield part
+        yield (astyle.style_default, end)
+xrepr.when_type(dict)(xrepr_dict)
+xrepr.when_type(types.DictProxyType)(xrepr_dict)
+
+
+def upgradexattr(attr):
+    """
+    Convert an attribute descriptor string to a real descriptor object.
+
+    If attr already is a descriptor object return if unmodified. A
+    ``SelfDescriptor`` will be returned if ``attr`` is ``None``. ``"foo"``
+    returns an ``AttributeDescriptor`` for the attribute named ``"foo"``.
+    ``"foo()"`` returns a ``MethodDescriptor`` for the method named ``"foo"``.
+    ``"-foo"`` will return an ``IterAttributeDescriptor`` for the attribute
+    named ``"foo"`` and ``"-foo()"`` will return an ``IterMethodDescriptor``
+    for the method named ``"foo"``. Furthermore integer will return the appropriate
+    ``IndexDescriptor`` and callables will return a ``FunctionDescriptor``.
+    """
+    if attr is None:
+        return selfdescriptor
+    elif isinstance(attr, Descriptor):
+        return attr
+    elif isinstance(attr, str):
+        if attr.endswith("()"):
+            if attr.startswith("-"):
+                return IterMethodDescriptor(attr[1:-2])
+            else:
+                return MethodDescriptor(attr[:-2])
+        else:
+            if attr.startswith("-"):
+                return IterAttributeDescriptor(attr[1:])
+            else:
+                return AttributeDescriptor(attr)
+    elif isinstance(attr, (int, long)):
+        return IndexDescriptor(attr)
+    elif callable(attr):
+        return FunctionDescriptor(attr)
+    else:
+        raise TypeError("can't handle descriptor %r" % attr)
+
+
+def xattrs(item, mode="default"):
+    """
+    Generic function that returns an iterable of attribute descriptors
+    to be used for displaying the attributes ob the object ``item`` in display
+    mode ``mode``.
+
+    There are two possible modes:
+
+    ``"detail"``
+        The ``Display`` object wants to display a detailed list of the object
+        attributes.
+
+    ``"default"``
+        The ``Display`` object wants to display the object in a list view.
+
+    If no implementation is registered for the object ``item`` ``xattrs`` falls
+    back to trying the ``__xattrs__`` method of the object. If this doesn't
+    exist either, ``dir(item)`` is used for ``"detail"`` mode and ``(None,)``
+    for ``"default"`` mode.
+
+    The implementation must yield attribute descriptors (see the class
+    ``Descriptor`` for more info). The ``__xattrs__`` method may also return
+    attribute descriptor strings (and ``None``) which will be converted to real
+    descriptors by ``upgradexattr()``.
+    """
+    try:
+        func = item.__xattrs__
+    except AttributeError:
+        if mode == "detail":
+            for attrname in dir(item):
+                yield AttributeDescriptor(attrname)
+        else:
+            yield selfdescriptor
+    else:
+        for attr in func(mode):
+            yield upgradexattr(attr)
+xattrs = simplegeneric.generic(xattrs)
+
+
+def xattrs_complex(self, mode="default"):
+    if mode == "detail":
+        return (AttributeDescriptor("real"), AttributeDescriptor("imag"))
+    return (selfdescriptor,)
+xattrs.when_type(complex)(xattrs_complex)
+
+
+def _isdict(item):
+    try:
+        itermeth = item.__class__.__iter__
+    except (AttributeError, TypeError):
+        return False
+    return itermeth is dict.__iter__ or itermeth is types.DictProxyType.__iter__
+
+
+def _isstr(item):
+    if not isinstance(item, basestring):
+        return False
+    try:
+        itermeth = item.__class__.__iter__
+    except AttributeError:
+        return True
+    return False # ``__iter__`` has been redefined
+
+
+def xiter(item):
+    """
+    Generic function that implements iteration for pipeline expression. If no
+    implementation is registered for ``item`` ``xiter`` falls back to ``iter``.
+    """
+    try:
+        func = item.__xiter__
+    except AttributeError:
+        if _isdict(item):
+            def items(item):
+                fields = ("key", "value")
+                for (key, value) in item.iteritems():
+                    yield Fields(fields, key=key, value=value)
+            return items(item)
+        elif isinstance(item, new.module):
+            def items(item):
+                fields = ("key", "value")
+                for key in sorted(item.__dict__):
+                    yield Fields(fields, key=key, value=getattr(item, key))
+            return items(item)
+        elif _isstr(item):
+            if not item:
+                raise ValueError("can't enter empty string")
+            lines = item.splitlines()
+            if len(lines) == 1:
+               def iterone(item):
+                   yield item
+               return iterone(item)
+            else:
+                return iter(lines)
+        return iter(item)
+    else:
+        return iter(func()) # iter() just to be safe
+xiter = simplegeneric.generic(xiter)
+
+
+class ichain(Pipe):
+    """
+    Chains multiple ``Table``s into one.
+    """
+
+    def __init__(self, *iters):
+        self.iters = iters
+
+    def __iter__(self):
+        return itertools.chain(*self.iters)
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer":
+            for (i, item) in enumerate(self.iters):
+                if i:
+                    yield (astyle.style_default, "+")
+                if isinstance(item, Pipe):
+                    yield (astyle.style_default, "(")
+                for part in xrepr(item, mode):
+                    yield part
+                if isinstance(item, Pipe):
+                    yield (astyle.style_default, ")")
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __repr__(self):
+        args = ", ".join([repr(it) for it in self.iters])
+        return "%s.%s(%s)" % \
+            (self.__class__.__module__, self.__class__.__name__, args)
+
+
+class ifile(path.path):
+    """
+    file (or directory) object.
+    """
+
+    def getmode(self):
+        return self.stat().st_mode
+    mode = property(getmode, None, None, "Access mode")
+
+    def gettype(self):
+        data = [
+            (stat.S_ISREG, "file"),
+            (stat.S_ISDIR, "dir"),
+            (stat.S_ISCHR, "chardev"),
+            (stat.S_ISBLK, "blockdev"),
+            (stat.S_ISFIFO, "fifo"),
+            (stat.S_ISLNK, "symlink"),
+            (stat.S_ISSOCK,"socket"),
+        ]
+        lstat = self.lstat()
+        if lstat is not None:
+            types = set([text for (func, text) in data if func(lstat.st_mode)])
+        else:
+            types = set()
+        m = self.mode
+        types.update([text for (func, text) in data if func(m)])
+        return ", ".join(types)
+    type = property(gettype, None, None, "file type (file, directory, link, etc.)")
+
+    def getmodestr(self):
+        m = self.mode
+        data = [
+            (stat.S_IRUSR, "-r"),
+            (stat.S_IWUSR, "-w"),
+            (stat.S_IXUSR, "-x"),
+            (stat.S_IRGRP, "-r"),
+            (stat.S_IWGRP, "-w"),
+            (stat.S_IXGRP, "-x"),
+            (stat.S_IROTH, "-r"),
+            (stat.S_IWOTH, "-w"),
+            (stat.S_IXOTH, "-x"),
+        ]
+        return "".join([text[bool(m&bit)] for (bit, text) in data])
+
+    modestr = property(getmodestr, None, None, "Access mode as string")
+
+    def getblocks(self):
+        return self.stat().st_blocks
+    blocks = property(getblocks, None, None, "File size in blocks")
+
+    def getblksize(self):
+        return self.stat().st_blksize
+    blksize = property(getblksize, None, None, "Filesystem block size")
+
+    def getdev(self):
+        return self.stat().st_dev
+    dev = property(getdev)
+
+    def getnlink(self):
+        return self.stat().st_nlink
+    nlink = property(getnlink, None, None, "Number of links")
+
+    def getuid(self):
+        return self.stat().st_uid
+    uid = property(getuid, None, None, "User id of file owner")
+
+    def getgid(self):
+        return self.stat().st_gid
+    gid = property(getgid, None, None, "Group id of file owner")
+
+    def getowner(self):
+        stat = self.stat()
+        try:
+            return pwd.getpwuid(stat.st_uid).pw_name
+        except KeyError:
+            return stat.st_uid
+    owner = property(getowner, None, None, "Owner name (or id)")
+
+    def getgroup(self):
+        stat = self.stat()
+        try:
+            return grp.getgrgid(stat.st_gid).gr_name
+        except KeyError:
+            return stat.st_gid
+    group = property(getgroup, None, None, "Group name (or id)")
+
+    def getadate(self):
+        return datetime.datetime.utcfromtimestamp(self.atime)
+    adate = property(getadate, None, None, "Access date")
+
+    def getcdate(self):
+        return datetime.datetime.utcfromtimestamp(self.ctime)
+    cdate = property(getcdate, None, None, "Creation date")
+
+    def getmdate(self):
+        return datetime.datetime.utcfromtimestamp(self.mtime)
+    mdate = property(getmdate, None, None, "Modification date")
+
+    def mimetype(self):
+        """
+        Return MIME type guessed from the extension.
+        """
+        return mimetypes.guess_type(self.basename())[0]
+
+    def encoding(self):
+        """
+        Return guessed compression (like "compress" or "gzip").
+        """
+        return mimetypes.guess_type(self.basename())[1]
+
+    def __repr__(self):
+        return "ifile(%s)" % path._base.__repr__(self)
+
+    if sys.platform == "win32":
+        defaultattrs = (None, "type", "size", "modestr", "mdate")
+    else:
+        defaultattrs = (None, "type", "size", "modestr", "owner", "group", "mdate")
+
+    def __xattrs__(self, mode="default"):
+        if mode == "detail":
+            return (
+                "name",
+                "basename()",
+                "abspath()",
+                "realpath()",
+                "type",
+                "mode",
+                "modestr",
+                "stat()",
+                "lstat()",
+                "uid",
+                "gid",
+                "owner",
+                "group",
+                "dev",
+                "nlink",
+                "ctime",
+                "mtime",
+                "atime",
+                "cdate",
+                "mdate",
+                "adate",
+                "size",
+                "blocks",
+                "blksize",
+                "isdir()",
+                "islink()",
+                "mimetype()",
+                "encoding()",
+                "-listdir()",
+                "-dirs()",
+                "-files()",
+                "-walk()",
+                "-walkdirs()",
+                "-walkfiles()",
+            )
+        else:
+            return self.defaultattrs
+
+
+def xiter_ifile(self):
+    if self.isdir():
+        yield (self / os.pardir).abspath()
+        for child in sorted(self.listdir()):
+            yield child
+    else:
+        f = self.open("rb")
+        for line in f:
+            yield line
+        f.close()
+xiter.when_type(ifile)(xiter_ifile)
+
+
+# We need to implement ``xrepr`` for ``ifile`` as a generic function, because
+# otherwise ``xrepr_str`` would kick in.
+def xrepr_ifile(self, mode="default"):
+    try:
+        if self.isdir():
+            name = "idir"
+            style = astyle.style_dir
+        else:
+            name = "ifile"
+            style = astyle.style_file
+    except IOError:
+        name = "ifile"
+        style = astyle.style_default
+    if mode in ("cell", "header", "footer"):
+        abspath = repr(path._base(self.normpath()))
+        if abspath.startswith("u"):
+            abspath = abspath[2:-1]
+        else:
+            abspath = abspath[1:-1]
+        if mode == "cell":
+            yield (style, abspath)
+        else:
+            yield (style, "%s(%s)" % (name, abspath))
+    else:
+        yield (style, repr(self))
+xrepr.when_type(ifile)(xrepr_ifile)
+
+
+class ils(Table):
+    """
+    List the current (or a specified) directory.
+
+    Examples::
+
+        >>> ils
+        >>> ils("/usr/local/lib/python2.4")
+        >>> ils("~")
+    """
+    def __init__(self, base=os.curdir, dirs=True, files=True):
+        self.base = os.path.expanduser(base)
+        self.dirs = dirs
+        self.files = files
+
+    def __iter__(self):
+        base = ifile(self.base)
+        yield (base / os.pardir).abspath()
+        for child in sorted(base.listdir()):
+            if self.dirs:
+                if self.files:
+                    yield child
+                else:
+                    if child.isdir():
+                        yield child
+            elif self.files:
+                if not child.isdir():
+                    yield child
+
+    def __xrepr__(self, mode="default"):
+       return xrepr(ifile(self.base), mode)
+
+    def __repr__(self):
+        return "%s.%s(%r)" % \
+            (self.__class__.__module__, self.__class__.__name__, self.base)
+
+
+class iglob(Table):
+    """
+    List all files and directories matching a specified pattern.
+    (See ``glob.glob()`` for more info.).
+
+    Examples::
+
+        >>> iglob("*.py")
+    """
+    def __init__(self, glob):
+        self.glob = glob
+
+    def __iter__(self):
+        for name in glob.glob(self.glob):
+            yield ifile(name)
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer" or mode == "cell":
+            yield (astyle.style_default,
+                   "%s(%r)" % (self.__class__.__name__, self.glob))
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __repr__(self):
+        return "%s.%s(%r)" % \
+            (self.__class__.__module__, self.__class__.__name__, self.glob)
+
+
+class iwalk(Table):
+    """
+    List all files and directories in a directory and it's subdirectory::
+
+        >>> iwalk
+        >>> iwalk("/usr/local/lib/python2.4")
+        >>> iwalk("~")
+    """
+    def __init__(self, base=os.curdir, dirs=True, files=True):
+        self.base = os.path.expanduser(base)
+        self.dirs = dirs
+        self.files = files
+
+    def __iter__(self):
+        for (dirpath, dirnames, filenames) in os.walk(self.base):
+            if self.dirs:
+                for name in sorted(dirnames):
+                    yield ifile(os.path.join(dirpath, name))
+            if self.files:
+                for name in sorted(filenames):
+                    yield ifile(os.path.join(dirpath, name))
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer" or mode == "cell":
+            yield (astyle.style_default,
+                   "%s(%r)" % (self.__class__.__name__, self.base))
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __repr__(self):
+        return "%s.%s(%r)" % \
+            (self.__class__.__module__, self.__class__.__name__, self.base)
+
+
+class ipwdentry(object):
+    """
+    ``ipwdentry`` objects encapsulate entries in the Unix user account and
+    password database.
+    """
+    def __init__(self, id):
+        self._id = id
+        self._entry = None
+
+    def __eq__(self, other):
+        return self.__class__ is other.__class__ and self._id == other._id
+
+    def __ne__(self, other):
+        return self.__class__ is not other.__class__ or self._id != other._id
+
+    def _getentry(self):
+        if self._entry is None:
+            if isinstance(self._id, basestring):
+                self._entry = pwd.getpwnam(self._id)
+            else:
+                self._entry = pwd.getpwuid(self._id)
+        return self._entry
+
+    def getname(self):
+        if isinstance(self._id, basestring):
+            return self._id
+        else:
+            return self._getentry().pw_name
+    name = property(getname, None, None, "User name")
+
+    def getpasswd(self):
+        return self._getentry().pw_passwd
+    passwd = property(getpasswd, None, None, "Password")
+
+    def getuid(self):
+        if isinstance(self._id, basestring):
+            return self._getentry().pw_uid
+        else:
+            return self._id
+    uid = property(getuid, None, None, "User id")
+
+    def getgid(self):
+        return self._getentry().pw_gid
+    gid = property(getgid, None, None, "Primary group id")
+
+    def getgroup(self):
+        return igrpentry(self.gid)
+    group = property(getgroup, None, None, "Group")
+
+    def getgecos(self):
+        return self._getentry().pw_gecos
+    gecos = property(getgecos, None, None, "Information (e.g. full user name)")
+
+    def getdir(self):
+        return self._getentry().pw_dir
+    dir = property(getdir, None, None, "$HOME directory")
+
+    def getshell(self):
+        return self._getentry().pw_shell
+    shell = property(getshell, None, None, "Login shell")
+
+    def __xattrs__(self, mode="default"):
+       return ("name", "passwd", "uid", "gid", "gecos", "dir", "shell")
+
+    def __repr__(self):
+        return "%s.%s(%r)" % \
+            (self.__class__.__module__, self.__class__.__name__, self._id)
+
+
+class ipwd(Table):
+    """
+    List all entries in the Unix user account and password database.
+
+    Example::
+
+        >>> ipwd | isort("uid")
+    """
+    def __iter__(self):
+        for entry in pwd.getpwall():
+            yield ipwdentry(entry.pw_name)
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer" or mode == "cell":
+            yield (astyle.style_default, "%s()" % self.__class__.__name__)
+        else:
+            yield (astyle.style_default, repr(self))
+
+
+class igrpentry(object):
+    """
+    ``igrpentry`` objects encapsulate entries in the Unix group database.
+    """
+    def __init__(self, id):
+        self._id = id
+        self._entry = None
+
+    def __eq__(self, other):
+        return self.__class__ is other.__class__ and self._id == other._id
+
+    def __ne__(self, other):
+        return self.__class__ is not other.__class__ or self._id != other._id
+
+    def _getentry(self):
+        if self._entry is None:
+            if isinstance(self._id, basestring):
+                self._entry = grp.getgrnam(self._id)
+            else:
+                self._entry = grp.getgrgid(self._id)
+        return self._entry
+
+    def getname(self):
+        if isinstance(self._id, basestring):
+            return self._id
+        else:
+            return self._getentry().gr_name
+    name = property(getname, None, None, "Group name")
+
+    def getpasswd(self):
+        return self._getentry().gr_passwd
+    passwd = property(getpasswd, None, None, "Password")
+
+    def getgid(self):
+        if isinstance(self._id, basestring):
+            return self._getentry().gr_gid
+        else:
+            return self._id
+    gid = property(getgid, None, None, "Group id")
+
+    def getmem(self):
+        return self._getentry().gr_mem
+    mem = property(getmem, None, None, "Members")
+
+    def __xattrs__(self, mode="default"):
+        return ("name", "passwd", "gid", "mem")
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer" or mode == "cell":
+            yield (astyle.style_default, "group ")
+            try:
+                yield (astyle.style_default, self.name)
+            except KeyError:
+                if isinstance(self._id, basestring):
+                    yield (astyle.style_default, self.name_id)
+                else:
+                    yield (astyle.style_type_number, str(self._id))
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __iter__(self):
+        for member in self.mem:
+            yield ipwdentry(member)
+
+    def __repr__(self):
+        return "%s.%s(%r)" % \
+            (self.__class__.__module__, self.__class__.__name__, self._id)
+
+
+class igrp(Table):
+    """
+    This ``Table`` lists all entries in the Unix group database.
+    """
+    def __iter__(self):
+        for entry in grp.getgrall():
+            yield igrpentry(entry.gr_name)
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer":
+            yield (astyle.style_default, "%s()" % self.__class__.__name__)
+        else:
+            yield (astyle.style_default, repr(self))
+
+
+class Fields(object):
+    def __init__(self, fieldnames, **fields):
+        self.__fieldnames = [upgradexattr(fieldname) for fieldname in fieldnames]
+        for (key, value) in fields.iteritems():
+            setattr(self, key, value)
+
+    def __xattrs__(self, mode="default"):
+        return self.__fieldnames
+
+    def __xrepr__(self, mode="default"):
+        yield (-1, False)
+        if mode == "header" or mode == "cell":
+            yield (astyle.style_default, self.__class__.__name__)
+            yield (astyle.style_default, "(")
+            for (i, f) in enumerate(self.__fieldnames):
+                if i:
+                    yield (astyle.style_default, ", ")
+                yield (astyle.style_default, f.name())
+                yield (astyle.style_default, "=")
+                for part in xrepr(getattr(self, f), "default"):
+                    yield part
+            yield (astyle.style_default, ")")
+        elif mode == "footer":
+            yield (astyle.style_default, self.__class__.__name__)
+            yield (astyle.style_default, "(")
+            for (i, f) in enumerate(self.__fieldnames):
+                if i:
+                    yield (astyle.style_default, ", ")
+                yield (astyle.style_default, f.name())
+            yield (astyle.style_default, ")")
+        else:
+            yield (astyle.style_default, repr(self))
+
+
+class FieldTable(Table, list):
+    def __init__(self, *fields):
+        Table.__init__(self)
+        list.__init__(self)
+        self.fields = fields
+
+    def add(self, **fields):
+        self.append(Fields(self.fields, **fields))
+
+    def __xrepr__(self, mode="default"):
+        yield (-1, False)
+        if mode == "header" or mode == "footer":
+            yield (astyle.style_default, self.__class__.__name__)
+            yield (astyle.style_default, "(")
+            for (i, f) in enumerate(self.__fieldnames):
+                if i:
+                    yield (astyle.style_default, ", ")
+                yield (astyle.style_default, f)
+            yield (astyle.style_default, ")")
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __repr__(self):
+        return "<%s.%s object with fields=%r at 0x%x>" % \
+            (self.__class__.__module__, self.__class__.__name__,
+             ", ".join(map(repr, self.fields)), id(self))
+
+
+class List(list):
+    def __xattrs__(self, mode="default"):
+        return xrange(len(self))
+
+    def __xrepr__(self, mode="default"):
+        yield (-1, False)
+        if mode == "header" or mode == "cell" or mode == "footer" or mode == "default":
+            yield (astyle.style_default, self.__class__.__name__)
+            yield (astyle.style_default, "(")
+            for (i, item) in enumerate(self):
+                if i:
+                    yield (astyle.style_default, ", ")
+                for part in xrepr(item, "default"):
+                    yield part
+            yield (astyle.style_default, ")")
+        else:
+            yield (astyle.style_default, repr(self))
+
+
+class ienv(Table):
+    """
+    List environment variables.
+
+    Example::
+
+        >>> ienv
+    """
+
+    def __iter__(self):
+        fields = ("key", "value")
+        for (key, value) in os.environ.iteritems():
+            yield Fields(fields, key=key, value=value)
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "cell":
+            yield (astyle.style_default, "%s()" % self.__class__.__name__)
+        else:
+            yield (astyle.style_default, repr(self))
+
+
+class ihist(Table):
+    """
+    IPython input history
+
+    Example::
+
+        >>> ihist
+        >>> ihist(True) (raw mode)
+    """
+    def __init__(self, raw=True):
+        self.raw = raw
+
+    def __iter__(self):
+        api = ipapi.get()
+        if self.raw:
+            for line in api.IP.input_hist_raw:
+                yield line.rstrip("\n")
+        else:
+            for line in api.IP.input_hist:
+                yield line.rstrip("\n")
+
+
+class Alias(object):
+    """
+    Entry in the alias table
+    """
+    def __init__(self, name, args, command):
+        self.name = name
+        self.args = args
+        self.command = command
+
+    def __xattrs__(self, mode="default"):
+        return ("name", "args", "command")
+
+
+class ialias(Table):
+    """
+    IPython alias list
+
+    Example::
+
+        >>> ialias
+    """
+    def __iter__(self):
+        api = ipapi.get()
+
+        for (name, (args, command)) in api.IP.alias_table.iteritems():
+            yield Alias(name, args, command)
+
+
+class icsv(Pipe):
+    """
+    This ``Pipe`` turns the input (with must be a pipe outputting lines
+    or an ``ifile``) into lines of CVS columns.
+    """
+    def __init__(self, **csvargs):
+        """
+        Create an ``icsv`` object. ``cvsargs`` will be passed through as
+        keyword arguments to ``cvs.reader()``.
+        """
+        self.csvargs = csvargs
+
+    def __iter__(self):
+        input = self.input
+        if isinstance(input, ifile):
+            input = input.open("rb")
+        reader = csv.reader(input, **self.csvargs)
+        for line in reader:
+            yield List(line)
+
+    def __xrepr__(self, mode="default"):
+        yield (-1, False)
+        if mode == "header" or mode == "footer":
+            input = getattr(self, "input", None)
+            if input is not None:
+                for part in xrepr(input, mode):
+                    yield part
+                yield (astyle.style_default, " | ")
+            yield (astyle.style_default, "%s(" % self.__class__.__name__)
+            for (i, (name, value)) in enumerate(self.csvargs.iteritems()):
+                if i:
+                    yield (astyle.style_default, ", ")
+                yield (astyle.style_default, name)
+                yield (astyle.style_default, "=")
+                for part in xrepr(value, "default"):
+                    yield part
+            yield (astyle.style_default, ")")
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __repr__(self):
+        args = ", ".join(["%s=%r" % item for item in self.csvargs.iteritems()])
+        return "<%s.%s %s at 0x%x>" % \
+        (self.__class__.__module__, self.__class__.__name__, args, id(self))
+
+
+class ix(Table):
+    """
+    Execute a system command and list its output as lines
+    (similar to ``os.popen()``).
+
+    Examples::
+
+        >>> ix("ps x")
+        >>> ix("find .") | ifile
+    """
+    def __init__(self, cmd):
+        self.cmd = cmd
+        self._pipeout = None
+
+    def __iter__(self):
+        (_pipein, self._pipeout) = os.popen4(self.cmd)
+        _pipein.close()
+        for l in self._pipeout:
+            yield l.rstrip("\r\n")
+        self._pipeout.close()
+        self._pipeout = None
+
+    def __del__(self):
+        if self._pipeout is not None and not self._pipeout.closed:
+            self._pipeout.close()
+        self._pipeout = None
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer":
+            yield (astyle.style_default,
+                   "%s(%r)" % (self.__class__.__name__, self.cmd))
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __repr__(self):
+        return "%s.%s(%r)" % \
+            (self.__class__.__module__, self.__class__.__name__, self.cmd)
+
+
+class ifilter(Pipe):
+    """
+    Filter an input pipe. Only objects where an expression evaluates to true
+    (and doesn't raise an exception) are listed.
+
+    Examples::
+
+        >>> ils | ifilter("_.isfile() and size>1000")
+        >>> igrp | ifilter("len(mem)")
+        >>> sys.modules | ifilter(lambda _:_.value is not None)
+    """
+
+    def __init__(self, expr, globals=None, errors="raiseifallfail"):
+        """
+        Create an ``ifilter`` object. ``expr`` can be a callable or a string
+        containing an expression. ``globals`` will be used as the global
+        namespace for calling string expressions (defaulting to IPython's
+        user namespace). ``errors`` specifies how exception during evaluation
+        of ``expr`` are handled:
+
+        ``"drop"``
+            drop all items that have errors;
+
+        ``"keep"``
+            keep all items that have errors;
+
+        ``"keeperror"``
+            keep the exception of all items that have errors;
+
+        ``"raise"``
+            raise the exception;
+
+        ``"raiseifallfail"``
+            raise the first exception if all items have errors; otherwise drop
+            those with errors (this is the default).
+        """
+        self.expr = expr
+        self.globals = globals
+        self.errors = errors
+
+    def __iter__(self):
+        if callable(self.expr):
+            test = self.expr
+        else:
+            g = getglobals(self.globals)
+            expr = compile(self.expr, "ipipe-expression", "eval")
+            def test(item):
+                return eval(expr, g, AttrNamespace(item))
+
+        ok = 0
+        exc_info = None
+        for item in xiter(self.input):
+            try:
+                if test(item):
+                    yield item
+                ok += 1
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, exc:
+                if self.errors == "drop":
+                    pass # Ignore errors
+                elif self.errors == "keep":
+                    yield item
+                elif self.errors == "keeperror":
+                    yield exc
+                elif self.errors == "raise":
+                    raise
+                elif self.errors == "raiseifallfail":
+                    if exc_info is None:
+                        exc_info = sys.exc_info()
+        if not ok and exc_info is not None:
+            raise exc_info[0], exc_info[1], exc_info[2]
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer":
+            input = getattr(self, "input", None)
+            if input is not None:
+                for part in xrepr(input, mode):
+                    yield part
+                yield (astyle.style_default, " | ")
+            yield (astyle.style_default, "%s(" % self.__class__.__name__)
+            for part in xrepr(self.expr, "default"):
+                yield part
+            yield (astyle.style_default, ")")
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __repr__(self):
+        return "<%s.%s expr=%r at 0x%x>" % \
+            (self.__class__.__module__, self.__class__.__name__,
+             self.expr, id(self))
+
+
+class ieval(Pipe):
+    """
+    Evaluate an expression for each object in the input pipe.
+
+    Examples::
+
+        >>> ils | ieval("_.abspath()")
+        >>> sys.path | ieval(ifile)
+    """
+
+    def __init__(self, expr, globals=None, errors="raiseifallfail"):
+        """
+        Create an ``ieval`` object. ``expr`` can be a callable or a string
+        containing an expression. For the meaning of ``globals`` and
+        ``errors`` see ``ifilter``.
+        """
+        self.expr = expr
+        self.globals = globals
+        self.errors = errors
+
+    def __iter__(self):
+        if callable(self.expr):
+            do = self.expr
+        else:
+            g = getglobals(self.globals)
+            expr = compile(self.expr, "ipipe-expression", "eval")
+            def do(item):
+                return eval(expr, g, AttrNamespace(item))
+
+        ok = 0
+        exc_info = None
+        for item in xiter(self.input):
+            try:
+                yield do(item)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, exc:
+                if self.errors == "drop":
+                    pass # Ignore errors
+                elif self.errors == "keep":
+                    yield item
+                elif self.errors == "keeperror":
+                    yield exc
+                elif self.errors == "raise":
+                    raise
+                elif self.errors == "raiseifallfail":
+                    if exc_info is None:
+                        exc_info = sys.exc_info()
+        if not ok and exc_info is not None:
+            raise exc_info[0], exc_info[1], exc_info[2]
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer":
+            input = getattr(self, "input", None)
+            if input is not None:
+                for part in xrepr(input, mode):
+                    yield part
+                yield (astyle.style_default, " | ")
+            yield (astyle.style_default, "%s(" % self.__class__.__name__)
+            for part in xrepr(self.expr, "default"):
+                yield part
+            yield (astyle.style_default, ")")
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __repr__(self):
+        return "<%s.%s expr=%r at 0x%x>" % \
+            (self.__class__.__module__, self.__class__.__name__,
+             self.expr, id(self))
+
+
+class ienum(Pipe):
+    """
+    Enumerate the input pipe (i.e. wrap each input object in an object
+    with ``index`` and ``object`` attributes).
+
+    Examples::
+
+        >>> xrange(20) | ieval("_,_*_") | ienum | ifilter("index % 2 == 0") | ieval("object")
+    """
+    def __iter__(self):
+        fields = ("index", "object")
+        for (index, object) in enumerate(xiter(self.input)):
+            yield Fields(fields, index=index, object=object)
+
+
+class isort(Pipe):
+    """
+    Sorts the input pipe.
+
+    Examples::
+
+        >>> ils | isort("size")
+        >>> ils | isort("_.isdir(), _.lower()", reverse=True)
+    """
+
+    def __init__(self, key=None, globals=None, reverse=False):
+        """
+        Create an ``isort`` object. ``key`` can be a callable or a string
+        containing an expression (or ``None`` in which case the items
+        themselves will be sorted). If ``reverse`` is true the sort order
+        will be reversed. For the meaning of ``globals`` see ``ifilter``.
+        """
+        self.key = key
+        self.globals = globals
+        self.reverse = reverse
+
+    def __iter__(self):
+        if self.key is None:
+            items = sorted(xiter(self.input), reverse=self.reverse)
+        elif callable(self.key):
+            items = sorted(xiter(self.input), key=self.key, reverse=self.reverse)
+        else:
+            g = getglobals(self.globals)
+            key = compile(self.key, "ipipe-expression", "eval")
+            def realkey(item):
+                return eval(key, g, AttrNamespace(item))
+            items = sorted(xiter(self.input), key=realkey, reverse=self.reverse)
+        for item in items:
+            yield item
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer":
+            input = getattr(self, "input", None)
+            if input is not None:
+                for part in xrepr(input, mode):
+                    yield part
+                yield (astyle.style_default, " | ")
+            yield (astyle.style_default, "%s(" % self.__class__.__name__)
+            for part in xrepr(self.key, "default"):
+                yield part
+            if self.reverse:
+                yield (astyle.style_default, ", ")
+                for part in xrepr(True, "default"):
+                    yield part
+            yield (astyle.style_default, ")")
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __repr__(self):
+        return "<%s.%s key=%r reverse=%r at 0x%x>" % \
+            (self.__class__.__module__, self.__class__.__name__,
+             self.key, self.reverse, id(self))
+
+
+tab = 3 # for expandtabs()
+
+def _format(field):
+    if isinstance(field, str):
+        text = repr(field.expandtabs(tab))[1:-1]
+    elif isinstance(field, unicode):
+        text = repr(field.expandtabs(tab))[2:-1]
+    elif isinstance(field, datetime.datetime):
+        # Don't use strftime() here, as this requires year >= 1900
+        text = "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
+            (field.year, field.month, field.day,
+             field.hour, field.minute, field.second, field.microsecond)
+    elif isinstance(field, datetime.date):
+        text = "%04d-%02d-%02d" % (field.year, field.month, field.day)
+    else:
+        text = repr(field)
+    return text
+
+
+class Display(object):
+    class __metaclass__(type):
+        def __ror__(self, input):
+            return input | self()
+
+    def __init__(self, input=None):
+        self.input = input
+
+    def __ror__(self, input):
+        self.input = input
+        return self
+
+    def display(self):
+        pass
+
+
+class iless(Display):
+    cmd = "less --quit-if-one-screen --LONG-PROMPT --LINE-NUMBERS --chop-long-lines --shift=8 --RAW-CONTROL-CHARS"
+
+    def display(self):
+        try:
+            pager = os.popen(self.cmd, "w")
+            try:
+                for item in xiter(self.input):
+                    first = False
+                    for attr in xattrs(item, "default"):
+                        if first:
+                            first = False
+                        else:
+                            pager.write(" ")
+                        attr = upgradexattr(attr)
+                        if not isinstance(attr, SelfDescriptor):
+                            pager.write(attr.name())
+                            pager.write("=")
+                        pager.write(str(attr.value(item)))
+                    pager.write("\n")
+            finally:
+                pager.close()
+        except Exception, exc:
+            print "%s: %s" % (exc.__class__.__name__, str(exc))
+
+
+class _RedirectIO(object):
+    def __init__(self,*args,**kwargs):
+        """
+        Map the system output streams to self.
+        """
+        self.stream = StringIO.StringIO()
+        self.stdout = sys.stdout
+        sys.stdout = self
+        self.stderr = sys.stderr
+        sys.stderr = self
+
+    def write(self, text):
+        """
+        Write both to screen and to self.
+        """
+        self.stream.write(text)
+        self.stdout.write(text)
+        if "\n" in text:
+            self.stdout.flush()
+
+    def writelines(self, lines):
+        """
+        Write lines both to screen and to self.
+        """
+        self.stream.writelines(lines)
+        self.stdout.writelines(lines)
+        self.stdout.flush()
+
+    def restore(self):
+        """
+        Restore the default system streams.
+        """
+        self.stdout.flush()
+        self.stderr.flush()
+        sys.stdout = self.stdout
+        sys.stderr = self.stderr
+
+
+class icap(Table):
+    """
+    Execute a python string and capture any output to stderr/stdout.
+
+    Examples::
+
+        >>> import time
+        >>> icap("for i in range(10): print i, time.sleep(0.1)")
+
+    """
+    def __init__(self, expr, globals=None):
+        self.expr = expr
+        self.globals = globals
+        log = _RedirectIO()
+        try:
+            exec(expr, getglobals(globals))
+        finally:
+            log.restore()
+        self.stream = log.stream
+
+    def __iter__(self):
+        self.stream.seek(0)
+        for line in self.stream:
+            yield line.rstrip("\r\n")
+
+    def __xrepr__(self, mode="default"):
+        if mode == "header" or mode == "footer":
+            yield (astyle.style_default,
+                   "%s(%r)" % (self.__class__.__name__, self.expr))
+        else:
+            yield (astyle.style_default, repr(self))
+
+    def __repr__(self):
+        return "%s.%s(%r)" % \
+            (self.__class__.__module__, self.__class__.__name__, self.expr)
+
+
+def xformat(value, mode, maxlength):
+    align = None
+    full = True
+    width = 0
+    text = astyle.Text()
+    for (style, part) in xrepr(value, mode):
+        # only consider the first result
+        if align is None:
+            if isinstance(style, int):
+                # (style, text) really is (alignment, stop)
+                align = style
+                full = part
+                continue
+            else:
+                align = -1
+                full = True
+        if not isinstance(style, int):
+            text.append((style, part))
+            width += len(part)
+            if width >= maxlength and not full:
+                text.append((astyle.style_ellisis, "..."))
+                width += 3
+                break
+    if align is None: # default to left alignment
+        align = -1
+    return (align, width, text)
+
+
+
+import astyle
+
+class idump(Display):
+    # The approximate maximum length of a column entry
+    maxattrlength = 200
+
+    # Style for column names
+    style_header = astyle.Style.fromstr("white:black:bold")
+
+    def __init__(self, input=None, *attrs):
+        Display.__init__(self, input)
+        self.attrs = [upgradexattr(attr) for attr in attrs]
+        self.headerpadchar = " "
+        self.headersepchar = "|"
+        self.datapadchar = " "
+        self.datasepchar = "|"
+
+    def display(self):
+        stream = genutils.Term.cout
+        allattrs = []
+        attrset = set()
+        colwidths = {}
+        rows = []
+        for item in xiter(self.input):
+            row = {}
+            attrs = self.attrs
+            if not attrs:
+                attrs = xattrs(item, "default")
+            for attr in attrs:
+                if attr not in attrset:
+                    allattrs.append(attr)
+                    attrset.add(attr)
+                    colwidths[attr] = len(attr.name())
+                try:
+                    value = attr.value(item)
+                except (KeyboardInterrupt, SystemExit):
+                    raise
+                except Exception, exc:
+                    value = exc
+                (align, width, text) = xformat(value, "cell", self.maxattrlength)
+                colwidths[attr] = max(colwidths[attr], width)
+                # remember alignment, length and colored parts
+                row[attr] = (align, width, text)
+            rows.append(row)
+
+        stream.write("\n")
+        for (i, attr) in enumerate(allattrs):
+            attrname = attr.name()
+            self.style_header(attrname).write(stream)
+            spc = colwidths[attr] - len(attrname)
+            if i < len(colwidths)-1:
+                stream.write(self.headerpadchar*spc)
+                stream.write(self.headersepchar)
+        stream.write("\n")
+
+        for row in rows:
+            for (i, attr) in enumerate(allattrs):
+                (align, width, text) = row[attr]
+                spc = colwidths[attr] - width
+                if align == -1:
+                    text.write(stream)
+                    if i < len(colwidths)-1:
+                        stream.write(self.datapadchar*spc)
+                elif align == 0:
+                    spc = colwidths[attr] - width
+                    spc1 = spc//2
+                    spc2 = spc-spc1
+                    stream.write(self.datapadchar*spc1)
+                    text.write(stream)
+                    if i < len(colwidths)-1:
+                        stream.write(self.datapadchar*spc2)
+                else:
+                    stream.write(self.datapadchar*spc)
+                    text.write(stream)
+                if i < len(colwidths)-1:
+                    stream.write(self.datasepchar)
+            stream.write("\n")
+
+
+class AttributeDetail(Table):
+    """
+    ``AttributeDetail`` objects are use for displaying a detailed list of object
+    attributes.
+    """
+    def __init__(self, object, descriptor):
+        self.object = object
+        self.descriptor = descriptor
+
+    def __iter__(self):
+        return self.descriptor.iter(self.object)
+
+    def name(self):
+        return self.descriptor.name()
+
+    def attrtype(self):
+        return self.descriptor.attrtype(self.object)
+
+    def valuetype(self):
+        return self.descriptor.valuetype(self.object)
+
+    def doc(self):
+        return self.descriptor.doc(self.object)
+
+    def shortdoc(self):
+        return self.descriptor.shortdoc(self.object)
+
+    def value(self):
+        return self.descriptor.value(self.object)
+
+    def __xattrs__(self, mode="default"):
+        attrs = ("name()", "attrtype()", "valuetype()", "value()", "shortdoc()")
+        if mode == "detail":
+            attrs += ("doc()",)
+        return attrs
+
+    def __xrepr__(self, mode="default"):
+        yield (-1, True)
+        valuetype = self.valuetype()
+        if valuetype is not noitem:
+            for part in xrepr(valuetype):
+                yield part
+            yield (astyle.style_default, " ")
+        yield (astyle.style_default, self.attrtype())
+        yield (astyle.style_default, " ")
+        yield (astyle.style_default, self.name())
+        yield (astyle.style_default, " of ")
+        for part in xrepr(self.object):
+            yield part
+
+
+try:
+    from ibrowse import ibrowse
+except ImportError:
+    # No curses (probably Windows) => try igrid
+    try:
+        from igrid import igrid
+    except ImportError:
+        # no wx either => use ``idump`` as the default display.
+        defaultdisplay = idump
+    else:
+        defaultdisplay = igrid
+        __all__.append("igrid")
+else:
+    defaultdisplay = ibrowse
+    __all__.append("ibrowse")
+
+
+# If we're running under IPython, register our objects with IPython's
+# generic function ``result_display``, else install a displayhook
+# directly as sys.displayhook
+if generics is not None:
+    def display_display(obj):
+        return obj.display()
+    generics.result_display.when_type(Display)(display_display)
+
+    def display_tableobject(obj):
+        return display_display(defaultdisplay(obj))
+    generics.result_display.when_type(Table)(display_tableobject)
+
+    def display_tableclass(obj):
+        return display_tableobject(obj())
+    generics.result_display.when_type(Table.__metaclass__)(display_tableclass)
+else:
+    def installdisplayhook():
+        _originalhook = sys.displayhook
+        def displayhook(obj):
+            if isinstance(obj, type) and issubclass(obj, Table):
+                obj = obj()
+            if isinstance(obj, Table):
+                obj = defaultdisplay(obj)
+            if isinstance(obj, Display):
+                return obj.display()
+            else:
+                _originalhook(obj)
+        sys.displayhook = displayhook
+    installdisplayhook()
diff --git a/IPython/Extensions/ipy_app_completers.py b/IPython/Extensions/ipy_app_completers.py
new file mode 100644
index 0000000..4d2ca5b
--- /dev/null
+++ b/IPython/Extensions/ipy_app_completers.py
@@ -0,0 +1,17 @@
+""" Install various IPython completers
+
+IPython extension that installs the completers related to external apps.
+
+The actual implementations are in Extensions/ipy_completers.py
+
+"""
+import IPython.ipapi
+
+ip = IPython.ipapi.get()
+
+from ipy_completers import *
+
+ip.set_hook('complete_command', apt_completer, re_key = '.*apt-get')
+ip.set_hook('complete_command', svn_completer, str_key = 'svn')
+ip.set_hook('complete_command', hg_completer, str_key = 'hg')
+ip.set_hook('complete_command', bzr_completer, str_key = 'bzr')
diff --git a/IPython/Extensions/ipy_completers.py b/IPython/Extensions/ipy_completers.py
new file mode 100644
index 0000000..f1b3f78
--- /dev/null
+++ b/IPython/Extensions/ipy_completers.py
@@ -0,0 +1,359 @@
+#!/usr/bin/env python
+
+""" Implementations for various useful completers
+
+See Extensions/ipy_stock_completers.py on examples of how to enable a completer,
+but the basic idea is to do:
+
+ip.set_hook('complete_command', svn_completer, str_key = 'svn')
+
+"""
+import IPython.ipapi
+import glob,os,shlex,sys
+import inspect
+from time import time
+ip = IPython.ipapi.get()
+
+try:
+    set
+except:
+    from sets import Set as set
+
+TIMEOUT_STORAGE = 3 #Time in seconds after which the rootmodules will be stored
+TIMEOUT_GIVEUP = 20 #Time in seconds after which we give up
+
+def quick_completer(cmd, completions):
+    """ Easily create a trivial completer for a command.
+
+    Takes either a list of completions, or all completions in string
+    (that will be split on whitespace)
+    
+    Example::
+    
+        [d:\ipython]|1> import ipy_completers                                       
+        [d:\ipython]|2> ipy_completers.quick_completer('foo', ['bar','baz'])        
+        [d:\ipython]|3> foo b<TAB>
+        bar baz                                                                     
+        [d:\ipython]|3> foo ba
+    """
+    if isinstance(completions, basestring):
+        
+        completions = completions.split()
+    def do_complete(self,event):
+        return completions
+    
+    ip.set_hook('complete_command',do_complete, str_key = cmd)
+    
+def getRootModules():
+    """
+    Returns a list containing the names of all the modules available in the
+    folders of the pythonpath.
+    """
+    modules = []
+    if ip.db.has_key('rootmodules'):
+        return ip.db['rootmodules']
+    t = time()
+    store = False
+    for path in sys.path:
+        modules += moduleList(path)        
+        if time() - t >= TIMEOUT_STORAGE and not store:
+            store = True
+            print "\nCaching the list of root modules, please wait!" 
+            print "(This will only be done once - type '%rehashx' to " + \
+            "reset cache!)"
+            print
+        if time() - t > TIMEOUT_GIVEUP:
+            print "This is taking too long, we give up."
+            print
+            ip.db['rootmodules'] = []
+            return []
+    
+    modules += sys.builtin_module_names
+      
+    modules = list(set(modules))
+    if '__init__' in modules:
+        modules.remove('__init__')
+    modules = list(set(modules))
+    if store:
+        ip.db['rootmodules'] = modules
+    return modules
+
+def moduleList(path):
+    """
+    Return the list containing the names of the modules available in the given
+    folder.
+    """
+
+    if os.path.isdir(path):
+        folder_list = os.listdir(path)
+    else:
+        folder_list = []
+    #folder_list = glob.glob(os.path.join(path,'*'))
+    folder_list = [p for p in folder_list  \
+       if os.path.exists(os.path.join(path, p,'__init__.py'))\
+           or p[-3:] in ('.py','.so')\
+           or p[-4:] in ('.pyc','.pyo')]
+
+    folder_list = [os.path.basename(p).split('.')[0] for p in folder_list]
+    return folder_list
+
+def moduleCompletion(line):
+    """
+    Returns a list containing the completion possibilities for an import line.
+    The line looks like this :
+    'import xml.d'
+    'from xml.dom import'
+    """
+    def tryImport(mod, only_modules=False):
+        def isImportable(module, attr):
+            if only_modules:
+                return inspect.ismodule(getattr(module, attr))
+            else:
+                return not(attr[:2] == '__' and attr[-2:] == '__')
+        try:
+            m = __import__(mod)
+        except:
+            return []
+        mods = mod.split('.')
+        for module in mods[1:]:
+            m = getattr(m,module)
+        if (not hasattr(m, '__file__')) or (not only_modules) or\
+           (hasattr(m, '__file__') and '__init__' in m.__file__):
+            completion_list = [attr for attr in dir(m) if isImportable(m, attr)]
+        completion_list.extend(getattr(m,'__all__',[]))
+        if hasattr(m, '__file__') and '__init__' in m.__file__:
+            completion_list.extend(moduleList(os.path.dirname(m.__file__)))
+        completion_list = list(set(completion_list))
+        if '__init__' in completion_list:
+            completion_list.remove('__init__')
+        return completion_list
+
+    words = line.split(' ')
+    if len(words) == 3 and words[0] == 'from':
+        return ['import ']
+    if len(words) < 3 and (words[0] in ['import','from']) :
+        if len(words) == 1:
+            return getRootModules()
+        mod = words[1].split('.')
+        if len(mod) < 2:
+            return getRootModules()
+        completion_list = tryImport('.'.join(mod[:-1]), True)
+        completion_list = ['.'.join(mod[:-1] + [el]) for el in completion_list]
+        return completion_list
+    if len(words) >= 3 and words[0] == 'from':
+        mod = words[1]
+        return tryImport(mod)
+
+def vcs_completer(commands, event):
+    """ utility to make writing typical version control app completers easier
+
+    VCS command line apps typically have the format:
+
+    [sudo ]PROGNAME [help] [command] file file...
+
+    """
+
+
+    cmd_param = event.line.split()
+    if event.line.endswith(' '):
+        cmd_param.append('')
+
+    if cmd_param[0] == 'sudo':
+        cmd_param = cmd_param[1:]
+
+    if len(cmd_param) == 2 or 'help' in cmd_param:
+        return commands.split()
+
+    return ip.IP.Completer.file_matches(event.symbol)
+
+
+pkg_cache = None
+
+def module_completer(self,event):
+    """ Give completions after user has typed 'import ...' or 'from ...'"""
+
+    # This works in all versions of python.  While 2.5 has
+    # pkgutil.walk_packages(), that particular routine is fairly dangerous,
+    # since it imports *EVERYTHING* on sys.path.  That is: a) very slow b) full
+    # of possibly problematic side effects.
+    # This search the folders in the sys.path for available modules.
+
+    return moduleCompletion(event.line)
+
+
+svn_commands = """\
+add blame praise annotate ann cat checkout co cleanup commit ci copy
+cp delete del remove rm diff di export help ? h import info list ls
+lock log merge mkdir move mv rename ren propdel pdel pd propedit pedit
+pe propget pget pg proplist plist pl propset pset ps resolved revert
+status stat st switch sw unlock update
+"""
+
+def svn_completer(self,event):
+    return vcs_completer(svn_commands, event)
+
+
+hg_commands = """
+add addremove annotate archive backout branch branches bundle cat
+clone commit copy diff export grep heads help identify import incoming
+init locate log manifest merge outgoing parents paths pull push
+qapplied qclone qcommit qdelete qdiff qfold qguard qheader qimport
+qinit qnew qnext qpop qprev qpush qrefresh qrename qrestore qsave
+qselect qseries qtop qunapplied recover remove rename revert rollback
+root serve showconfig status strip tag tags tip unbundle update verify
+version
+"""
+
+def hg_completer(self,event):
+    """ Completer for mercurial commands """
+
+    return vcs_completer(hg_commands, event)
+
+
+
+bzr_commands = """
+add annotate bind branch break-lock bundle-revisions cat check
+checkout commit conflicts deleted diff export gannotate gbranch
+gcommit gdiff help ignore ignored info init init-repository inventory
+log merge missing mkdir mv nick pull push reconcile register-branch
+remerge remove renames resolve revert revno root serve sign-my-commits
+status testament unbind uncommit unknowns update upgrade version
+version-info visualise whoami
+"""
+
+def bzr_completer(self,event):
+    """ Completer for bazaar commands """
+    cmd_param = event.line.split()
+    if event.line.endswith(' '):
+        cmd_param.append('')
+
+    if len(cmd_param) > 2:
+        cmd = cmd_param[1]
+        param = cmd_param[-1]
+        output_file = (param == '--output=')
+        if cmd == 'help':
+            return bzr_commands.split()
+        elif cmd in ['bundle-revisions','conflicts',
+                     'deleted','nick','register-branch',
+                     'serve','unbind','upgrade','version',
+                     'whoami'] and not output_file:
+            return []
+        else:
+            # the rest are probably file names
+            return ip.IP.Completer.file_matches(event.symbol)
+
+    return bzr_commands.split()
+
+
+def shlex_split(x):
+    """Helper function to split lines into segments."""
+    #shlex.split raise exception if syntax error in sh syntax
+    #for example if no closing " is found. This function keeps dropping
+    #the last character of the line until shlex.split does not raise
+    #exception. Adds end of the line to the result of shlex.split
+    #example: %run "c:/python  -> ['%run','"c:/python']
+    endofline=[]
+    while x!="":
+        try:
+            comps=shlex.split(x)
+            if len(endofline)>=1:
+                comps.append("".join(endofline))
+            return comps
+        except ValueError:
+            endofline=[x[-1:]]+endofline
+            x=x[:-1]
+    return ["".join(endofline)]
+
+def runlistpy(self, event):
+    comps = shlex_split(event.line)
+    relpath = (len(comps) > 1 and comps[-1] or '').strip("'\"")
+
+    #print "\nev=",event  # dbg
+    #print "rp=",relpath  # dbg
+    #print 'comps=',comps  # dbg
+
+    lglob = glob.glob
+    isdir = os.path.isdir
+    if relpath.startswith('~'):
+        relpath = os.path.expanduser(relpath)
+    dirs = [f.replace('\\','/') + "/" for f in lglob(relpath+'*')
+            if isdir(f)]
+
+    # Find if the user has already typed the first filename, after which we
+    # should complete on all files, since after the first one other files may
+    # be arguments to the input script.
+    #filter(
+    if filter(lambda f: f.endswith('.py') or f.endswith('.ipy') or
+              f.endswith('.pyw'),comps):
+        pys =  [f.replace('\\','/') for f in lglob('*')]
+    else:
+        pys =  [f.replace('\\','/')
+                for f in lglob(relpath+'*.py') + lglob(relpath+'*.ipy') +
+                lglob(relpath + '*.pyw')]
+    return dirs + pys
+
+
+def cd_completer(self, event):
+    relpath = event.symbol
+    #print event # dbg
+    if '-b' in event.line:
+        # return only bookmark completions
+        bkms = self.db.get('bookmarks',{})
+        return bkms.keys()
+
+    
+    if event.symbol == '-':
+        width_dh = str(len(str(len(ip.user_ns['_dh']) + 1)))
+        # jump in directory history by number
+        fmt = '-%0' + width_dh +'d [%s]'
+        ents = [ fmt % (i,s) for i,s in enumerate(ip.user_ns['_dh'])]
+        if len(ents) > 1:
+            return ents
+        return []
+
+    if relpath.startswith('~'):
+        relpath = os.path.expanduser(relpath).replace('\\','/')
+    found = []
+    for d in [f.replace('\\','/') + '/' for f in glob.glob(relpath+'*')
+              if os.path.isdir(f)]:
+        if ' ' in d:
+            # we don't want to deal with any of that, complex code
+            # for this is elsewhere
+            raise IPython.ipapi.TryNext
+        found.append( d )
+
+    if not found:
+        if os.path.isdir(relpath):
+            return [relpath]
+        raise IPython.ipapi.TryNext
+    return found
+
+def apt_get_packages(prefix):
+    out = os.popen('apt-cache pkgnames')
+    for p in out:
+        if p.startswith(prefix):
+            yield p.rstrip()
+    
+    
+apt_commands = """\
+update upgrade install remove purge source build-dep dist-upgrade
+dselect-upgrade clean autoclean check"""
+
+def apt_completer(self, event):
+    """ Completer for apt-get (uses apt-cache internally)
+
+    """
+
+
+    cmd_param = event.line.split()
+    if event.line.endswith(' '):
+        cmd_param.append('')
+
+    if cmd_param[0] == 'sudo':
+        cmd_param = cmd_param[1:]
+
+    if len(cmd_param) == 2 or 'help' in cmd_param:
+        return apt_commands.split()
+
+    return list(apt_get_packages(event.symbol))
+
diff --git a/IPython/Extensions/ipy_constants.py b/IPython/Extensions/ipy_constants.py
new file mode 100644
index 0000000..59883cd
--- /dev/null
+++ b/IPython/Extensions/ipy_constants.py
@@ -0,0 +1,669 @@
+""" Module with physical constants for use with ipython, profile
+"physics".
+
+Definition of Fundamental Physical Constants, CODATA Recommended Values
+
+Source, Peter J. Mohr and Barry N. Taylor,  
+CODATA Recommended Values of the Fundamental
+Physical Constants, 1998                    
+                                            
+Website: physics.nist.gov/constants         
+"""
+# License: BSD-like
+# Copyright: Gael Varoquaux (gael.varoquaux@normalesup.org)
+
+# inspired by maxima's physconst.mac by Cliff Yapp
+
+#from math import * # math MUST be imported BEFORE PhysicalQInteractive 
+from IPython.Extensions.PhysicalQInteractive import PhysicalQuantityInteractive
+
+# Math constants:
+
+# Pi mathematical constants
+pi = 3.141592653589793238462643383279502884197169399375105820974944592
+
+# Universal Constants
+#-------------------------------------------------------------------------
+
+c = PhysicalQuantityInteractive(299792458 , 'm/s')
+c.__doc__ = """speed of light in vacuum"""
+c.__doc__ = "speed of light in vacuum"
+
+u_0 = PhysicalQuantityInteractive(4*pi*1E-7 , 'N/(A**2)')
+u_0.__doc__ = """magnetic constant"""
+mu_0 = PhysicalQuantityInteractive(4*pi*1E-7 , 'N/(A**2)')
+
+epsilon_0 = PhysicalQuantityInteractive(8.854187817E-12 , 'F/m')
+epsilon_0.__doc__ = """electric constant """
+
+Z_0 = PhysicalQuantityInteractive(376.730313461 , 'ohm')
+Z_0.__doc__ = """characteristic impedance of vacuum """
+
+G = PhysicalQuantityInteractive(6.673E-11 , 'm**3/(kg*s**2)')
+G.__doc__ = """Newtonian constant of gravitation    """
+
+
+h = PhysicalQuantityInteractive(6.62606876E-34 , 'J*s')
+h.__doc__ = """Planck constant    """
+
+
+h_eV = PhysicalQuantityInteractive(4.13566727E-15 , 'eV*s')
+h_eV.__doc__ = """Planck constant in eVs  """
+
+
+h_bar = PhysicalQuantityInteractive(1.054571596E-34 , 'J*s')
+h_bar.__doc__ = """Hbar"""
+
+
+h_bar_eV = PhysicalQuantityInteractive(6.58211889E-16 , 'eV*s')
+h_bar_eV.__doc__ = """Hbar in eV"""
+
+
+P_m = PhysicalQuantityInteractive(2.1767E-8 , 'kg')
+P_m.__doc__ = """Planck mass"""
+
+
+P_l = PhysicalQuantityInteractive(1.6160E-35 , 'm')
+P_l.__doc__ = """Planck length  """
+
+
+P_t = PhysicalQuantityInteractive(5.3906E-44 , 's')
+P_t.__doc__ = """Planck time """
+
+# Electromagnetic Constants
+#------------------------------------------------------------------------
+
+_e = PhysicalQuantityInteractive(1.602176462E-19 , 'C')
+_e.__doc__ = """elementary charge"""
+q = _e
+
+
+capitalphi_0 = PhysicalQuantityInteractive(2.067833636E-15 , 'Wb')
+capitalphi_0.__doc__ = """magnetic flux quantum """
+mfq_0 = PhysicalQuantityInteractive(2.067833636E-15 , 'Wb')
+
+
+G_0 = PhysicalQuantityInteractive(7.748091696E-5 , 'S')
+G_0.__doc__ = """conductance quantum """
+
+
+K_J = PhysicalQuantityInteractive(483597.898E9 , 'Hz/V')
+K_J.__doc__ = """Josephson constant"""
+
+
+R_K = PhysicalQuantityInteractive(25812.807572 , 'ohm')
+R_K.__doc__ = """von Klitzing constant"""
+
+
+u_B = PhysicalQuantityInteractive(927.400899E-26 , 'J/T')
+u_B.__doc__ = """Bohr magneton"""
+
+ueVT_B = PhysicalQuantityInteractive(5.788381749E-5 , 'eV/T')
+ueVT_B.__doc__ = """Bohr magneton in eV T-1"""
+
+
+u_N = PhysicalQuantityInteractive(5.05078317E-27 , 'J/T')
+u_N.__doc__ = """nuclear magneton """
+
+ueVT_N = PhysicalQuantityInteractive(3.152451238E-8 , 'eV/T')
+ueVT_N.__doc__ = """nuclear magneton in eV T-1      """
+
+# Atomic and Nuclear Constants
+# General
+#-------------------------------------------------------------------------
+# fine-structure constant 
+alpha = 7.297352533E-3
+
+
+Ry = PhysicalQuantityInteractive(10973731.568549 , '1/m')
+Ry.__doc__ = """Rydberg constant  """
+Ry_INF = PhysicalQuantityInteractive(10973731.568549 , '1/m')
+
+
+a_0 = PhysicalQuantityInteractive(0.5291772083E-10 , 'm')
+a_0.__doc__ = """Bohr radius """
+
+
+E_h = PhysicalQuantityInteractive(4.35974381E-18 , 'J')
+E_h.__doc__ = """Hartree energy """
+
+Eev_h = PhysicalQuantityInteractive(27.2113834 , 'eV')
+Eev_h.__doc__ = """Hartree energy in eV    """
+
+
+qcir2 = PhysicalQuantityInteractive(3.636947516E-4 , 'm**2/s')
+qcir2.__doc__ = """quantum of circulation   h/(2me) """
+
+qcir = PhysicalQuantityInteractive(7.273895032E-4 , 'm**2/s')
+qcir.__doc__ = """quantum of circulation   h/(me) """
+
+# Electroweak
+#-------------------------------------------------------------------------
+
+Fcc = PhysicalQuantityInteractive(1.16639E-5 , '1/GeV**2')
+Fcc.__doc__ = """Fermi coupling constant    """
+# weak mixing angled  W (on-shell scheme)
+wma_W = 0.2224
+
+# Electron, e-
+#-------------------------------------------------------------------------
+
+m_e = PhysicalQuantityInteractive(9.10938188E-31 , 'kg')
+m_e.__doc__ = """electron mass    """
+
+m_e_u = PhysicalQuantityInteractive(5.485799110E-4 , 'amu')
+m_e_u.__doc__ = """electron mass (electron relative atomic mass times amu)"""
+
+me_J = PhysicalQuantityInteractive(8.18710414E-14 , 'J')
+me_J.__doc__ = """electron mass - energy equivalent    """
+
+me_MeV = PhysicalQuantityInteractive(0.510998902 , 'MeV')
+me_MeV.__doc__ = """electron mass - energy equivalent in MeV"""
+
+# electron-muon mass ratio
+memu = 4.83633210E-3
+
+# electron-tau mass ratio    
+metau = 2.87555E-4
+
+# electron-proton mass ratio    
+memp = 5.446170232E-4
+
+# electron-neutron mass ratio 
+memn = 5.438673462E-4
+
+# electron-deuteron mass ratio    
+memd = 2.7244371170E-4
+
+# electron to alpha particle mass ratio    
+memalpha = 1.3709335611E-4
+
+
+echargeemass = PhysicalQuantityInteractive(-1.758820174E11 , 'C/kg')
+echargeemass.__doc__ = """electron charge to mass quotient    """
+
+
+Molar_e = PhysicalQuantityInteractive(5.485799110E-7 , 'kg/mol')
+Molar_e.__doc__ = """electron molar mass     """
+
+
+lambdaC = PhysicalQuantityInteractive(2.426310215E-12 , 'm')
+lambdaC.__doc__ = """Compton wavelength """
+
+
+r_e = PhysicalQuantityInteractive(2.817940285E-15 , 'm')
+r_e.__doc__ = """classical electron radius  """
+
+
+sigma_e = PhysicalQuantityInteractive(0.665245854E-28 , 'm**2')
+sigma_e.__doc__ = """Thomson cross section """
+
+
+u_e = PhysicalQuantityInteractive(-928.476362E-26 , 'J/T')
+u_e.__doc__ = """electron magnetic moment    """
+
+# electron magnetic moment to Bohr magneton ratio     
+ueuB = -1.0011596521869
+
+# electron magnetic moment to nuclear magneton ratio    
+ueuN = -1838.2819660
+
+# electron magnetic moment anomaly |ue|/uB - 1    
+a_e = 1.1596521869E-3
+
+# electron g-factor 
+g_e = -2.0023193043737
+
+# electron-muon magnetic moment ratio   
+ueuu = 206.7669720
+
+# electron-proton magnetic moment ratio    
+ueup = -658.2106875
+
+# electron to shielded proton magnetic moment ratio  (H2O, sphere, 25  C)
+ueusp = -658.2275954
+
+# electron-neutron magnetic moment ratio    
+ueun = 960.92050
+
+# electron-deuteron magnetic moment ratio    
+ueud = -2143.923498
+
+# electron to shielded helione magnetic moment ratio  (gas, sphere, 25  C)
+ueush = 864.058255
+
+
+gamma_e = PhysicalQuantityInteractive(1.760859794E11 , '1/(s*T)')
+gamma_e.__doc__ = """electron gyromagnetic ratio """
+
+# Muon, u-
+#-------------------------------------------------------------------------
+
+m_u = PhysicalQuantityInteractive(1.88353109E-28 , 'kg')
+m_u.__doc__ = """muon mass    """
+
+mu_u = PhysicalQuantityInteractive(0.1134289168 , 'amu')
+mu_u.__doc__ = """muon mass in muon relative atomic mass times amu    """
+
+
+muc2_J = PhysicalQuantityInteractive(1.69283332E-11 , 'J')
+muc2_J.__doc__ = """energy equivalent    """
+
+muc2_MeV = PhysicalQuantityInteractive(105.6583568 , 'MeV')
+muc2_MeV.__doc__ = """energy equivalent in MeV """
+
+# muon-electron mass ratio    
+mume = 206.7682657
+
+# muon-tau mass ratio
+mum = 5.94572E-2
+
+# muon-proton mass ratio
+mump = 0.1126095173
+
+# muon-neutron mass ratio 
+mumn = 0.1124545079
+
+
+Molar_u = PhysicalQuantityInteractive(0.1134289168E-3 , 'kg/mol')
+Molar_u.__doc__ = """muon molar mass """
+
+
+lambda_C_u = PhysicalQuantityInteractive(11.73444197E-15 , 'm')
+lambda_C_u.__doc__ = """muon Compton wavelength """
+
+
+uu = PhysicalQuantityInteractive(-4.49044813E-26 , 'J/T')
+uu.__doc__ = """muon magnetic moment    """
+
+# ratio of muon magnetic moment to Bohr magneton ratio 
+uuuB = -4.84197085E-3
+
+# ratio of muon magnetic moment to nuclear magneton ratio    
+uuuN = -8.89059770
+
+# muon magnetic moment anomaly |uu|/(e /2mu) - 1    
+a_u = 1.16591602E-3
+
+# muon g-factor -2(1 + au)
+g_u = -2.0023318320
+
+# muon-proton magnetic moment ratio    
+uuup = -3.18334539
+
+# Tau, tau-
+#-------------------------------------------------------------------------
+
+m_tau = PhysicalQuantityInteractive(3.16788E-27 , 'kg')
+m_tau.__doc__ = """tau mass    """
+
+mu_tau = PhysicalQuantityInteractive(1.90774 , 'amu')
+mu_tau.__doc__ = """tau mass  (tau relative atomic mass times amu)   """
+
+
+mtauc2_J = PhysicalQuantityInteractive(2.84715E-10 , 'J')
+mtauc2_J.__doc__ = """tau mass energy equivalent    """
+
+
+mtauc2_MeV = PhysicalQuantityInteractive(1777.05 , 'MeV')
+mtauc2_MeV.__doc__ = """tau mass energy equivalent in MeV """
+
+# tau-electron mass ratio   
+mtaume = 3477.60
+
+# tau-muon mass ratio    
+mtaumu = 16.8188
+
+# tau-proton mass ratio    
+mtaump = 1.89396
+
+# tau-neutron mass ratio    
+mtaumn = 1.89135
+
+
+Molar_tau = PhysicalQuantityInteractive(1.90774E-3 , 'kg/mol')
+Molar_tau.__doc__ = """tau molar mass """
+
+
+lambda_C_tau = PhysicalQuantityInteractive(0.69770E-15 , 'm')
+lambda_C_tau.__doc__ = """tau Compton wavelength    """
+
+# Proton, p
+#-------------------------------------------------------------------------
+
+m_p = PhysicalQuantityInteractive(1.67262158E-27 , 'kg')
+m_p.__doc__ = """proton mass  """
+
+mu_p = PhysicalQuantityInteractive(1.00727646688 , 'amu')
+mu_p.__doc__ = """proton mass (proton relative atomic mass times amu)  """
+
+
+mpc2_J = PhysicalQuantityInteractive(1.50327731E-10 , 'J')
+mpc2_J.__doc__ = """energy equivalent   """
+
+mpc2_MeV = PhysicalQuantityInteractive(938.271998 , 'MeV')
+mpc2_MeV.__doc__ = """energy equivalent in MeV  """
+
+# proton-electron mass ratio 
+mpme = 1836.1526675
+
+# proton-muon mass ratio
+mpmu = 8.88024408
+
+# proton-tau mass ratio 
+mpmtau = 0.527994
+
+# proton-neutron mass ratio 
+mpmn = 0.99862347855
+
+
+emp = PhysicalQuantityInteractive(9.57883408E7 , 'C/kg')
+emp.__doc__ = """proton charge to mass quotient    """
+
+
+Molar_p = PhysicalQuantityInteractive(1.00727646688E-3 , 'kg/mol')
+Molar_p.__doc__ = """proton molar mass """
+
+
+lambda_C_p = PhysicalQuantityInteractive(1.321409847E-15 , 'm')
+lambda_C_p.__doc__ = """proton Compton wavelength h/mpc  """
+
+
+up = PhysicalQuantityInteractive(1.410606633E-26 , 'J/T')
+up.__doc__ = """proton magnetic moment   """
+
+# proton magnetic moment to Bohr magneton ratio 
+upuB = 1.521032203E-3
+
+# proton magnetic moment to nuclear magneton ratio 
+upuN = 2.792847337
+
+# proton g-factor 2up/uN  
+g_p = 5.585694675
+
+# proton-neutron magnetic moment ratio  
+upun = -1.45989805
+
+
+usp = PhysicalQuantityInteractive(1.410570399E-26 , 'J/T')
+usp.__doc__ = """shielded proton magnetic moment  (H2O, sphere, 25  C)"""
+
+# shielded proton magnetic moment to Bohr magneton ratio 
+uspuB = 1.520993132E-3
+
+# shielded proton magnetic moment to nuclear magneton ratio 
+uspuN = 2.792775597
+
+# proton magnetic shielding correction 1 - u p/up  (H2O, sphere, 25  C)
+spc = 25.687E-6
+
+
+gamma_p = PhysicalQuantityInteractive(2.67522212E8 , '1/(s*T)')
+gamma_p.__doc__ = """proton gyromagnetic ratio """
+
+
+gamma_sp = PhysicalQuantityInteractive(2.67515341E8 , '1/(s*T)')
+gamma_sp.__doc__ = """shielded proton gyromagnetic ratio (H2O, sphere, 25  C)"""
+
+# Neutron, n
+#-------------------------------------------------------------------------
+
+m_n = PhysicalQuantityInteractive(1.67492716E-27 , 'kg')
+m_n.__doc__ = """neutron mass  """
+
+mu_n = PhysicalQuantityInteractive(1.00866491578 , 'amu')
+mu_n.__doc__ = """neutron mass (neutron relative atomic mass times amu) """
+
+
+mnc2_J = PhysicalQuantityInteractive(1.50534946E-10 , 'J')
+mnc2_J.__doc__ = """neutron mass energy equivalent  """
+
+
+mnc2_MeV = PhysicalQuantityInteractive(939.565330 , 'MeV')
+mnc2_MeV.__doc__ = """neutron mass energy equivalent  in MeV  """
+
+# neutron-electron mass ratio 
+mnme = 1838.6836550
+
+# neutron-muon mass ratio 
+mnmu = 8.89248478
+
+# neutron-tau mass ratio 
+mnm = 0.528722
+
+# neutron-proton mass ratio 
+mnmp = 1.00137841887
+
+
+Molar_n = PhysicalQuantityInteractive(1.00866491578E-3 , 'kg/mol')
+Molar_n.__doc__ = """neutron molar mass  """
+
+
+lambda_C_n = PhysicalQuantityInteractive(1.319590898E-15 , 'm')
+lambda_C_n.__doc__ = """neutron Compton wavelength"""
+
+
+un = PhysicalQuantityInteractive(-0.96623640E-26 , 'J/T')
+un.__doc__ = """neutron magnetic moment """
+
+# neutron magnetic moment to Bohr magneton ratio 
+unuB = -1.04187563E-3
+
+# neutron magnetic moment to nuclear magneton ratio 
+unuN = -1.91304272
+
+# neutron g-factor 
+g_n = -3.82608545
+
+# neutron-electron magnetic moment ratio  
+unue = 1.04066882E-3
+
+# neutron-proton magnetic moment ratio 
+unup = -0.68497934
+
+# neutron to shielded proton magnetic moment ratio (H2O, sphere, 25  C)
+unusp = -0.68499694
+
+
+gamma_n = PhysicalQuantityInteractive(1.83247188E8 , '1/(s*T)')
+gamma_n.__doc__ = """neutron gyromagnetic ratio """
+
+# Deuteron, d
+#-------------------------------------------------------------------------
+
+m_d = PhysicalQuantityInteractive(3.34358309E-27 , 'kg')
+m_d.__doc__ = """deuteron mass """
+
+
+mu_d = PhysicalQuantityInteractive(2.01355321271 , 'amu')
+mu_d.__doc__ = """deuteron mass (deuteron relative atomic mass times amu)  """
+
+
+mdc2_J = PhysicalQuantityInteractive(3.00506262E-10 , 'J')
+mdc2_J.__doc__ = """deuteron mass energy equivalent """
+
+
+mdc2_eV = PhysicalQuantityInteractive(1875.612762 , 'MeV')
+mdc2_eV.__doc__ = """deuteron mass energy equivalent in MeV  """
+
+# deuteron-electron mass ratio  
+mdme = 3670.4829550
+
+# deuteron-proton mass ratio 
+mdmp = 1.99900750083
+
+
+Molar_d = PhysicalQuantityInteractive(2.01355321271E-3 , 'kg/mol')
+Molar_d.__doc__ = """deuteron molar mass """
+
+
+ud = PhysicalQuantityInteractive(0.433073457E-26 , 'J/T')
+ud.__doc__ = """deuteron magnetic moment  """
+
+# deuteron magnetic moment to Bohr magneton ratio 
+uduB = 0.4669754556E-3
+
+# deuteron magnetic moment to nuclear magneton ratio 
+uduN = 0.8574382284
+
+# deuteron-electron magnetic moment ratio 
+udue = -4.664345537E-4
+
+# deuteron-proton magnetic moment ratio 
+udup = 0.3070122083
+
+# deuteron-neutron magnetic moment ratio 
+udun = -0.44820652
+
+# Helion, h
+#-------------------------------------------------------------------------
+
+m_h = PhysicalQuantityInteractive(5.00641174E-27 , 'kg')
+m_h.__doc__ = """helion mass """
+
+
+mu_h = PhysicalQuantityInteractive(3.01493223469 , 'amu')
+mu_h.__doc__ = """helion mass (helion relative atomic mass times amu)  """
+
+
+mhc2_J = PhysicalQuantityInteractive(4.49953848E-10 , 'J')
+mhc2_J.__doc__ = """helion mass energy equivalent """
+
+mhc2_MeV = PhysicalQuantityInteractive(2808.39132 , 'MeV')
+mhc2_MeV.__doc__ = """helion mass energy equivalent in MeV """
+
+# helion-electron mass ratio 
+mhme = 5495.885238
+
+# helion-proton mass ratio 
+mhmp = 2.99315265850
+
+
+Molar_h = PhysicalQuantityInteractive(3.01493223469E-3 , 'kg/mol')
+Molar_h.__doc__ = """helion molar mass """
+
+
+ush = PhysicalQuantityInteractive(-1.074552967E-26 , 'J/T')
+ush.__doc__ = """shielded helion magnetic moment (gas, sphere, 25  C)"""
+
+# shielded helion magnetic moment to Bohr magneton ratio 
+ushuB = -1.158671474E-3
+
+# shielded helion magnetic moment to nuclear magneton ratio  
+ushuN = -2.127497718
+
+# shielded helion to proton magnetic moment ratio  (gas, sphere, 25  C)
+ushup = -0.761766563
+
+# shielded helion to shielded proton magnetic moment ratio  (gas/H2O, spheres, 25  C)
+ushusp = -0.7617861313
+
+
+gamma_h = PhysicalQuantityInteractive(2.037894764E8 , '1/(s*T)')
+gamma_h.__doc__ = """shielded helion gyromagnetic  (gas, sphere, 25  C) """
+
+# Alpha particle, 
+#-------------------------------------------------------------------------
+
+m_alpha = PhysicalQuantityInteractive(6.64465598E-27 , 'kg')
+m_alpha.__doc__ = """alpha particle mass  """
+
+mu_alpha = PhysicalQuantityInteractive(4.0015061747 , 'amu')
+mu_alpha.__doc__ = """alpha particle mass (alpha particle relative atomic mass times amu) """
+
+
+malphac2_J = PhysicalQuantityInteractive(5.97191897E-10 , 'J')
+malphac2_J.__doc__ = """alpha particle mass energy equivalent  """
+
+
+malphac2_MeV = PhysicalQuantityInteractive(3727.37904 , 'MeV')
+malphac2_MeV.__doc__ = """alpha particle mass energy equivalent in MeV  """
+
+# alpha particle to electron mass ratio 
+malphame = 7294.299508
+
+# alpha particle to proton mass ratio 
+malphamp = 3.9725996846
+
+
+Molar_alpha = PhysicalQuantityInteractive(4.0015061747E-3 , 'kg/mol')
+Molar_alpha.__doc__ = """alpha particle molar mass"""
+
+# PHYSICO-CHEMICAL
+#-------------------------------------------------------------------------
+
+N_A = PhysicalQuantityInteractive(6.02214199E23 , '1/mol')
+N_A.__doc__ = """Avogadro constant  """
+L = PhysicalQuantityInteractive(6.02214199E23 , '1/mol')
+
+
+m_u = PhysicalQuantityInteractive(1.66053873E-27 , 'kg')
+m_u.__doc__ = """atomic mass constant mu = 112m(12C) = 1 u = 10E-3 kg mol-1/NA"""
+# atomic mass constant mu = 112m(12C) = 1 u = 10E-3 kg mol-1/NA
+amu = m_u
+
+
+muc2_J = PhysicalQuantityInteractive(1.49241778E-10 , 'J')
+muc2_J.__doc__ = """energy equivalent of the atomic mass constant"""
+
+
+muc2_MeV = PhysicalQuantityInteractive(931.494013 , 'MeV')
+muc2_MeV.__doc__ = """energy equivalent of the atomic mass constant in MeV """
+
+
+F = PhysicalQuantityInteractive(96485.3415 , 'C/mol')
+F.__doc__ = """Faraday constant"""
+
+
+N_Ah = PhysicalQuantityInteractive(3.990312689E-10 , 'J*s/mol')
+N_Ah.__doc__ = """molar Planck constant   """
+
+
+R = PhysicalQuantityInteractive(8.314472 , 'J/(mol*K)')
+R.__doc__ = """molar gas constant  """
+
+
+k_J = PhysicalQuantityInteractive(1.3806503E-23 , 'J/K')
+k_J.__doc__ = """Boltzmann constant """
+
+
+k_eV = PhysicalQuantityInteractive(8.617342E-5 , 'eV/K')
+k_eV.__doc__ = """Boltzmann constant in eV """
+
+
+n_0 = PhysicalQuantityInteractive(2.6867775E25 , '1/m**3')
+n_0.__doc__ = """Loschmidt constant  NA/Vm """
+
+
+Vm_1 = PhysicalQuantityInteractive(22.413996E-3 , 'm**3/mol')
+Vm_1.__doc__ = """molar volume of ideal gas RT/p   T = 273.15 K, p = 101.325 kPa """
+
+Vm_2 = PhysicalQuantityInteractive(22.710981E-3 , 'm**3/mol')
+Vm_2.__doc__ = """molar volume of ideal gas RT/p   T = 273.15 K, p = 100 kPa  """
+
+# Sackur-Tetrode constant (absolute entropy constant) 52 + ln_(2 mukT1/h2)3/2kT1/p0
+# T1 = 1 K, p0 = 100 kPa 
+S_0R_1 = -1.1517048
+# T1 = 1 K, p0 = 101.325 kPa  
+S_0R_2 = -1.1648678
+
+
+sigma = PhysicalQuantityInteractive(5.670400E-8 , 'W/(m**2*K**4)')
+sigma.__doc__ = """Stefan-Boltzmann constant """
+
+
+c_1 = PhysicalQuantityInteractive(3.74177107E-16 , 'W*m**2')
+c_1.__doc__ = """first radiation constant"""
+
+
+c_1L = PhysicalQuantityInteractive(1.191042722E-16 , 'W*m**2/sr')
+c_1L.__doc__ = """first radiation constant for spectral radiance"""
+
+
+c_2 = PhysicalQuantityInteractive(1.4387752E-2 , 'm*K')
+c_2.__doc__ = """second radiation constant"""
+
+
+b = PhysicalQuantityInteractive(2.8977686E-3 , 'm*K')
+b.__doc__ = """Wien displacement law constant b =  maxT = c2/4.965 114231... """
+
diff --git a/IPython/Extensions/ipy_defaults.py b/IPython/Extensions/ipy_defaults.py
new file mode 100644
index 0000000..89ea3e2
--- /dev/null
+++ b/IPython/Extensions/ipy_defaults.py
@@ -0,0 +1,62 @@
+""" Set default options for IPython. 
+
+Just import this module to get reasonable defaults for everything.
+
+These configurations used to be performed in ipythonrc (or ipythonrc.ini). 
+Therefore importing this in your config files makes ipython basically
+ignore your ipythonrc. This is *not* imported by default, you need to import 
+this manually in one of your config files.
+
+You can further override these defaults in e.g. your ipy_user_config.py,
+ipy_profile_PROFILENAME etc.
+
+"""
+
+import IPython.rlineimpl as readline
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+o = ip.options
+
+o.colors = "Linux"
+o.color_info=1
+o.confirm_exit=1
+o.pprint=1
+o.multi_line_specials=1
+o.xmode="Context"
+
+
+o.prompt_in1='In [\#]: '
+o.prompt_in2 ='   .\D.: '
+o.prompt_out = 'Out[\#]: '
+o.prompts_pad_left=1
+
+o.autoindent = 1
+
+o.readline_remove_delims="-/~"
+o.readline_merge_completions=1
+
+o.readline = 1
+
+rlopts = """\
+tab: complete
+"\C-l": possible-completions
+set show-all-if-ambiguous on
+"\C-o": tab-insert
+"\M-i": "    "
+"\M-o": "\d\d\d\d"
+"\M-I": "\d\d\d\d"
+"\C-r": reverse-search-history
+"\C-s": forward-search-history
+"\C-p": history-search-backward
+"\C-n": history-search-forward
+"\e[A": history-search-backward
+"\e[B": history-search-forward
+"\C-k": kill-line
+"\C-u": unix-line-discard"""
+
+if readline.have_readline:
+    for cmd in rlopts.split('\n'):
+        readline.parse_and_bind(cmd)
+    
+    
diff --git a/IPython/Extensions/ipy_editors.py b/IPython/Extensions/ipy_editors.py
new file mode 100644
index 0000000..c94027c
--- /dev/null
+++ b/IPython/Extensions/ipy_editors.py
@@ -0,0 +1,84 @@
+""" 'editor' hooks for common editors that work well with ipython
+
+They should honor the line number argument, at least.
+
+Contributions are *very* welcome.
+"""
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+from IPython.Itpl import itplns
+import os
+
+def install_editor(run_template, wait = False):
+    """ Gets a template in format "myeditor bah bah $file bah bah $line"
+    
+    $file will be replaced by file name, $line by line number (or 0).
+    Installs the editor that is called by IPython, instead of the default
+    notepad or vi.
+    
+    If wait is true, wait until the user presses enter before returning,
+    to facilitate non-blocking editors that exit immediately after
+    the call.
+    """
+    
+    def call_editor(self, file, line=0):
+        if line is None:
+            line = 0
+        cmd = itplns(run_template, locals())
+        print ">",cmd
+        os.system(cmd)
+        if wait:
+            raw_input("Press Enter when done editing:")
+
+    ip.set_hook('editor',call_editor)
+
+
+# in these, exe is always the path/name of the executable. Useful
+# if you don't have the editor directory in your path
+
+def komodo(exe = 'komodo'):
+    """ Activestate Komodo [Edit] """
+    install_editor(exe + ' -l $line "$file"', wait = True)
+
+def scite(exe = "scite"):
+    """ SciTE or Sc1 """
+    install_editor(exe + ' "$file" -goto:$line')
+
+def notepadplusplus(exe = 'notepad++'):
+    """ Notepad++ http://notepad-plus.sourceforge.net """
+    install_editor(exe + ' -n$line "$file"')
+    
+def jed(exe = 'jed'):
+    """ JED, the lightweight emacsish editor """
+    install_editor(exe + ' +$line "$file"')
+
+def idle(exe = None):
+    """ Idle, the editor bundled with python
+    
+    Should be pretty smart about finding the executable.
+    """
+    if exe is None:
+        import idlelib
+        p = os.path.dirname(idlelib.__file__)
+        exe = p + '/idle.py'
+    install_editor(exe + ' "$file"')
+        
+
+# these are untested, report any problems
+
+def emacs(exe = 'emacs'):
+    install_editor(exe + ' +$line "$file"')
+
+def gnuclient(exe= 'gnuclient'):
+    install_editor(exe + ' -nw +$line "$file"')
+
+def crimson_editor(exe = 'cedt.exe'):
+    install_editor(exe + ' /L:$line "$file"')
+    
+def kate(exe = 'kate'):
+    install_editor(exe + ' -u -l $line "$file"')
+    
+   
+    
\ No newline at end of file
diff --git a/IPython/Extensions/ipy_exportdb.py b/IPython/Extensions/ipy_exportdb.py
new file mode 100644
index 0000000..d19cfc0
--- /dev/null
+++ b/IPython/Extensions/ipy_exportdb.py
@@ -0,0 +1,76 @@
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import os,pprint
+
+def export(filename = None):
+
+    lines = ['import IPython.ipapi', 'ip = IPython.ipapi.get()','']
+
+    vars = ip.db.keys('autorestore/*')
+    vars.sort()
+    varstomove = []
+    get = ip.db.get
+    
+    macros = []
+    variables = []
+    
+    for var in vars:
+        k = os.path.basename(var)
+        v = get(var)
+
+        if k.startswith('_'):
+            continue
+        if isinstance(v, IPython.macro.Macro):
+            macros.append((k,v))
+        if type(v) in [int, str, float]:
+            variables.append((k,v))
+            
+            
+
+    if macros:
+        lines.extend(['# === Macros ===' ,''])
+    for k,v in macros:
+        lines.append("ip.defmacro('%s'," % k)
+        for line in v.value.splitlines():
+            lines.append(' ' + repr(line+'\n'))
+        lines.extend([')', ''])
+        
+    if variables:
+        lines.extend(['','# === Variables ===',''])
+        for k,v in variables:
+            varstomove.append(k)
+            lines.append('%s = %s' % (k,repr(v)))
+                
+        lines.append('ip.to_user_ns("%s")' % (' '.join(varstomove)))
+    
+    bkms = ip.db.get('bookmarks',{})
+    
+    if bkms:
+        lines.extend(['','# === Bookmarks ===',''])
+        lines.append("ip.db['bookmarks'] = %s " % pprint.pformat(bkms, indent = 2) )
+        
+    aliases = ip.db.get('stored_aliases', {} )
+    
+    if aliases:
+        lines.extend(['','# === Alias definitions ===',''])
+        for k,v in aliases.items():
+            try:
+                lines.append("ip.defalias('%s', %s)" % (k, repr(v[1])))
+            except (AttributeError, TypeError):
+                pass
+
+    env = ip.db.get('stored_env')
+    if env:
+        lines.extend(['','# === Stored env vars ===',''])
+        lines.append("ip.db['stored_env'] = %s " % pprint.pformat(env, indent = 2) )
+        
+    
+    
+    out = '\n'.join(lines)
+    
+    if filename:
+        open(filename,'w').write(out)
+    else:
+        print out
+    
diff --git a/IPython/Extensions/ipy_extutil.py b/IPython/Extensions/ipy_extutil.py
new file mode 100644
index 0000000..c35cbc3
--- /dev/null
+++ b/IPython/Extensions/ipy_extutil.py
@@ -0,0 +1,43 @@
+""" IPython extension management tools.
+
+After installation, you'll have the 'extutil' object in your namespace.
+to.
+"""
+
+# for the purposes of this module, every module that has the name 'ip' globally
+# installed as below is an IPython extension
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import sys,textwrap,inspect
+
+def indent(s, ind= '    '):
+    return '\n'.join([ind +l for l in s.splitlines()])
+
+class ExtUtil:
+    """ IPython extensios (ipy_* etc.) management utilities """
+    
+    def describe(self):
+        for n,mod in self._active():
+            doc = inspect.getdoc(mod)
+            if doc:
+                print '== %s ==' % n
+                print indent(doc)
+            
+            
+    def ls(self):
+        """ Show list of installed extensions. """
+        for n,m in self._active():
+            print '%-20s %s' % (n,m.__file__.replace('\\','/'))
+    def _active(self):
+        act = []
+        for mname,m in sys.modules.items():
+            o = getattr(m, 'ip', None)
+            if isinstance(o, IPython.ipapi.IPApi):
+                act.append((mname,m))
+        act.sort()                
+        return act
+
+extutil = ExtUtil()                
+ip.to_user_ns('extutil')
diff --git a/IPython/Extensions/ipy_fsops.py b/IPython/Extensions/ipy_fsops.py
new file mode 100644
index 0000000..a8cd2eb
--- /dev/null
+++ b/IPython/Extensions/ipy_fsops.py
@@ -0,0 +1,244 @@
+""" File system operations
+
+Contains: Simple variants of normal unix shell commands (icp, imv, irm,
+imkdir, igrep).
+
+Some "otherwise handy" utils ('collect' for gathering files to
+~/_ipython/collect, 'inote' for collecting single note lines to
+~/_ipython/note.txt)
+
+Mostly of use for bare windows installations where cygwin/equivalent is not
+installed and you would otherwise need to deal with dos versions of the
+commands (that e.g. don't understand / as path separator). These can
+do some useful tricks on their own, though (like use 'mglob' patterns).
+
+Not to be confused with ipipe commands (ils etc.) that also start with i.
+"""
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import shutil,os,shlex
+from IPython.external import mglob
+from IPython.external.path import path
+from IPython.ipapi import UsageError
+
+def parse_args(args):
+    """ Given arg string 'CMD files... target', return ([files], target) """
+    
+    tup = args.split(None, 1)
+    if len(tup) == 1:
+        raise UsageError("Expected arguments for " + tup[0])
+    
+    tup2 = shlex.split(tup[1])
+    
+    flist, trg = mglob.expand(tup2[0:-1]), tup2[-1]
+    if not flist:
+        raise UsageError("No files found:" + str(tup2[0:-1]))
+    return flist, trg
+    
+def icp(ip,arg):
+    """ icp files... targetdir
+    
+    Copy all files to target, creating dirs for target if necessary
+    
+    icp srcdir dstdir
+    
+    Copy srcdir to distdir
+    
+    """
+    import distutils.dir_util
+    
+    fs, targetdir = parse_args(arg)
+    if not os.path.isdir(targetdir) and len(fs) > 1:
+        distutils.dir_util.mkpath(targetdir,verbose =1)
+    for f in fs:
+        if os.path.isdir(f):
+            shutil.copytree(f, targetdir)
+        else:
+            shutil.copy2(f,targetdir)
+    return fs
+ip.defalias("icp",icp)
+
+def imv(ip,arg):
+    """ imv src tgt
+    
+    Move source to target.
+    """
+    
+    fs, target = parse_args(arg)
+    if len(fs) > 1:
+        assert os.path.isdir(target)
+    for f in fs:        
+        shutil.move(f, target)
+    return fs
+ip.defalias("imv",imv)        
+
+def irm(ip,arg):
+    """ irm path[s]...
+    
+    Remove file[s] or dir[s] path. Dirs are deleted recursively.
+    """
+    try:
+        paths = mglob.expand(arg.split(None,1)[1])
+    except IndexError:
+        raise UsageError("%irm paths...")
+    import distutils.dir_util
+    for p in paths:
+        print "rm",p
+        if os.path.isdir(p):
+            distutils.dir_util.remove_tree(p, verbose = 1)
+        else:
+            os.remove(p)
+
+ip.defalias("irm",irm)
+
+def imkdir(ip,arg):
+    """ imkdir path
+    
+    Creates dir path, and all dirs on the road
+    """
+    import distutils.dir_util
+    targetdir = arg.split(None,1)[1]
+    distutils.dir_util.mkpath(targetdir,verbose =1)    
+
+ip.defalias("imkdir",imkdir)    
+
+def igrep(ip,arg):
+    """ igrep PAT files...
+    
+    Very dumb file scan, case-insensitive.
+    
+    e.g.
+    
+    igrep "test this" rec:*.py
+    
+    """
+    elems = shlex.split(arg)
+    dummy, pat, fs = elems[0], elems[1], mglob.expand(elems[2:])
+    res = []
+    for f in fs:
+        found = False
+        for l in open(f):
+            if pat.lower() in l.lower():
+                if not found:
+                    print "[[",f,"]]"
+                    found = True
+                    res.append(f)
+                print l.rstrip()
+    return res
+
+ip.defalias("igrep",igrep)    
+
+def collect(ip,arg):
+    """ collect foo/a.txt rec:bar=*.py
+    
+    Copies foo/a.txt to ~/_ipython/collect/foo/a.txt and *.py from bar,
+    likewise
+    
+    Without args, try to open ~/_ipython/collect dir (in win32 at least).
+    """
+    from IPython.external.path import path
+    basedir = path(ip.options.ipythondir + '/collect')
+    try:    
+        fs = mglob.expand(arg.split(None,1)[1])
+    except IndexError:
+        os.startfile(basedir)
+        return
+    for f in fs:
+        f = path(f)
+        trg = basedir / f.splitdrive()[1].lstrip('/\\')
+        if f.isdir():
+            print "mkdir",trg
+            trg.makedirs()
+            continue
+        dname = trg.dirname()
+        if not dname.isdir():
+            dname.makedirs()
+        print f,"=>",trg
+        shutil.copy2(f,trg)
+
+ip.defalias("collect",collect)            
+
+def inote(ip,arg):
+    """ inote Hello world
+    
+    Adds timestamp and Hello world to ~/_ipython/notes.txt
+    
+    Without args, opens notes.txt for editing.
+    """
+    import time
+    fname = ip.options.ipythondir + '/notes.txt'
+    
+    try:
+        entry = " === " + time.asctime() + ': ===\n' + arg.split(None,1)[1] + '\n'
+        f= open(fname, 'a').write(entry)    
+    except IndexError:
+        ip.IP.hooks.editor(fname)        
+
+ip.defalias("inote",inote)
+
+def pathobj_mangle(p):
+    return p.replace(' ', '__').replace('.','DOT')
+def pathobj_unmangle(s):
+    return s.replace('__',' ').replace('DOT','.')
+
+
+    
+class PathObj(path):
+    def __init__(self,p):
+        self.path = p
+        if p != '.':
+            self.ents = [pathobj_mangle(ent) for ent in os.listdir(p)]
+        else:
+            self.ents = None
+    def __complete__(self):
+        if self.path != '.':
+            return self.ents
+        self.ents = [pathobj_mangle(ent) for ent in os.listdir('.')]
+        return self.ents
+    def __getattr__(self,name):
+        if name in self.ents:
+            if self.path.endswith('/'):
+                sep = ''
+            else:
+                sep = '/'
+                
+            tgt = self.path + sep + pathobj_unmangle(name)
+            #print "tgt",tgt
+            if os.path.isdir(tgt):
+                return PathObj(tgt)
+            if os.path.isfile(tgt):
+                return path(tgt)
+
+        raise AttributeError, name  # <<< DON'T FORGET THIS LINE !!
+    def __str__(self):
+        return self.path
+        
+    def __repr__(self):
+        return "<PathObj to %s>" % self.path
+    
+    def __call__(self):
+        print "cd:",self.path
+        os.chdir(self.path)
+        
+def complete_pathobj(obj, prev_completions):    
+    if hasattr(obj,'__complete__'):
+        res = obj.__complete__()
+        if res:
+            return res
+    # just return normal attributes of 'path' object if the dir is empty
+    raise IPython.ipapi.TryNext
+
+complete_pathobj = IPython.generics.complete_object.when_type(PathObj)(complete_pathobj)
+
+def test_pathobj():
+    #p = PathObj('c:/prj')
+    #p2 = p.cgi
+    #print p,p2
+    rootdir = PathObj("/")
+    startmenu = PathObj("d:/Documents and Settings/All Users/Start Menu/Programs")
+    cwd = PathObj('.')
+    ip.to_user_ns("rootdir startmenu cwd")
+    
+#test_pathobj()
\ No newline at end of file
diff --git a/IPython/Extensions/ipy_gnuglobal.py b/IPython/Extensions/ipy_gnuglobal.py
new file mode 100644
index 0000000..d03babc
--- /dev/null
+++ b/IPython/Extensions/ipy_gnuglobal.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+
+
+"""
+Add %global magic for GNU Global usage.
+
+http://www.gnu.org/software/global/
+
+"""
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+import os
+
+# alter to your liking
+global_bin = 'd:/opt/global/bin/global'
+
+def global_f(self,cmdline):
+    simple = 0
+    if '-' not in cmdline:
+        cmdline  = '-rx ' + cmdline
+        simple = 1
+        
+    lines = [l.rstrip() for l in os.popen( global_bin + ' ' + cmdline ).readlines()]
+    
+    if simple:
+        parts = [l.split(None,3) for l in lines]
+        lines = ['%s [%s]\n%s' % (p[2].rjust(70),p[1],p[3].rstrip()) for p in parts]
+    print "\n".join(lines)
+
+ip.expose_magic('global', global_f)
+
+def global_completer(self,event):
+    compl = [l.rstrip() for l in os.popen(global_bin + ' -c ' + event.symbol).readlines()]
+    return compl    
+
+ip.set_hook('complete_command', global_completer, str_key = '%global')
+
diff --git a/IPython/Extensions/ipy_kitcfg.py b/IPython/Extensions/ipy_kitcfg.py
new file mode 100644
index 0000000..d77f672
--- /dev/null
+++ b/IPython/Extensions/ipy_kitcfg.py
@@ -0,0 +1,80 @@
+import os,sys
+
+import ipy_rehashdir,glob
+from ipy_rehashdir import selflaunch, PyLauncher
+
+def pylaunchers():
+    """Create launchers for python scripts in cwd and store them in alias table
+    
+    This is useful if you want to invoke .py scripts from ipykit session,
+    just adding .py files in PATH does not work without file association.
+    
+    .ipy files will be run like macros.
+    
+    """
+    fs = glob.glob('*.py') + glob.glob('*.ipy')
+    for f in fs:
+        l = PyLauncher(f)
+        n = os.path.splitext(f)[0]
+        ip.defalias(n, l)
+        ip.magic('store '+n)
+
+
+def exta_imports():
+    # add some modules that you'd want to be bundled in the ipykit
+    # library zip file here. Do this if you get ImportErrors from scripts you
+    # try to launch with 'py' or pylaunchers. In theory you could include
+    # the whole stdlib here for full script coverage
+    
+    # note that this is never run, it's just here for py2exe
+    import distutils.dir_util
+  
+def kitroot():
+    return os.environ.get('IPYKITROOT', None)
+    
+def main():
+
+    if not kitroot():
+        print "Can't configure ipykit, IPYKITROOT should be set."
+        return
+        
+    os.environ["PATH"] = os.environ["PATH"] + ";" + kitroot() + "\\bin;"
+    ip.to_user_ns("pylaunchers")
+    cmds = ip.db.get('syscmdlist', None)
+    if cmds is None:
+        ip.magic('rehashx')
+        cmds = ip.db.get('syscmdlist', [])
+    #print cmds
+    if 'sc1' in cmds:
+        print "Default editor: Sc1"
+        import ipy_editors
+        ipy_editors.scite('sc1')
+    
+    # for icp, imv, imkdir, etc.
+    import ipy_fsops
+
+greeting = """\n\n === Welcome to ipykit ===
+
+%quickref - learn quickly about IPython.
+
+"""
+    
+def ipython_firstrun(ip):
+
+    print "First run of ipykit - configuring"
+
+    ip.defalias('py',selflaunch)
+    ip.defalias('d','dir /w /og /on')
+    ip.magic('store py')
+    ip.magic('store d')
+    
+    bins = kitroot() +'/bin'
+
+    print greeting
+        
+def init_ipython(ipy):
+    global ip
+    ip = ipy
+    main()
+
+
diff --git a/IPython/Extensions/ipy_legacy.py b/IPython/Extensions/ipy_legacy.py
new file mode 100644
index 0000000..e59a5db
--- /dev/null
+++ b/IPython/Extensions/ipy_legacy.py
@@ -0,0 +1,62 @@
+""" Legacy stuff
+
+Various stuff that are there for historical / familiarity reasons.
+
+This is automatically imported by default profile, though not other profiles
+(e.g. 'sh' profile).
+
+Stuff that is considered obsolete / redundant is gradually moved here.
+
+"""
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import os,sys
+
+from IPython.genutils import *
+
+# use rehashx
+
+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.get('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()
+
+ip.expose_magic("rehash", magic_rehash)
+
+# Exit
+def magic_Quit(self, parameter_s=''):
+    """Exit IPython without confirmation (like %Exit)."""
+
+    self.shell.exit_now = True
+
+ip.expose_magic("Quit", magic_Quit)
+
+
+# make it autocallable fn if you really need it
+def magic_p(self, parameter_s=''):
+    """Just a short alias for Python's 'print'."""
+    exec 'print ' + parameter_s in self.shell.user_ns
+
+ip.expose_magic("p", magic_p)
diff --git a/IPython/Extensions/ipy_leo.py b/IPython/Extensions/ipy_leo.py
new file mode 100644
index 0000000..29d39dc
--- /dev/null
+++ b/IPython/Extensions/ipy_leo.py
@@ -0,0 +1,215 @@
+""" Leo plugin for IPython
+
+Example use:
+
+nodes.foo = "hello world"
+
+  -> create '@ipy foo' node with text "hello world"
+
+Access works also, and so does tab completion.
+   
+"""
+import IPython.ipapi
+import IPython.genutils
+import IPython.generics
+import re
+
+
+
+ip = IPython.ipapi.get()
+leo = ip.user_ns['leox']
+c,g = leo.c, leo.g
+
+# will probably be overwritten by user, but handy for experimentation early on
+ip.user_ns['c'] = c
+ip.user_ns['g'] = g
+
+
+from IPython.external.simplegeneric import generic 
+import pprint
+
+@generic
+def format_for_leo(obj):
+    """ Convert obj to string representiation (for editing in Leo)"""
+    return pprint.pformat(obj)
+
+@format_for_leo.when_type(list)
+def format_list(obj):
+    return "\n".join(str(s) for s in obj)
+
+nodename_re = r'(@ipy?[\w-]+)?\s?(\w+)'
+
+def all_cells():
+    d = {}
+    for p in c.allNodes_iter():
+        h = p.headString()
+        if h.startswith('@') and len(h.split()) == 1: 
+            continue
+        mo = re.match(nodename_re, h)
+        if not mo:
+            continue
+        d[mo.group(2)] = p.copy()
+    return d    
+    
+
+class TrivialLeoWorkbook:
+    """ class to find cells """
+    def __getattr__(self, key):
+        cells = all_cells()
+        p = cells[key]
+        body = p.bodyString()
+        return eval_body(body)
+    def __setattr__(self,key,val):
+        cells = all_cells()
+        p = cells.get(key,None)
+        if p is None:
+            add_var(key,val)
+        else:
+            c.setBodyString(p,format_for_leo(val))
+    def __str__(self):
+        return "<TrivialLeoWorkbook>"
+    __repr__ = __str__
+
+ip.user_ns['nodes'] = TrivialLeoWorkbook()            
+
+
+class LeoNode(object):
+    def __init__(self,p):
+        self.p = p.copy()
+
+    def get_h(self): return self.p.headString()
+    def set_h(self,val):
+        print "set head",val 
+        c.setHeadString(self.p,val)
+        
+    h = property( get_h, set_h)  
+
+    def get_b(self): return self.p.bodyString()
+    def set_b(self,val):
+        print "set body",val 
+        c.setBodyString(self.p, val)
+    
+    b = property(get_b, set_b)
+    
+    def set_val(self, val):
+        self.b = pprint.pformat(val)
+        
+    val = property(lambda self: ip.ev(self.b.strip()), set_val)
+    
+    def set_l(self,val):
+        self.b = '\n'.join(val )
+    l = property(lambda self : IPython.genutils.SList(self.b.splitlines()), 
+                 set_l)
+    
+    def __iter__(self):
+        return (LeoNode(p) for p in self.p.children_iter())
+     
+
+class LeoWorkbook:
+    """ class for 'advanced' node access """
+    def __getattr__(self, key):
+        if key.startswith('_') or key == 'trait_names':
+            raise AttributeError
+        cells = all_cells()
+        p = cells.get(key, None)
+        if p is None:
+            p = add_var(key,None)
+
+        return LeoNode(p)
+
+    def __str__(self):
+        return "<LeoWorkbook>"
+    __repr__ = __str__
+ip.user_ns['wb'] = LeoWorkbook()
+
+
+_dummyval = object()
+@IPython.generics.complete_object.when_type(LeoWorkbook)
+def workbook_complete(obj, prev):
+    return all_cells().keys()
+    
+
+def add_var(varname, value = _dummyval):
+    nodename = '@ipy-var ' + varname
+    p2 = g.findNodeAnywhere(c,nodename)
+    if not c.positionExists(p2):
+        p2 = c.currentPosition().insertAfter()
+        c.setHeadString(p2,'@ipy ' + varname)
+        
+    c.setCurrentPosition(p2)
+    if value is _dummyval:
+        val = ip.user_ns[varname]
+    else:
+        val = value
+    if val is not None:
+        formatted = format_for_leo(val)
+        c.setBodyString(p2,formatted)
+    return p2
+
+def add_file(self,fname):
+    p2 = c.currentPosition().insertAfter()
+
+def push_script(p):
+    ohist = ip.IP.output_hist 
+    hstart = len(ip.IP.input_hist)
+    script = g.getScript(c,p,useSelectedText=False,forcePythonSentinels=False,useSentinels=False)
+    
+    script = g.splitLines(script + '\n')
+    script = ''.join(z for z in script if z.strip())
+    
+    ip.runlines(script)
+    
+    has_output = False
+    for idx in range(hstart,len(ip.IP.input_hist)):
+        val = ohist.get(idx,None)
+        if val is None:
+            continue
+        has_output = True
+        inp = ip.IP.input_hist[idx]
+        if inp.strip():
+            g.es('In: %s' % (inp[:40], ),  tabName = 'IPython')
+            
+        g.es('<%d> %s' % (idx, pprint.pformat(ohist[idx],width = 40)), tabName = 'IPython')
+    
+    if not has_output:
+        g.es('ipy run: %s' %( p.headString(),), tabName = 'IPython')
+    
+    
+def eval_body(body):
+    try:
+        val = ip.ev(body)
+    except:
+        # just use stringlist if it's not completely legal python expression
+        val = IPython.genutils.SList(body.splitlines())
+    return val 
+    
+def push_variable(p,varname):
+    body = p.bodyString()
+    val = eval_body(body.strip())
+    ip.user_ns[varname] = val
+    g.es('ipy var: %s' % (varname,), tabName = "IPython")
+    
+def push_from_leo(p):
+    # headstring without @ are just scripts
+    if not p.headString().startswith('@'):
+        push_script(p)
+        return
+    tup = p.headString().split(None,1)
+    # @ipy foo is variable foo
+    if len(tup) == 2 and tup[0] == '@ipy':
+        varname = tup[1]
+        push_variable(p,varname)
+        return
+    
+ip.user_ns['leox'].push = push_from_leo    
+    
+def leo_f(self,s):
+    ip = self.getapi()
+    s = s.strip()
+    if s in ip.user_ns:
+        add_var(s)
+    elif os.path.isfile(s):
+        # todo open file
+        pass
+
+ip.expose_magic('leo',leo_f)
diff --git a/IPython/Extensions/ipy_p4.py b/IPython/Extensions/ipy_p4.py
new file mode 100644
index 0000000..448ce2a
--- /dev/null
+++ b/IPython/Extensions/ipy_p4.py
@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+"""
+Add %p4 magic for pythonic p4 (Perforce) usage.
+"""
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import os,sys,marshal
+
+import ipy_stock_completers
+
+def p4_f(self, parameter_s=''):
+    cmd = 'p4 -G ' + parameter_s
+    fobj = os.popen(cmd)
+    out = []
+    while 1:
+        try:
+            out.append(marshal.load(fobj))
+        except EOFError:
+            break
+        
+    return out
+
+def p4d(fname):
+    return os.popen('p4 where ' + fname).read().split()[0]
+    
+ip.to_user_ns("p4d")
+
+ip.expose_magic('p4', p4_f)
+
+p4_commands = """\
+add admin annotate branch branches change changes changelist
+changelists client clients counter counters delete depot depots
+describe diff diff2 dirs edit filelog files fix fixes flush fstat
+group groups have help info integrate integrated job jobs jobspec
+label labels labelsync lock logger login logout monitor obliterate
+opened passwd print protect rename reopen resolve resolved revert
+review reviews set submit sync tag tickets triggers typemap unlock
+user users verify workspace workspaces where"""
+    
+def p4_completer(self,event):
+    return ipy_stock_completers.vcs_completer(p4_commands, event)
+
+ip.set_hook('complete_command', p4_completer, str_key = '%p4')
+ip.set_hook('complete_command', p4_completer, str_key = 'p4')
+
diff --git a/IPython/Extensions/ipy_profile_doctest.py b/IPython/Extensions/ipy_profile_doctest.py
new file mode 100644
index 0000000..b35074e
--- /dev/null
+++ b/IPython/Extensions/ipy_profile_doctest.py
@@ -0,0 +1,46 @@
+"""Config file for 'doctest' profile.
+
+This profile modifies the prompts to be the standard Python ones, so that you
+can generate easily doctests from an IPython session.
+
+But more importantly, it enables pasting of code with '>>>' prompts and
+arbitrary initial whitespace, as is typical of doctests in reST files and
+docstrings.  This allows you to easily re-run existing doctests and iteratively
+work on them as part of your development workflow.
+
+The exception mode is also set to 'plain' so the generated exceptions are as
+similar as possible to the default Python ones, for inclusion in doctests."""
+
+# get various stuff that are there for historical / familiarity reasons
+import ipy_legacy
+
+from  IPython import ipapi
+
+from IPython.Extensions import InterpreterPasteInput
+
+def main():    
+    ip = ipapi.get()
+    o = ip.options
+
+    # Set the prompts similar to the defaults
+    o.prompt_in1 = '>>> '
+    o.prompt_in2 = '... '
+    o.prompt_out = ''
+
+    # Add a blank line before each new set of inputs.  This is needed by
+    # doctest to distinguish each test from the next.
+    o.separate_in = '\n'
+    o.separate_out = ''
+    o.separate_out2 = ''
+
+    # Disable pprint, so that outputs are printed as similarly to standard
+    # python as possible
+    o.pprint = False
+    
+    # Use plain exceptions, to also resemble normal pyhton.
+    o.xmode = 'plain'
+
+    # Store the activity flag in the metadata bag from the running shell
+    ip.IP.meta.doctest_mode = True
+
+main()
diff --git a/IPython/Extensions/ipy_profile_none.py b/IPython/Extensions/ipy_profile_none.py
new file mode 100644
index 0000000..195aa87
--- /dev/null
+++ b/IPython/Extensions/ipy_profile_none.py
@@ -0,0 +1,4 @@
+""" Config file for 'default' profile """
+
+# get various stuff that are there for historical / familiarity reasons
+import ipy_legacy
\ No newline at end of file
diff --git a/IPython/Extensions/ipy_profile_scipy.py b/IPython/Extensions/ipy_profile_scipy.py
new file mode 100644
index 0000000..7c929c2
--- /dev/null
+++ b/IPython/Extensions/ipy_profile_scipy.py
@@ -0,0 +1,25 @@
+""" IPython 'sci' profile
+
+Replaces the old scipy profile.
+
+"""
+
+
+import IPython.ipapi
+import ipy_defaults
+
+def main():
+    ip = IPython.ipapi.get()
+
+    try:
+        ip.ex("import numpy")
+        ip.ex("import scipy")
+        
+        ip.ex("from numpy import *")
+        ip.ex("from scipy import *")
+        print "SciPy profile successfully loaded."
+    except ImportError:
+        print "Unable to start scipy profile, are scipy and numpy installed?"
+    
+
+main()
diff --git a/IPython/Extensions/ipy_profile_sh.py b/IPython/Extensions/ipy_profile_sh.py
new file mode 100644
index 0000000..adf2b81
--- /dev/null
+++ b/IPython/Extensions/ipy_profile_sh.py
@@ -0,0 +1,226 @@
+"""Shell mode for IPython.
+
+Start ipython in shell mode by invoking "ipython -p sh"
+
+(the old version, "ipython -p pysh" still works but this is the more "modern" 
+shell mode and is recommended for users who don't care about pysh-mode
+compatibility)
+"""
+
+from IPython import ipapi
+import os,textwrap
+
+# The import below effectively obsoletes your old-style ipythonrc[.ini],
+# so consider yourself warned!
+
+import ipy_defaults
+
+def main():    
+    ip = ipapi.get()
+    o = ip.options
+    # autocall to "full" mode (smart mode is default, I like full mode)
+    
+    o.autocall = 2
+    
+    # Jason Orendorff's path class is handy to have in user namespace
+    # if you are doing shell-like stuff
+    try:
+        ip.ex("from IPython.external.path import path" )
+    except ImportError:
+        pass
+    
+    # beefed up %env is handy in shell mode
+    import envpersist
+    
+    # To see where mycmd resides (in path/aliases), do %which mycmd 
+    import ipy_which
+    
+    # tab completers for hg, svn, ...
+    import ipy_app_completers
+    
+    # To make executables foo and bar in mybin usable without PATH change, do:
+    # %rehashdir c:/mybin
+    # %store foo
+    # %store bar
+    import ipy_rehashdir
+    import ipy_signals
+    
+    ip.ex('import os')
+    ip.ex("def up(): os.chdir('..')")
+        
+    # Nice prompt
+    
+    o.prompt_in1= r'\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Green|\#> '
+    o.prompt_in2= r'\C_Green|\C_LightGreen\D\C_Green> '
+    o.prompt_out= '<\#> '
+    
+    from IPython import Release
+
+    import sys
+    # Non-chatty banner
+    o.banner = "IPython %s   [on Py %s]\n" % (Release.version,sys.version.split(None,1)[0])
+    
+    
+    ip.IP.default_option('cd','-q')
+    ip.IP.default_option('macro', '-r')
+    # If you only rarely want to execute the things you %edit...  
+    #ip.IP.default_option('edit','-x')
+    
+
+    o.prompts_pad_left="1"
+    # Remove all blank lines in between prompts, like a normal shell.
+    o.separate_in="0"
+    o.separate_out="0"
+    o.separate_out2="0"
+    
+    # now alias all syscommands
+    
+    db = ip.db
+    
+    syscmds = db.get("syscmdlist",[] )
+    if not syscmds:
+        print textwrap.dedent("""
+        System command list not initialized, probably the first run...
+        running %rehashx to refresh the command list. Run %rehashx
+        again to refresh command list (after installing new software etc.)
+        """)
+        ip.magic('rehashx')
+        syscmds = db.get("syscmdlist")
+    
+    # lowcase aliases on win32 only
+    if os.name == 'posix':
+        mapper = lambda s:s
+    else:
+        def mapper(s): return s.lower()
+        
+    for cmd in syscmds:
+        # print "sys",cmd #dbg
+        noext, ext = os.path.splitext(cmd)
+        key = mapper(noext)
+        if key not in ip.IP.alias_table:
+            ip.defalias(key, cmd)
+
+    # mglob combines 'find', recursion, exclusion... '%mglob?' to learn more
+    ip.load("IPython.external.mglob")    
+
+    # win32 is crippled w/o cygwin, try to help it a little bit
+    if sys.platform == 'win32':
+        if 'cygwin' in os.environ['PATH'].lower():          
+            # use the colors of cygwin ls (recommended)
+            ip.defalias('d', 'ls -F --color=auto')
+        else:
+            # get icp, imv, imkdir, igrep, irm,...
+            ip.load('ipy_fsops')
+            
+            # and the next best thing to real 'ls -F'
+            ip.defalias('d','dir /w /og /on')
+    
+    extend_shell_behavior(ip)
+
+# XXX You do not need to understand the next function!
+# This should probably be moved out of profile
+
+def extend_shell_behavior(ip):
+
+    # Instead of making signature a global variable tie it to IPSHELL.
+    # In future if it is required to distinguish between different
+    # shells we can assign a signature per shell basis
+    ip.IP.__sig__ = 0xa005
+    # mark the IPSHELL with this signature
+    ip.IP.user_ns['__builtins__'].__dict__['__sig__'] = ip.IP.__sig__
+
+    from IPython.Itpl import ItplNS
+    from IPython.genutils import shell
+    # utility to expand user variables via Itpl
+    # xxx do something sensible with depth?
+    ip.IP.var_expand = lambda cmd, lvars=None, depth=2: \
+        str(ItplNS(cmd, ip.IP.user_ns, get_locals()))
+
+    def get_locals():
+        """ Substituting a variable through Itpl deep inside the IPSHELL stack
+            requires the knowledge of all the variables in scope upto the last
+            IPSHELL frame. This routine simply merges all the local variables
+            on the IPSHELL stack without worrying about their scope rules
+        """
+        import sys
+        # note lambda expression constitues a function call
+        # hence fno should be incremented by one
+        getsig = lambda fno: sys._getframe(fno+1).f_globals \
+                             ['__builtins__'].__dict__['__sig__']
+        getlvars = lambda fno: sys._getframe(fno+1).f_locals
+        # trackback until we enter the IPSHELL
+        frame_no = 1
+        sig = ip.IP.__sig__
+        fsig = ~sig
+        while fsig != sig :
+            try:
+                fsig = getsig(frame_no)
+            except (AttributeError, KeyError):
+                frame_no += 1
+            except ValueError:
+                # stack is depleted
+                # call did not originate from IPSHELL
+                return {}
+        first_frame = frame_no
+        # walk further back until we exit from IPSHELL or deplete stack
+        try:
+            while(sig == getsig(frame_no+1)):
+                frame_no += 1
+        except (AttributeError, KeyError, ValueError):
+            pass
+        # merge the locals from top down hence overriding
+        # any re-definitions of variables, functions etc.
+        lvars = {}
+        for fno in range(frame_no, first_frame-1, -1):
+            lvars.update(getlvars(fno))
+        #print '\n'*5, first_frame, frame_no, '\n', lvars, '\n'*5 #dbg
+        return lvars
+
+    def _runlines(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).
+        ip.IP.resetbuffer()
+        lines = lines.split('\n')
+        more = 0
+        command = ''
+        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 command is not empty trim the line
+            if command != '' :
+                line = line.strip()
+            # add the broken line to the command
+            if line and line[-1] == '\\' :
+                command += line[0:-1] + ' '
+                more = True
+                continue
+            else :
+                # add the last (current) line to the command
+                command += line
+                if command or more:
+                    # push to raw history, so hist line numbers stay in sync
+                    ip.IP.input_hist_raw.append("# " + command + "\n")
+                    
+                    more = ip.IP.push(ip.IP.prefilter(command,more))
+                    command = ''
+                    # 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:
+            ip.IP.push('\n')
+
+    ip.IP.runlines = _runlines
+
+main()
diff --git a/IPython/Extensions/ipy_profile_zope.py b/IPython/Extensions/ipy_profile_zope.py
new file mode 100644
index 0000000..3c812f0
--- /dev/null
+++ b/IPython/Extensions/ipy_profile_zope.py
@@ -0,0 +1,317 @@
+# -*- coding: utf-8 -*-
+#
+# File: ipy_profile_zope.py
+#
+# Copyright (c) InQuant GmbH
+#
+# An ipython profile for zope and plone. Some ideas
+# stolen from http://www.tomster.org.
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+
+__author__ = """Stefan Eletzhofer <stefan.eletzhofer@inquant.de>"""
+__docformat__ = 'plaintext'
+__revision__ = "$Revision$"
+
+from IPython import ipapi
+from IPython import Release
+from types import StringType
+import sys
+import os
+import textwrap
+
+# The import below effectively obsoletes your old-style ipythonrc[.ini],
+# so consider yourself warned!
+# import ipy_defaults
+
+_marker = []
+def shasattr(obj, attr, acquire=False):
+    """ See Archetypes/utils.py
+    """
+    if not acquire:
+        obj = obj.aq_base
+    return getattr(obj, attr, _marker) is not _marker
+
+class ZopeDebug(object):
+    def __init__(self):
+
+        self.instancehome = os.environ.get( "INSTANCE_HOME" )
+
+        configfile = os.environ.get( "CONFIG_FILE" )
+        if configfile is None and self.instancehome is not None:
+            configfile = os.path.join( self.instancehome, "etc", "zope.conf" )
+
+        if configfile is None:
+            raise RuntimeError( "CONFIG_FILE env not set" )
+
+        print "CONFIG_FILE=", configfile
+        print "INSTANCE_HOME=", self.instancehome
+
+        self.configfile = configfile
+
+        try:
+            from Zope2 import configure
+        except ImportError:
+            from Zope import configure
+
+        configure( configfile )
+
+        try:
+            import Zope2
+            app = Zope2.app()
+        except ImportError:
+            import Zope
+            app = Zope.app()
+
+        from Testing.makerequest import makerequest
+        self.app = makerequest( app )
+
+        try:
+            self._make_permissive()
+            print "Permissive security installed"
+        except:
+            print "Permissive security NOT installed"
+
+        self._pwd = self.portal or self.app
+
+        try:
+            from zope.component import getSiteManager
+            from zope.component import getGlobalSiteManager
+            from zope.app.component.hooks import setSite
+
+            if self.portal is not None:
+                setSite( self.portal )
+
+                gsm = getGlobalSiteManager()
+                sm = getSiteManager()
+
+                if sm is gsm:
+                    print "ERROR SETTING SITE!"
+        except:
+            pass
+
+
+    @property
+    def utils(self):
+        class Utils(object):
+            commit = self.commit
+            sync = self.sync
+            objectInfo = self.objectInfo
+            ls = self.ls
+            pwd = self.pwd
+            cd = self.cd
+            su = self.su
+            getCatalogInfo = self.getCatalogInfo
+
+            @property
+            def cwd(self):
+                return self.pwd()
+
+        return Utils()
+
+    @property
+    def namespace(self):
+        return dict( utils=self.utils, app=self.app, portal=self.portal )
+
+    @property
+    def portal(self):
+        portals = self.app.objectValues( "Plone Site" )
+        if len(portals):
+            return portals[0]
+        else:
+            raise KeyError( "No Plone Site found.")
+
+    def pwd(self):
+        return self._pwd
+
+    def _make_permissive(self):
+        """
+        Make a permissive security manager with all rights. Hell,
+        we're developers, aren't we? Security is for whimps. :)
+        """
+        from Products.CMFCore.tests.base.security import PermissiveSecurityPolicy
+        import AccessControl
+        from AccessControl.SecurityManagement import newSecurityManager
+        from AccessControl.SecurityManager import setSecurityPolicy
+
+        _policy = PermissiveSecurityPolicy()
+        self.oldpolicy = setSecurityPolicy(_policy)
+        newSecurityManager(None, AccessControl.User.system)
+
+    def su(self, username):
+        """ Change to named user.
+        """
+        # TODO Make it easy to change back to permissive security.
+        user = self.portal.acl_users.getUser(username)
+        if not user:
+            print "Can't find %s in %s" % (username, self.portal.acl_users)
+            return
+
+        from AccessControl import ZopeSecurityPolicy
+        import AccessControl
+        from AccessControl.SecurityManagement import newSecurityManager, getSecurityManager
+        from AccessControl.SecurityManager import setSecurityPolicy
+
+        _policy = ZopeSecurityPolicy
+        self.oldpolicy = setSecurityPolicy(_policy)
+        wrapped_user = user.__of__(self.portal.acl_users)
+        newSecurityManager(None, user)
+        print 'User changed.'
+        return getSecurityManager().getUser()
+
+    def getCatalogInfo(self, obj=None, catalog='portal_catalog', query=None, sort_on='created', sort_order='reverse' ):
+        """ Inspect portal_catalog. Pass an object or object id for a
+        default query on that object, or pass an explicit query.
+        """
+        if obj and query:
+            print "Ignoring %s, using query." % obj
+
+        catalog = self.portal.get(catalog)
+        if not catalog:
+            return 'No catalog'
+
+        indexes = catalog._catalog.indexes
+        if not query:
+            if type(obj) is StringType:
+                cwd = self.pwd()
+                obj = cwd.unrestrictedTraverse( obj )
+            # If the default in the signature is mutable, its value will
+            # persist across invocations.
+            query = {}
+            if indexes.get('path'):
+                from string import join
+                path = join(obj.getPhysicalPath(), '/') 
+                query.update({'path': path})
+            if indexes.get('getID'):
+                query.update({'getID': obj.id, })
+            if indexes.get('UID') and shasattr(obj, 'UID'):
+                query.update({'UID': obj.UID(), })
+        if indexes.get(sort_on):
+            query.update({'sort_on': sort_on, 'sort_order': sort_order})
+        if not query:
+            return 'Empty query'
+        results = catalog(**query)
+
+        result_info = []
+        for r in results:
+            rid = r.getRID()
+            if rid:
+                result_info.append(
+                        {'path': catalog.getpath(rid),
+                        'metadata': catalog.getMetadataForRID(rid),
+                        'indexes': catalog.getIndexDataForRID(rid), }
+                        )
+            else:
+                result_info.append({'missing': rid})
+
+        if len(result_info) == 1:
+            return result_info[0]
+        return result_info
+
+    def commit(self):
+        """
+        Commit the transaction.
+        """
+        try:
+            import transaction
+            transaction.get().commit()
+        except ImportError:
+            get_transaction().commit()
+
+    def sync(self):
+        """
+        Sync the app's view of the zodb.
+        """
+        self.app._p_jar.sync()
+
+    def objectInfo( self, o ):
+        """
+        Return a descriptive string of an object
+        """
+        Title = ""
+        t = getattr( o, 'Title', None )
+        if t:
+            Title = t()
+        return {'id': o.getId(),
+                'Title': Title,
+                'portal_type': getattr( o, 'portal_type', o.meta_type),
+                'folderish': o.isPrincipiaFolderish
+                }
+
+    def cd( self, path ):
+        """
+        Change current dir to a specific folder.
+
+         cd( ".." )
+         cd( "/plone/Members/admin" )
+         cd( portal.Members.admin )
+         etc.
+        """
+        if type(path) is not StringType:
+            path = '/'.join(path.getPhysicalPath())
+        cwd = self.pwd()
+        x = cwd.unrestrictedTraverse( path )
+        if x is None:
+            raise KeyError( "Can't cd to %s" % path )
+
+        print "%s -> %s" % ( self.pwd().getId(), x.getId() )
+        self._pwd = x
+
+    def ls( self, x=None ):
+        """
+        List object(s)
+        """
+        if type(x) is StringType:
+            cwd = self.pwd()
+            x = cwd.unrestrictedTraverse( x )
+        if x is None:
+            x = self.pwd()
+        if x.isPrincipiaFolderish:
+            return [self.objectInfo(o) for id, o in x.objectItems()]
+        else:
+            return self.objectInfo( x )
+
+zope_debug = None
+
+def ipy_set_trace():
+    import IPython; IPython.Debugger.Pdb().set_trace()
+
+def main():
+    global zope_debug
+    ip = ipapi.get()
+    o = ip.options
+    # autocall to "full" mode (smart mode is default, I like full mode)
+    
+    SOFTWARE_HOME = os.environ.get( "SOFTWARE_HOME" )
+    sys.path.append( SOFTWARE_HOME )
+    print "SOFTWARE_HOME=%s\n" % SOFTWARE_HOME
+
+    zope_debug = ZopeDebug()
+
+    # <HACK ALERT>
+    import pdb;
+    pdb.set_trace = ipy_set_trace
+    # </HACK ALERT>
+
+    # I like my banner minimal.
+    o.banner = "ZOPE Py %s IPy %s\n" % (sys.version.split('\n')[0],Release.version)
+
+    print textwrap.dedent("""\
+        ZOPE mode iPython shell.
+
+          Bound names:
+           app
+           portal
+           utils.{ %s }
+  
+        Uses the $SOFTWARE_HOME and $CONFIG_FILE environment
+        variables.
+        """ % ( ",".join([ x for x in dir(zope_debug.utils) if not x.startswith("_") ] ) ) )
+
+
+    ip.user_ns.update( zope_debug.namespace )
+
+
+main()
+# vim: set ft=python ts=4 sw=4 expandtab :
diff --git a/IPython/Extensions/ipy_pydb.py b/IPython/Extensions/ipy_pydb.py
new file mode 100644
index 0000000..ee30523
--- /dev/null
+++ b/IPython/Extensions/ipy_pydb.py
@@ -0,0 +1,31 @@
+import inspect
+import IPython.ipapi
+from IPython.genutils import arg_split
+ip = IPython.ipapi.get()
+
+from IPython import Debugger
+
+def call_pydb(self, args):
+    """Invoke pydb with the supplied parameters."""
+    try:
+        import pydb
+    except ImportError:
+        raise ImportError("pydb doesn't seem to be installed.")
+
+    if not hasattr(pydb.pydb, "runv"):
+        raise ImportError("You need pydb version 1.19 or later installed.")
+
+    argl = arg_split(args)
+    # print argl # dbg
+    if len(inspect.getargspec(pydb.runv)[0]) == 2:
+        pdb = Debugger.Pdb(color_scheme=self.rc.colors)
+        ip.IP.history_saving_wrapper( lambda : pydb.runv(argl, pdb) )()
+    else:
+        ip.IP.history_saving_wrapper( lambda : pydb.runv(argl) )()
+
+    
+ip.expose_magic("pydb",call_pydb)    
+
+    
+    
+    
diff --git a/IPython/Extensions/ipy_rehashdir.py b/IPython/Extensions/ipy_rehashdir.py
new file mode 100644
index 0000000..15abcec
--- /dev/null
+++ b/IPython/Extensions/ipy_rehashdir.py
@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+""" IPython extension: add %rehashdir magic
+
+Usage:
+
+%rehashdir c:/bin c:/tools
+  - Add all executables under c:/bin and c:/tools to alias table, in 
+  order to make them directly executable from any directory.
+  
+This also serves as an example on how to extend ipython
+with new magic functions.
+
+Unlike rest of ipython, this requires Python 2.4 (optional
+extensions are allowed to do that).
+
+"""
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+
+import os,re,fnmatch,sys
+
+def selflaunch(ip,line):
+    """ Launch python script with 'this' interpreter
+    
+    e.g. d:\foo\ipykit.exe a.py
+    
+    """
+    
+    tup = line.split(None,1)
+    if len(tup) == 1:
+        print "Launching nested ipython session"
+        os.system(sys.executable)
+        return
+        
+    cmd = sys.executable + ' ' + tup[1]
+    print ">",cmd
+    os.system(cmd)
+
+class PyLauncher:
+    """ Invoke selflanucher on the specified script
+    
+    This is mostly useful for associating with scripts using::
+        _ip.defalias('foo',PyLauncher('foo_script.py'))
+    
+    """
+    def __init__(self,script):
+        self.script = os.path.abspath(script)
+    def __call__(self, ip, line):
+        if self.script.endswith('.ipy'):
+            ip.runlines(open(self.script).read())
+        else:
+            # first word is the script/alias name itself, strip it
+            tup = line.split(None,1)
+            if len(tup) == 2:
+                tail = ' ' + tup[1]
+            else:
+                tail = ''
+                
+            selflaunch(ip,"py " + self.script + tail)
+    def __repr__(self):
+        return 'PyLauncher("%s")' % self.script
+
+def rehashdir_f(self,arg):
+    """ Add executables in all specified dirs to alias table
+     
+    Usage:
+
+    %rehashdir c:/bin;c:/tools
+      - Add all executables under c:/bin and c:/tools to alias table, in 
+      order to make them directly executable from any directory.
+        
+      Without arguments, add all executables in current directory.
+      
+    """
+
+    # most of the code copied from Magic.magic_rehashx
+
+    def isjunk(fname):
+        junk = ['*~']
+        for j in junk:
+            if fnmatch.fnmatch(fname, j):
+                return True
+        return False
+    
+    created = []
+    if not arg:
+        arg = '.'
+    path = map(os.path.abspath,arg.split(';'))
+    alias_table = self.shell.alias_table
+        
+    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|py'
+        if 'py' not in winext:
+            winext += '|py'
+            
+        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 not isjunk(ff):
+                        # each entry in the alias table must be (N,name),
+                        # where N is the number of positional arguments of the
+                        # alias.
+                        src,tgt = os.path.splitext(ff)[0], os.path.abspath(ff)
+                        created.append(src)                        
+                        alias_table[src] = (0,tgt)
+        else:
+            for pdir in path:
+                os.chdir(pdir)
+                for ff in os.listdir(pdir):
+                    if isexec(ff) and not isjunk(ff):
+                        src, tgt = execre.sub(r'\1',ff), os.path.abspath(ff)
+                        src = src.lower()
+                        created.append(src)                                                
+                        alias_table[src] = (0,tgt)
+        # 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()
+    finally:
+        os.chdir(savedir)
+    return created
+
+ip.expose_magic("rehashdir",rehashdir_f)
diff --git a/IPython/Extensions/ipy_render.py b/IPython/Extensions/ipy_render.py
new file mode 100644
index 0000000..3946a87
--- /dev/null
+++ b/IPython/Extensions/ipy_render.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+
+""" IPython extension: Render templates from variables and paste to clipbard """
+
+import IPython.ipapi
+
+ip = IPython.ipapi.get()
+
+from string import Template
+import sys,os
+
+from IPython.Itpl import itplns
+
+def toclip_w32(s):
+    """ Places contents of s to clipboard
+    
+    Needs pyvin32 to work:
+    http://sourceforge.net/projects/pywin32/
+    """
+    import win32clipboard as cl
+    import win32con
+    cl.OpenClipboard()
+    cl.EmptyClipboard()
+    cl.SetClipboardText( s.replace('\n','\r\n' ))
+    cl.CloseClipboard()
+
+try:
+    import win32clipboard    
+    toclip = toclip_w32
+except ImportError:
+    def toclip(s): pass
+    
+
+def render(tmpl):
+    """ Render a template (Itpl format) from ipython variables
+
+    Example:
+    
+    $ import ipy_render
+    $ my_name = 'Bob'  # %store this for convenience
+    $ t_submission_form = "Submission report, author: $my_name"  # %store also
+    $ render t_submission_form
+    
+    => returns "Submission report, author: Bob" and copies to clipboard on win32
+
+    # if template exist as a file, read it. Note: ;f hei vaan => f("hei vaan")
+    $ ;render c:/templates/greeting.txt  
+    
+    Template examples (Ka-Ping Yee's Itpl library):
+    
+    Here is a $string.
+    Here is a $module.member.
+    Here is an $object.member.
+    Here is a $functioncall(with, arguments).
+    Here is an ${arbitrary + expression}.
+    Here is an $array[3] member.
+    Here is a $dictionary['member'].
+    """
+    
+    if os.path.isfile(tmpl):
+        tmpl = open(tmpl).read()
+        
+    res = itplns(tmpl, ip.user_ns)
+    toclip(res)
+    return res
+
+ip.to_user_ns('render')
+    
\ No newline at end of file
diff --git a/IPython/Extensions/ipy_server.py b/IPython/Extensions/ipy_server.py
new file mode 100644
index 0000000..cd4c55b
--- /dev/null
+++ b/IPython/Extensions/ipy_server.py
@@ -0,0 +1,38 @@
+""" Simple TCP socket server that executes statements in IPython instance.
+
+Usage:
+
+import ipy_server
+ipy_server.serve_thread(16455)
+
+Now, to execute the statements in this ipython instance, open a TCP socket
+(port 16455), write out the statements, and close the socket. 
+You can use e.g. "telnet localhost 16455" or a script to do this.
+
+This is a bit like 'M-x server-start" or gnuserv in the emacs world.
+
+"""
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import SocketServer
+
+# user-accessible port
+PORT = 8099
+
+class IPythonRequestHandler(SocketServer.StreamRequestHandler):
+    def handle(self):
+        #print "connection from", self.client_address
+        inp = self.rfile.read().replace('\r\n','\n')
+        #print "Execute",inp
+        ip.runlines(inp)
+
+def serve(port = PORT):
+    server = SocketServer.TCPServer(("", port), IPythonRequestHandler)
+    print "ipy_server on TCP port", port
+    server.serve_forever()
+
+def serve_thread(port = PORT):
+    import thread
+    thread.start_new_thread(serve, (port,))
\ No newline at end of file
diff --git a/IPython/Extensions/ipy_signals.py b/IPython/Extensions/ipy_signals.py
new file mode 100644
index 0000000..8debc62
--- /dev/null
+++ b/IPython/Extensions/ipy_signals.py
@@ -0,0 +1,62 @@
+""" Advanced signal (e.g. ctrl+C) handling for IPython
+
+So far, this only ignores ctrl + C in IPython file a subprocess
+is executing, to get closer to how a "proper" shell behaves.
+
+Other signal processing may be implemented later on.
+
+If _ip.options.verbose is true, show exit status if nonzero
+
+"""
+
+import signal,os,sys
+import IPython.ipapi
+import subprocess
+
+ip = IPython.ipapi.get()
+
+def new_ipsystem_posix(cmd):
+    """ ctrl+c ignoring replacement for system() command in iplib.
+    
+    Ignore ctrl + c in IPython process during the command execution. 
+    The subprocess will still get the ctrl + c signal.
+    
+    posix implementation
+    """
+    
+    p =  subprocess.Popen(cmd, shell = True)
+    
+    old_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
+    pid,status = os.waitpid(p.pid,0)
+    signal.signal(signal.SIGINT, old_handler)
+    if status and ip.options.verbose:
+        print "[exit status: %d]" % status
+    
+def new_ipsystem_win32(cmd):    
+    """ ctrl+c ignoring replacement for system() command in iplib.
+    
+    Ignore ctrl + c in IPython process during the command execution. 
+    The subprocess will still get the ctrl + c signal.
+    
+    win32 implementation
+    """
+    old_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
+    status = os.system(cmd)
+    signal.signal(signal.SIGINT, old_handler)
+    if status and ip.options.verbose:
+        print "[exit status: %d]" % status
+    
+    
+def init():
+    o = ip.options
+    try:
+        o.verbose
+    except AttributeError:
+        o.allow_new_attr (True )
+        o.verbose = 0
+        
+    ip.IP.system = (sys.platform == 'win32' and new_ipsystem_win32 or 
+                    new_ipsystem_posix)
+    
+init()
+    
\ No newline at end of file
diff --git a/IPython/Extensions/ipy_stock_completers.py b/IPython/Extensions/ipy_stock_completers.py
new file mode 100644
index 0000000..2714e0b
--- /dev/null
+++ b/IPython/Extensions/ipy_stock_completers.py
@@ -0,0 +1,17 @@
+""" Install various IPython completers
+
+IPython extension that installs completers related to core ipython behaviour.
+
+The actual implementations are in Extensions/ipy_completers.py
+
+"""
+import IPython.ipapi
+
+ip = IPython.ipapi.get()
+
+from ipy_completers import *
+
+ip.set_hook('complete_command', module_completer, str_key = 'import')
+ip.set_hook('complete_command', module_completer, str_key = 'from')
+ip.set_hook('complete_command', runlistpy, str_key = '%run')
+ip.set_hook('complete_command', cd_completer, str_key = '%cd')
diff --git a/IPython/Extensions/ipy_system_conf.py b/IPython/Extensions/ipy_system_conf.py
new file mode 100644
index 0000000..027594d
--- /dev/null
+++ b/IPython/Extensions/ipy_system_conf.py
@@ -0,0 +1,24 @@
+""" System wide configuration file for IPython.
+
+This will be imported by ipython for all users.
+
+After this ipy_user_conf.py is imported, user specific configuration
+should reside there. 
+
+ """
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+# add system wide configuration information, import extensions etc. here.
+# nothing here is essential 
+
+import sys
+
+import ext_rescapture # var = !ls and var = %magic
+import pspersistence # %store magic
+import clearcmd # %clear
+
+import ipy_stock_completers
+
+ip.load('IPython.history')
diff --git a/IPython/Extensions/ipy_traits_completer.py b/IPython/Extensions/ipy_traits_completer.py
new file mode 100644
index 0000000..6d3e6f7
--- /dev/null
+++ b/IPython/Extensions/ipy_traits_completer.py
@@ -0,0 +1,184 @@
+"""Traits-aware tab completion.
+
+This module provides a custom tab-completer that intelligently hides the names
+that the enthought.traits library (http://code.enthought.com/traits)
+automatically adds to all objects that inherit from its base HasTraits class.
+
+
+Activation
+==========
+
+To use this, put in your ~/.ipython/ipy_user_conf.py file:
+
+    from ipy_traits_completer import activate
+    activate([complete_threshold])
+
+The optional complete_threshold argument is the minimal length of text you need
+to type for tab-completion to list names that are automatically generated by
+traits.  The default value is 3.  Note that at runtime, you can change this
+value simply by doing:
+
+    import ipy_traits_completer
+    ipy_traits_completer.COMPLETE_THRESHOLD = 4
+
+
+Usage
+=====
+
+The system works as follows.  If t is an empty object that HasTraits, then
+(assuming the threshold is at the default value of 3):
+
+In [7]: t.ed<TAB>
+
+doesn't show anything at all, but:
+
+In [7]: t.edi<TAB>
+t.edit_traits      t.editable_traits
+
+shows these two names that come from traits.  This allows you to complete on
+the traits-specific names by typing at least 3 letters from them (or whatever
+you set your threshold to), but to otherwise not see them in normal completion.
+
+
+Notes
+=====
+
+  - This requires Python 2.4 to work (I use sets).  I don't think anyone is
+  using traits with 2.3 anyway, so that's OK.
+"""
+
+#############################################################################
+# External imports
+from enthought.traits import api as T
+
+# IPython imports
+from IPython.ipapi import TryNext, get as ipget
+from IPython.genutils import dir2
+try:
+    set
+except:
+    from sets import Set as set
+
+#############################################################################
+# Module constants
+
+# The completion threshold
+# This is currently implemented as a module global, since this sytem isn't
+# likely to be modified at runtime by multiple instances.  If needed in the
+# future, we can always make it local to the completer as a function attribute.
+COMPLETE_THRESHOLD = 3
+
+# Set of names that Traits automatically adds to ANY traits-inheriting object.
+# These are the names we'll filter out.
+TRAIT_NAMES = set( dir2(T.HasTraits()) ) - set( dir2(object()) )
+
+#############################################################################
+# Code begins
+
+def trait_completer(self,event):
+    """A custom IPython tab-completer that is traits-aware.
+
+    It tries to hide the internal traits attributes, and reveal them only when
+    it can reasonably guess that the user really is after one of them.
+    """
+    
+    #print '\nevent is:',event  # dbg
+    symbol_parts = event.symbol.split('.')
+    base = '.'.join(symbol_parts[:-1])
+    #print 'base:',base  # dbg
+
+    oinfo = self._ofind(base)
+    if not oinfo['found']:
+        raise TryNext
+
+    obj = oinfo['obj']
+    # OK, we got the object.  See if it's traits, else punt
+    if not isinstance(obj,T.HasTraits):
+        raise TryNext
+
+    # it's a traits object, don't show the tr* attributes unless the completion
+    # begins with 'tr'
+    attrs = dir2(obj)
+    # Now, filter out the attributes that start with the user's request
+    attr_start = symbol_parts[-1]
+    if attr_start:
+        attrs = [a for a in attrs if a.startswith(attr_start)]
+    
+    # Let's also respect the user's readline_omit__names setting:
+    omit__names = ipget().options.readline_omit__names
+    if omit__names == 1:
+        attrs = [a for a in attrs if not a.startswith('__')]
+    elif omit__names == 2:
+        attrs = [a for a in attrs if not a.startswith('_')]
+
+    #print '\nastart:<%r>' % attr_start  # dbg
+
+    if len(attr_start)<COMPLETE_THRESHOLD:
+        attrs = list(set(attrs) - TRAIT_NAMES)
+        
+    # The base of the completion, so we can form the final results list
+    bdot = base+'.'
+
+    tcomp = [bdot+a for a in attrs]
+    #print 'tcomp:',tcomp
+    return tcomp
+
+def activate(complete_threshold = COMPLETE_THRESHOLD):
+    """Activate the Traits completer.
+
+    :Keywords:
+      complete_threshold : int
+        The minimum number of letters that a user must type in order to
+      activate completion of traits-private names."""
+    
+    if not (isinstance(complete_threshold,int) and
+            complete_threshold>0):
+        e='complete_threshold must be a positive integer, not %r'  % \
+           complete_threshold
+        raise ValueError(e)
+
+    # Set the module global
+    global COMPLETE_THRESHOLD
+    COMPLETE_THRESHOLD = complete_threshold
+
+    # Activate the traits aware completer
+    ip = ipget()
+    ip.set_hook('complete_command', trait_completer, re_key = '.*')
+
+
+#############################################################################
+if __name__ == '__main__':
+    # Testing/debugging
+
+    # A sorted list of the names we'll filter out
+    TNL = list(TRAIT_NAMES)
+    TNL.sort()
+
+    # Make a few objects for testing
+    class TClean(T.HasTraits): pass
+    class Bunch(object): pass
+    # A clean traits object
+    t = TClean()
+    # A nested object containing t
+    f = Bunch()
+    f.t = t
+    # And a naked new-style object
+    o = object()
+
+    ip = ipget().IP
+    
+    # A few simplistic tests
+
+    # Reset the threshold to the default, in case the test is running inside an
+    # instance of ipython that changed it
+    import ipy_traits_completer
+    ipy_traits_completer.COMPLETE_THRESHOLD = 3
+
+    assert ip.complete('t.ed') ==[]
+
+    # For some bizarre reason, these fail on the first time I run them, but not
+    # afterwards.  Traits does some really weird stuff at object instantiation
+    # time...
+    ta = ip.complete('t.edi')
+    assert ta == ['t.edit_traits', 't.editable_traits']
+    print 'Tests OK'
diff --git a/IPython/Extensions/ipy_which.py b/IPython/Extensions/ipy_which.py
new file mode 100644
index 0000000..44bfae1
--- /dev/null
+++ b/IPython/Extensions/ipy_which.py
@@ -0,0 +1,76 @@
+r""" %which magic command
+
+%which <cmd> => search PATH for files matching PATH. Also scans aliases
+
+"""
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import os,sys
+from fnmatch import fnmatch
+def which(fname):
+    fullpath = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
+    
+    if '.' not in fullpath:
+        fullpath = ['.'] + fullpath
+    fn = fname
+    for p in fullpath:
+        for f in os.listdir(p):
+            head, ext = os.path.splitext(f)
+            if f == fn or fnmatch(head, fn):
+                yield os.path.join(p,f)
+    return
+
+def which_alias(fname):
+    for al, tgt in ip.IP.alias_table.items():
+        if not (al == fname or fnmatch(al, fname)):
+            continue
+        if callable(tgt):
+            print "Callable alias",tgt
+            d = tgt.__doc__
+            if d:
+                print "Docstring:\n",d
+                continue
+        trg = tgt[1]
+        
+        trans = ip.expand_alias(trg)
+        cmd = trans.split(None,1)[0]
+        print al,"->",trans
+        for realcmd in which(cmd):
+            print "  ==",realcmd
+        
+def which_f(self, arg):
+    r""" %which <cmd> => search PATH for files matching cmd. Also scans aliases.
+
+    Traverses PATH and prints all files (not just executables!) that match the
+    pattern on command line. Probably more useful in finding stuff
+    interactively than 'which', which only prints the first matching item.
+    
+    Also discovers and expands aliases, so you'll see what will be executed
+    when you call an alias.
+    
+    Example:
+    
+    [~]|62> %which d
+    d -> ls -F --color=auto
+      == c:\cygwin\bin\ls.exe
+    c:\cygwin\bin\d.exe
+    
+    [~]|64> %which diff*
+    diff3 -> diff3
+      == c:\cygwin\bin\diff3.exe
+    diff -> diff
+      == c:\cygwin\bin\diff.exe
+    c:\cygwin\bin\diff.exe
+    c:\cygwin\bin\diff3.exe
+
+    """
+    
+    which_alias(arg)
+
+    for e in which(arg):
+        print e
+    
+ip.expose_magic("which",which_f)        
+        
diff --git a/IPython/Extensions/ipy_workdir.py b/IPython/Extensions/ipy_workdir.py
new file mode 100644
index 0000000..e27b476
--- /dev/null
+++ b/IPython/Extensions/ipy_workdir.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import os, subprocess
+
+workdir = None
+def workdir_f(ip,line):
+    """ Exceute commands residing in cwd elsewhere 
+    
+    Example::
+      
+      workdir /myfiles
+      cd bin
+      workdir myscript.py 
+      
+    executes myscript.py (stored in bin, but not in path) in /myfiles
+    """
+    global workdir
+    dummy,cmd  = line.split(None,1)
+    if os.path.isdir(cmd):
+        workdir = os.path.abspath(cmd)
+        print "Set workdir",workdir
+    elif workdir is None:
+        print "Please set workdir first by doing e.g. 'workdir q:/'"
+    else:
+        sp = cmd.split(None,1)
+        if len(sp) == 1:
+            head, tail = cmd, ''
+        else:
+            head, tail = sp
+        if os.path.isfile(head):
+            cmd = os.path.abspath(head) + ' ' + tail
+        print "Execute command '" + cmd+ "' in",workdir
+        olddir = os.getcwd()
+        os.chdir(workdir)
+        try:
+            os.system(cmd)
+        finally:
+            os.chdir(olddir)
+
+ip.defalias("workdir",workdir_f)
diff --git a/IPython/Extensions/jobctrl.py b/IPython/Extensions/jobctrl.py
new file mode 100644
index 0000000..9f87121
--- /dev/null
+++ b/IPython/Extensions/jobctrl.py
@@ -0,0 +1,162 @@
+""" Preliminary "job control" extensions for IPython 
+
+requires python 2.4 (or separate 'subprocess' module
+
+This provides 2 features, launching background jobs and killing foreground jobs from another IPython instance.
+
+Launching background jobs:
+
+    Usage:
+
+    [ipython]|2> import jobctrl
+    [ipython]|3> &ls
+             <3> <jobctrl.IpyPopen object at 0x00D87FD0>
+    [ipython]|4> _3.go
+    -----------> _3.go()
+    ChangeLog
+    IPython
+    MANIFEST.in
+    README
+    README_Windows.txt
+
+    ...
+
+Killing foreground tasks:
+
+Launch IPython instance, run a blocking command:
+
+    [Q:/ipython]|1> import jobctrl
+    [Q:/ipython]|2> cat
+
+Now launch a new IPython prompt and kill the process:
+
+    IPython 0.8.3.svn.r2919   [on Py 2.5]
+    [Q:/ipython]|1> import jobctrl
+    [Q:/ipython]|2> %tasks
+    6020: 'cat ' (Q:\ipython)
+    [Q:/ipython]|3> %kill
+    SUCCESS: The process with PID 6020 has been terminated.
+    [Q:/ipython]|4>
+
+(you don't need to specify PID for %kill if only one task is running)
+"""                     
+
+from subprocess import Popen,PIPE
+import os,shlex,sys,time
+
+from IPython import genutils
+
+import IPython.ipapi
+
+if os.name == 'nt':
+    def kill_process(pid):
+        os.system('taskkill /F /PID %d' % pid)
+else:
+    def kill_process(pid):
+        os.system('kill -9 %d' % pid)
+    
+    
+
+class IpyPopen(Popen):
+    def go(self):
+        print self.communicate()[0]
+    def __repr__(self):
+        return '<IPython job "%s" PID=%d>' % (self.line, self.pid)
+
+    def kill(self):
+        kill_process(self.pid)
+                  
+def startjob(job):
+    p = IpyPopen(shlex.split(job), stdout=PIPE, shell = False)
+    p.line = job
+    return p
+
+def jobctrl_prefilter_f(self,line):    
+    if line.startswith('&'):
+        pre,fn,rest = self.split_user_input(line[1:])
+        
+        line = ip.IP.expand_aliases(fn,rest)
+        return '_ip.startjob(%s)' % genutils.make_quoted_expr(line)
+
+    raise IPython.ipapi.TryNext
+
+
+def job_list(ip):
+    keys = ip.db.keys('tasks/*')
+    ents = [ip.db[k] for k in keys]
+    return ents
+
+def magic_tasks(self,line):
+    """ Show a list of tasks.
+
+    A 'task' is a process that has been started in IPython when 'jobctrl' extension is enabled.
+    Tasks can be killed with %kill.
+    """
+    ip = self.getapi()
+    ents = job_list(ip)
+    if not ents:
+        print "No tasks running"
+    for pid,cmd,cwd,t in ents:
+        dur = int(time.time()-t)
+        print "%d: '%s' (%s) %d:%02d" % (pid,cmd,cwd, dur / 60,dur%60)
+
+def magic_kill(self,line):
+    """ Kill a task
+
+    Without args, either kill one task (if only one running) or show list (if many)
+    With arg, assume it's the process id.
+
+    %kill is typically (much) more powerful than trying to terminate a process with ctrl+C.
+    """
+    ip = self.getapi()
+    jobs  = job_list(ip)
+
+    if not line.strip():
+        if len(jobs) == 1:
+            kill_process(jobs[0][0])
+        else:
+            magic_tasks(self,line)
+        return
+        
+    try:
+        pid = int(line)
+        kill_process(pid)
+    except ValueError:
+        magic_tasks(self,line)
+        
+if sys.platform == 'win32':
+    shell_internal_commands = 'break chcp cls copy ctty date del erase dir md mkdir path prompt rd rmdir time 	type ver vol'.split()
+else:
+    # todo linux commands
+    shell_internal_commands = [] 
+
+
+def jobctrl_shellcmd(ip,cmd):
+    """ os.system replacement that stores process info to db['tasks/t1234'] """
+    cmdname = cmd.split(None,1)[0]
+    if cmdname in shell_internal_commands:
+        use_shell = True
+    else:
+        use_shell = False
+
+    p = Popen(cmd,shell = use_shell)
+    jobentry = 'tasks/t' + str(p.pid)
+    
+    try:
+        ip.db[jobentry] = (p.pid,cmd,os.getcwd(),time.time())
+        p.communicate()
+    finally:
+        del ip.db[jobentry]
+
+
+def install():
+    global ip
+    ip = IPython.ipapi.get()
+    # needed to make startjob visible as _ip.startjob('blah')
+    ip.startjob = startjob
+    ip.set_hook('input_prefilter', jobctrl_prefilter_f)
+    ip.set_hook('shell_hook', jobctrl_shellcmd)
+    ip.expose_magic('kill',magic_kill)
+    ip.expose_magic('tasks',magic_tasks)
+    
+install()
diff --git a/IPython/Extensions/ledit.py b/IPython/Extensions/ledit.py
new file mode 100644
index 0000000..87683b4
--- /dev/null
+++ b/IPython/Extensions/ledit.py
@@ -0,0 +1,98 @@
+""" Fun magic line editor for ipython 
+
+Use this to easily edit lists of strings gradually without crafting long 
+list comprehensions.
+
+'l' is the magic variable name for every line (array element). Save the current 
+result (or more exactly, retrieve the last ipython computation result into
+%led work area) by running '%led s'. Just run '%led' to show the current work
+area data.
+
+Example use:
+
+[ipython]|25> setups = !ls *setup*.py
+ ==
+['eggsetup.py', 'setup.py', 'setup_bdist_egg.py']
+[ipython]|26> setups
+         <26> ['eggsetup.py', 'setup.py', 'setup_bdist_egg.py']
+[ipython]|27> %led s
+Data set from last result (_)
+         <27> ['eggsetup.py', 'setup.py', 'setup_bdist_egg.py']
+[ipython]|28> %led upper
+cmd translated => l.upper()
+         <28> ['EGGSETUP.PY', 'SETUP.PY', 'SETUP_BDIST_EGG.PY']
+[ipython]|29> %led
+Magic line editor (for lists of strings)
+current data is:
+['eggsetup.py', 'setup.py', 'setup_bdist_egg.py']
+[ipython]|30> %led upper
+cmd translated => l.upper()
+         <30> ['EGGSETUP.PY', 'SETUP.PY', 'SETUP_BDIST_EGG.PY']
+[ipython]|31> %led s
+Data set from last result (_)
+         <31> ['EGGSETUP.PY', 'SETUP.PY', 'SETUP_BDIST_EGG.PY']
+[ipython]|32> %led "n:" + l
+         <32> ['n:EGGSETUP.PY', 'n:SETUP.PY', 'n:SETUP_BDIST_EGG.PY']
+[ipython]|33> %led s
+Data set from last result (_)
+         <33> ['n:EGGSETUP.PY', 'n:SETUP.PY', 'n:SETUP_BDIST_EGG.PY']
+[ipython]|34> %led l.
+l.__add__          l.__gt__           l.__reduce_ex__    l.endswith         l.join             l.rstrip
+l.__class__        l.__hash__         l.__repr__         l.expandtabs       l.ljust            l.split
+
+... (completions for string variable shown ) ...
+
+"""
+import IPython.ipapi
+import pprint
+ip = IPython.ipapi.get()
+
+curdata = []
+
+def line_edit_f(self, cmd ):
+    global curdata
+    
+    if not cmd:
+        
+        print "Magic line editor (for lists of strings)"
+        if curdata:
+            print "current data is:"
+            pprint.pprint(curdata)
+        else:
+            print "No current data, you should set it by running '%led s'"
+            print "When you have your data in _ (result of last computation)."
+        return
+        
+    if cmd == 's':
+        curdata = ip.ev('_')
+        print "Data set from last result (_)"
+        newlines = curdata
+        
+    else:
+        # simple method call, e.g. upper
+        if cmd.isalpha():
+            cmd = 'l.' + cmd + '()'
+            print "cmd translated =>",cmd
+
+        newlines = []
+        for l in curdata:
+            try:
+                l2 = eval(cmd)
+            except Exception,e:
+                print "Dropping exception",e,"on line:",l
+                continue
+            newlines.append(l2)
+
+    
+    return newlines
+
+def line_edit_complete_f(self,event):
+    """ Show all string methods in completions """
+    if event.symbol.startswith('l.'):
+        return ['l.' + func for func in dir('')]
+    
+    return dir('') + ['l.' + func for func in dir('')]
+
+ip.set_hook('complete_command', line_edit_complete_f , str_key = '%led')
+        
+ip.expose_magic('led', line_edit_f)
\ No newline at end of file
diff --git a/IPython/Extensions/numeric_formats.py b/IPython/Extensions/numeric_formats.py
new file mode 100644
index 0000000..98afd95
--- /dev/null
+++ b/IPython/Extensions/numeric_formats.py
@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""
+Extension for printing Numeric Arrays in flexible ways.
+"""
+
+from Numeric import ArrayType
+
+def num_display(self,arg):
+    """Display method for printing which treats Numeric arrays specially.
+    """
+
+    # Non-numpy variables are printed using the system default
+    if type(arg) != ArrayType:
+        self._display(arg)
+        return
+    # Otherwise, we do work.
+    format = __IPYTHON__.runtime_rc.numarray_print_format
+    print 'NumPy array, format:',format
+    # Here is where all the printing logic needs to be implemented
+    print arg # nothing yet :)
+
+
+def magic_format(self,parameter_s=''):
+    """Specifies format of numerical output.
+
+    This command is similar to Ocave's format command.
+    """
+
+    valid_formats = ['long','short']
+    
+    if parameter_s in valid_formats:
+        self.runtime_rc.numarray_print_format = parameter_s
+        print 'Numeric output format is now:',parameter_s
+    else:
+        print 'Invalid format:',parameter_s
+        print 'Valid formats:',valid_formats
+
+# setup default format
+__IPYTHON__.runtime_rc.numarray_print_format = 'long'
+
+# Bind our new functions to the interpreter
+__IPYTHON__.__class__.magic_format = magic_format
+__IPYTHON__.hooks.display = num_display
diff --git a/IPython/Extensions/pickleshare.py b/IPython/Extensions/pickleshare.py
new file mode 100644
index 0000000..976ae8d
--- /dev/null
+++ b/IPython/Extensions/pickleshare.py
@@ -0,0 +1,359 @@
+#!/usr/bin/env python
+
+""" PickleShare - a small 'shelve' like datastore with concurrency support
+
+Like shelve, a PickleShareDB object acts like a normal dictionary. Unlike 
+shelve, many processes can access the database simultaneously. Changing a 
+value in database is immediately visible to other processes accessing the 
+same database.
+
+Concurrency is possible because the values are stored in separate files. Hence
+the "database" is a directory where *all* files are governed by PickleShare.
+
+Example usage::
+    
+    from pickleshare import *
+    db = PickleShareDB('~/testpickleshare')
+    db.clear()
+    print "Should be empty:",db.items()
+    db['hello'] = 15
+    db['aku ankka'] = [1,2,313]
+    db['paths/are/ok/key'] = [1,(5,46)]
+    print db.keys()
+    del db['aku ankka']
+
+This module is certainly not ZODB, but can be used for low-load 
+(non-mission-critical) situations where tiny code size trumps the 
+advanced features of a "real" object database.
+
+Installation guide: easy_install pickleshare
+
+Author: Ville Vainio <vivainio@gmail.com>
+License: MIT open source license.
+
+"""
+
+from IPython.external.path import path as Path
+import os,stat,time
+import cPickle as pickle
+import UserDict
+import warnings
+import glob
+
+from sets import Set as set
+
+def gethashfile(key):
+    return ("%02x" % abs(hash(key) % 256))[-2:]
+
+_sentinel = object()
+
+class PickleShareDB(UserDict.DictMixin):
+    """ The main 'connection' object for PickleShare database """
+    def __init__(self,root):
+        """ Return a db object that will manage the specied directory"""
+        self.root = Path(root).expanduser().abspath()
+        if not self.root.isdir():
+            self.root.makedirs()
+        # cache has { 'key' : (obj, orig_mod_time) }
+        self.cache = {}
+        
+
+    def __getitem__(self,key):
+        """ db['key'] reading """
+        fil = self.root / key
+        try:
+            mtime = (fil.stat()[stat.ST_MTIME])
+        except OSError:
+            raise KeyError(key)
+
+        if fil in self.cache and mtime == self.cache[fil][1]:
+            return self.cache[fil][0]
+        try:
+            # The cached item has expired, need to read
+            obj = pickle.load(fil.open())
+        except:
+            raise KeyError(key)
+            
+        self.cache[fil] = (obj,mtime)
+        return obj
+    
+    def __setitem__(self,key,value):
+        """ db['key'] = 5 """
+        fil = self.root / key
+        parent = fil.parent
+        if parent and not parent.isdir():
+            parent.makedirs()
+        pickled = pickle.dump(value,fil.open('w'))
+        try:
+            self.cache[fil] = (value,fil.mtime)
+        except OSError,e:
+            if e.errno != 2:
+                raise
+    
+    def hset(self, hashroot, key, value):
+        """ hashed set """
+        hroot = self.root / hashroot
+        if not hroot.isdir():
+            hroot.makedirs()
+        hfile = hroot / gethashfile(key)
+        d = self.get(hfile, {})
+        d.update( {key : value})
+        self[hfile] = d                
+
+    
+    
+    def hget(self, hashroot, key, default = _sentinel, fast_only = True):
+        """ hashed get """
+        hroot = self.root / hashroot
+        hfile = hroot / gethashfile(key)
+        
+        d = self.get(hfile, _sentinel )
+        #print "got dict",d,"from",hfile
+        if d is _sentinel:
+            if fast_only:
+                if default is _sentinel:
+                    raise KeyError(key)
+                    
+                return default
+            
+            # slow mode ok, works even after hcompress()
+            d = self.hdict(hashroot)
+        
+        return d.get(key, default)
+
+    def hdict(self, hashroot):
+        """ Get all data contained in hashed category 'hashroot' as dict """
+        hfiles = self.keys(hashroot + "/*")
+        hfiles.sort()
+        last = len(hfiles) and hfiles[-1] or ''
+        if last.endswith('xx'):
+            # print "using xx"
+            hfiles = [last] + hfiles[:-1]
+            
+        all = {}
+        
+        for f in hfiles:
+            # print "using",f
+            try:
+                all.update(self[f])
+            except KeyError:
+                print "Corrupt",f,"deleted - hset is not threadsafe!"
+                del self[f]
+                
+            self.uncache(f)
+        
+        return all
+    
+    def hcompress(self, hashroot):
+        """ Compress category 'hashroot', so hset is fast again
+        
+        hget will fail if fast_only is True for compressed items (that were
+        hset before hcompress).
+        
+        """
+        hfiles = self.keys(hashroot + "/*")
+        all = {}
+        for f in hfiles:
+            # print "using",f
+            all.update(self[f])
+            self.uncache(f)
+            
+        self[hashroot + '/xx'] = all
+        for f in hfiles:
+            p = self.root / f
+            if p.basename() == 'xx':
+                continue
+            p.remove()
+            
+            
+        
+    def __delitem__(self,key):
+        """ del db["key"] """
+        fil = self.root / key
+        self.cache.pop(fil,None)
+        try:
+            fil.remove()
+        except OSError:
+            # notfound and permission denied are ok - we
+            # lost, the other process wins the conflict
+            pass
+        
+    def _normalized(self, p):
+        """ Make a key suitable for user's eyes """
+        return str(self.root.relpathto(p)).replace('\\','/')
+    
+    def keys(self, globpat = None):
+        """ All keys in DB, or all keys matching a glob"""
+        
+        if globpat is None:
+            files = self.root.walkfiles()
+        else:
+            files = [Path(p) for p in glob.glob(self.root/globpat)]
+        return [self._normalized(p) for p in files if p.isfile()]
+
+    def uncache(self,*items):
+        """ Removes all, or specified items from cache
+        
+        Use this after reading a large amount of large objects
+        to free up memory, when you won't be needing the objects
+        for a while.
+         
+        """
+        if not items:
+            self.cache = {}
+        for it in items:
+            self.cache.pop(it,None)
+            
+    def waitget(self,key, maxwaittime = 60 ):
+        """ Wait (poll) for a key to get a value
+        
+        Will wait for `maxwaittime` seconds before raising a KeyError.
+        The call exits normally if the `key` field in db gets a value
+        within the timeout period.
+        
+        Use this for synchronizing different processes or for ensuring
+        that an unfortunately timed "db['key'] = newvalue" operation 
+        in another process (which causes all 'get' operation to cause a 
+        KeyError for the duration of pickling) won't screw up your program 
+        logic. 
+        """
+        
+        wtimes = [0.2] * 3 + [0.5] * 2 + [1]
+        tries = 0
+        waited = 0
+        while 1:
+            try:
+                val = self[key]
+                return val
+            except KeyError:
+                pass
+            
+            if waited > maxwaittime:
+                raise KeyError(key)
+            
+            time.sleep(wtimes[tries])
+            waited+=wtimes[tries]
+            if tries < len(wtimes) -1:
+                tries+=1
+    
+    def getlink(self,folder):
+        """ Get a convenient link for accessing items  """
+        return PickleShareLink(self, folder)
+    
+    def __repr__(self):
+        return "PickleShareDB('%s')" % self.root
+        
+        
+                
+class PickleShareLink:
+    """ A shortdand for accessing nested PickleShare data conveniently.
+
+    Created through PickleShareDB.getlink(), example::
+
+        lnk = db.getlink('myobjects/test')
+        lnk.foo = 2
+        lnk.bar = lnk.foo + 5
+    
+    """
+    def __init__(self, db, keydir ):    
+        self.__dict__.update(locals())
+        
+    def __getattr__(self,key):
+        return self.__dict__['db'][self.__dict__['keydir']+'/' + key]
+    def __setattr__(self,key,val):
+        self.db[self.keydir+'/' + key] = val
+    def __repr__(self):
+        db = self.__dict__['db']
+        keys = db.keys( self.__dict__['keydir'] +"/*")
+        return "<PickleShareLink '%s': %s>" % (
+            self.__dict__['keydir'],
+            ";".join([Path(k).basename() for k in keys]))
+            
+        
+def test():
+    db = PickleShareDB('~/testpickleshare')
+    db.clear()
+    print "Should be empty:",db.items()
+    db['hello'] = 15
+    db['aku ankka'] = [1,2,313]
+    db['paths/nest/ok/keyname'] = [1,(5,46)]
+    db.hset('hash', 'aku', 12)
+    db.hset('hash', 'ankka', 313)
+    print "12 =",db.hget('hash','aku')
+    print "313 =",db.hget('hash','ankka')
+    print "all hashed",db.hdict('hash')
+    print db.keys()
+    print db.keys('paths/nest/ok/k*')
+    print dict(db) # snapsot of whole db
+    db.uncache() # frees memory, causes re-reads later
+
+    # shorthand for accessing deeply nested files
+    lnk = db.getlink('myobjects/test')
+    lnk.foo = 2
+    lnk.bar = lnk.foo + 5
+    print lnk.bar # 7
+
+def stress():
+    db = PickleShareDB('~/fsdbtest')
+    import time,sys
+    for i in range(1000):
+        for j in range(1000):
+            if i % 15 == 0 and i < 200:
+                if str(j) in db:
+                    del db[str(j)]
+                continue
+
+            if j%33 == 0:
+                time.sleep(0.02)
+            
+            db[str(j)] = db.get(str(j), []) + [(i,j,"proc %d" % os.getpid())]
+            db.hset('hash',j, db.hget('hash',j,15) + 1 )
+            
+        print i,
+        sys.stdout.flush()
+        if i % 10 == 0:
+            db.uncache()
+    
+def main():
+    import textwrap
+    usage = textwrap.dedent("""\
+    pickleshare - manage PickleShare databases 
+    
+    Usage:
+        
+        pickleshare dump /path/to/db > dump.txt
+        pickleshare load /path/to/db < dump.txt
+        pickleshare test /path/to/db
+    """)
+    DB = PickleShareDB
+    import sys
+    if len(sys.argv) < 2:
+        print usage
+        return
+        
+    cmd = sys.argv[1]
+    args = sys.argv[2:]
+    if cmd == 'dump':
+        if not args: args= ['.']
+        db = DB(args[0])
+        import pprint
+        pprint.pprint(db.items())
+    elif cmd == 'load':
+        cont = sys.stdin.read()
+        db = DB(args[0])
+        data = eval(cont)
+        db.clear()
+        for k,v in db.items():
+            db[k] = v
+    elif cmd == 'testwait':
+        db = DB(args[0])
+        db.clear()
+        print db.waitget('250')
+    elif cmd == 'test':
+        test()
+        stress()
+    
+if __name__== "__main__":
+    main()
+    
+    
diff --git a/IPython/Extensions/pspersistence.py b/IPython/Extensions/pspersistence.py
new file mode 100644
index 0000000..6dfc29e
--- /dev/null
+++ b/IPython/Extensions/pspersistence.py
@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+"""
+%store magic for lightweight persistence.
+
+Stores variables, aliases etc. in PickleShare database.
+
+$Id: iplib.py 1107 2006-01-30 19:02:20Z vivainio $
+"""
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+import pickleshare
+
+import inspect,pickle,os,sys,textwrap
+from IPython.FakeModule import FakeModule
+
+def restore_aliases(self):
+    ip = self.getapi()
+    staliases = ip.db.get('stored_aliases', {})
+    for k,v in staliases.items():
+        #print "restore alias",k,v # dbg
+        #self.alias_table[k] = v
+        ip.defalias(k,v)
+
+
+def refresh_variables(ip):
+    db = ip.db
+    for key in db.keys('autorestore/*'):
+        # strip autorestore
+        justkey = os.path.basename(key)
+        try:
+            obj = db[key]
+        except KeyError:
+            print "Unable to restore variable '%s', ignoring (use %%store -d to forget!)" % justkey
+            print "The error was:",sys.exc_info()[0]
+        else:
+            #print "restored",justkey,"=",obj #dbg
+            ip.user_ns[justkey] = obj
+    
+
+def restore_dhist(ip):
+    db = ip.db
+    ip.user_ns['_dh'] = db.get('dhist',[])
+    
+def restore_data(self):
+    ip = self.getapi()
+    refresh_variables(ip)
+    restore_aliases(self)
+    restore_dhist(self)
+    raise IPython.ipapi.TryNext
+    
+ip.set_hook('late_startup_hook', restore_data)
+
+def magic_store(self, parameter_s=''):
+    """Lightweight persistence for python variables.
+
+    Example:
+    
+    ville@badger[~]|1> A = ['hello',10,'world']\\
+    ville@badger[~]|2> %store A\\
+    ville@badger[~]|3> Exit
+    
+    (IPython session is closed and started again...)
+    
+    ville@badger:~$ ipython -p pysh\\
+    ville@badger[~]|1> print A
+    
+    ['hello', 10, 'world']
+    
+    Usage:
+    
+    %store          - Show list of all variables and their current values\\
+    %store <var>    - Store the *current* value of the variable to disk\\
+    %store -d <var> - Remove the variable and its value from storage\\
+    %store -z       - Remove all variables from storage\\
+    %store -r       - Refresh all variables from store (delete current vals)\\
+    %store foo >a.txt  - Store value of foo to new file a.txt\\
+    %store foo >>a.txt - Append value of foo to file a.txt\\   
+    
+    It should be noted that if you change the value of a variable, you
+    need to %store it again if you want to persist the new value.
+    
+    Note also that the variables will need to be pickleable; most basic
+    python types can be safely %stored.
+    
+    Also aliases can be %store'd across sessions.
+    """
+    
+    opts,argsl = self.parse_options(parameter_s,'drz',mode='string')
+    args = argsl.split(None,1)
+    ip = self.getapi()
+    db = ip.db
+    # delete
+    if opts.has_key('d'):
+        try:
+            todel = args[0]
+        except IndexError:
+            error('You must provide the variable to forget')
+        else:
+            try:
+                del db['autorestore/' + todel]
+            except:
+                error("Can't delete variable '%s'" % todel)
+    # reset
+    elif opts.has_key('z'):
+        for k in db.keys('autorestore/*'):
+            del db[k]
+
+    elif opts.has_key('r'):
+        refresh_variables(ip)
+
+    
+    # run without arguments -> list variables & values
+    elif not args:
+        vars = self.db.keys('autorestore/*')
+        vars.sort()            
+        if vars:
+            size = max(map(len,vars))
+        else:
+            size = 0
+            
+        print 'Stored variables and their in-db values:'
+        fmt = '%-'+str(size)+'s -> %s'
+        get = db.get
+        for var in vars:
+            justkey = os.path.basename(var)
+            # print 30 first characters from every var
+            print fmt % (justkey,repr(get(var,'<unavailable>'))[:50])
+    
+    # default action - store the variable
+    else:
+        # %store foo >file.txt or >>file.txt
+        if len(args) > 1 and args[1].startswith('>'):
+            fnam = os.path.expanduser(args[1].lstrip('>').lstrip())
+            if args[1].startswith('>>'):
+                fil = open(fnam,'a')
+            else:
+                fil = open(fnam,'w')
+            obj = ip.ev(args[0])
+            print "Writing '%s' (%s) to file '%s'." % (args[0],
+              obj.__class__.__name__, fnam)
+
+            
+            if not isinstance (obj,basestring):
+                from pprint import pprint
+                pprint(obj,fil)
+            else:
+                fil.write(obj)
+                if not obj.endswith('\n'):
+                    fil.write('\n')
+            
+            fil.close()
+            return
+        
+        # %store foo
+        try:
+            obj = ip.user_ns[args[0]]
+        except KeyError:
+            # it might be an alias
+            if args[0] in self.alias_table:
+                staliases = db.get('stored_aliases',{})
+                staliases[ args[0] ] = self.alias_table[ args[0] ]
+                db['stored_aliases'] = staliases                
+                print "Alias stored:", args[0], self.alias_table[ args[0] ]
+                return
+            else:
+                print "Error: unknown variable '%s'" % args[0]
+            
+        else:
+            if isinstance(inspect.getmodule(obj), FakeModule):
+                print textwrap.dedent("""\
+                Warning:%s is %s 
+                Proper storage of interactively declared classes (or instances
+                of those classes) is not possible! Only instances
+                of classes in real modules on file system can be %%store'd.
+                """ % (args[0], obj) ) 
+                return
+            #pickled = pickle.dumps(obj)
+            self.db[ 'autorestore/' + args[0] ] = obj
+            print "Stored '%s' (%s)" % (args[0], obj.__class__.__name__)
+
+ip.expose_magic('store',magic_store)
diff --git a/IPython/Extensions/win32clip.py b/IPython/Extensions/win32clip.py
new file mode 100644
index 0000000..f2030e0
--- /dev/null
+++ b/IPython/Extensions/win32clip.py
@@ -0,0 +1,45 @@
+import IPython.ipapi
+
+ip = IPython.ipapi.get()
+
+def clip_f( self, parameter_s = '' ):
+    """Save a set of lines to the clipboard.
+
+    Usage:\\
+      %clip n1-n2 n3-n4 ... n5 .. n6 ...
+
+    This function uses the same syntax as %macro for line extraction, but
+    instead of creating a macro it saves the resulting string to the
+    clipboard.
+    
+    When used without arguments, this returns the text contents of the clipboard. 
+    E.g.
+    
+    mytext = %clip
+    
+    """
+
+    import win32clipboard as cl
+    import win32con
+    args = parameter_s.split()
+    cl.OpenClipboard()
+    if len( args ) == 0:
+        data = cl.GetClipboardData( win32con.CF_TEXT )
+        cl.CloseClipboard()
+        return data
+    api = self.getapi()
+    
+    if parameter_s.lstrip().startswith('='):
+        rest = parameter_s[parameter_s.index('=')+1:].strip()
+        val = str(api.ev(rest))
+    else:
+        ranges = args[0:]
+        val = ''.join( self.extract_input_slices( ranges ) )
+
+    cl.EmptyClipboard()
+    cl.SetClipboardText( val )
+    cl.CloseClipboard()
+    print 'The following text was written to the clipboard'
+    print val
+    
+ip.expose_magic( "clip", clip_f )
diff --git a/IPython/FakeModule.py b/IPython/FakeModule.py
new file mode 100644
index 0000000..dae7147
--- /dev/null
+++ b/IPython/FakeModule.py
@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""
+Class which mimics a module.
+
+Needed to allow pickle to correctly resolve namespaces during IPython
+sessions.
+
+$Id: FakeModule.py 2754 2007-09-09 10:16:59Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2002-2004 Fernando Perez. <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+import types
+
+class FakeModule(types.ModuleType):
+    """Simple class with attribute access to fake a module.
+
+    This is not meant to replace a module, but to allow inserting a fake
+    module in sys.modules so that systems which rely on run-time module
+    importing (like shelve and pickle) work correctly in interactive IPython
+    sessions.
+
+    Do NOT use this code for anything other than this IPython private hack."""
+
+    def __init__(self,adict=None):
+        
+        # tmp to force __dict__ instance creation, else self.__dict__ fails
+        self.__iptmp = None
+        
+        # It seems pydoc (and perhaps others) needs any module instance to
+        # implement a __nonzero__ method, so we add it if missing:
+        self.__dict__.setdefault('__nonzero__',lambda : True)
+        self.__dict__.setdefault('__file__',__file__)
+
+        # cleanup our temp trick
+        del self.__iptmp
+
+        if adict is not None:
+            self.__dict__.update(adict)
diff --git a/IPython/Gnuplot2.py b/IPython/Gnuplot2.py
new file mode 100644
index 0000000..ea6f08a
--- /dev/null
+++ b/IPython/Gnuplot2.py
@@ -0,0 +1,666 @@
+# -*- coding: utf-8 -*-
+"""Improved replacement for the Gnuplot.Gnuplot class.
+
+This module imports Gnuplot and replaces some of its functionality with
+improved versions. They add better handling of arrays for plotting and more
+convenient PostScript generation, plus some fixes for hardcopy().
+
+It also adds a convenient plot2 method for plotting dictionaries and
+lists/tuples of arrays.
+
+This module is meant to be used as a drop-in replacement to the original
+Gnuplot, so it should be safe to do:
+
+import IPython.Gnuplot2 as Gnuplot
+
+$Id: Gnuplot2.py 1210 2006-03-13 01:19:31Z fperez $"""
+
+import cStringIO
+import os
+import string
+import sys
+import tempfile
+import time
+import types
+
+import Gnuplot as Gnuplot_ori
+import Numeric
+
+from IPython.genutils import popkey,xsys
+
+# needed by hardcopy():
+gp = Gnuplot_ori.gp
+
+# Patch for Gnuplot.py 1.6 compatibility.
+# Thanks to Hayden Callow <h.callow@elec.canterbury.ac.nz>
+try:
+    OptionException = Gnuplot_ori.PlotItems.OptionException
+except AttributeError:
+    OptionException = Gnuplot_ori.Errors.OptionError
+
+# exhibit a similar interface to Gnuplot so it can be somewhat drop-in
+Data      = Gnuplot_ori.Data
+Func      = Gnuplot_ori.Func
+GridData  = Gnuplot_ori.GridData
+PlotItem  = Gnuplot_ori.PlotItem
+PlotItems = Gnuplot_ori.PlotItems
+
+# Modify some of Gnuplot's functions with improved versions (or bugfixed, in
+# hardcopy's case). In order to preserve the docstrings at runtime, I've
+# copied them from the original code.
+
+# After some significant changes in v 1.7 of Gnuplot.py, we need to do a bit
+# of version checking.
+
+if Gnuplot_ori.__version__ <= '1.6':
+    _BaseFileItem = PlotItems.File
+    _BaseTempFileItem = PlotItems.TempFile
+
+    # Fix the File class to add the 'index' option for Gnuplot versions < 1.7
+    class File(_BaseFileItem):
+
+        _option_list = _BaseFileItem._option_list.copy()
+        _option_list.update({
+            'index' : lambda self, index: self.set_option_index(index),
+            })
+
+        # A new initializer is needed b/c we want to add a modified
+        # _option_sequence list which includes 'index' in the right place.
+        def __init__(self,*args,**kw):
+            self._option_sequence = ['binary', 'index', 'using', 'smooth', 'axes',
+                         'title', 'with']
+
+            _BaseFileItem.__init__(self,*args,**kw)
+
+        # Let's fix the constructor docstring
+        __newdoc = \
+            """Additional Keyword arguments added by IPython:
+
+             'index=<int>' -- similar to the `index` keyword in Gnuplot.
+                 This allows only some of the datasets in a file to be
+                 plotted. Datasets within a file are assumed to be separated
+                 by _pairs_ of blank lines, and the first one is numbered as
+                 0 (similar to C/Python usage)."""
+        __init__.__doc__ = PlotItems.File.__init__.__doc__ + __newdoc
+
+        def set_option_index(self, index):
+            if index is None:
+                self.clear_option('index')
+            elif type(index) in [type(''), type(1)]:
+                self._options['index'] = (index, 'index %s' % index)
+            elif type(index) is type(()):
+                self._options['index'] = (index,'index %s' %
+                                          string.join(map(repr, index), ':'))
+            else:
+                raise OptionException('index=%s' % (index,))
+
+    # We need a FileClass with a different name from 'File', which is a
+    # factory function in 1.7, so that our String class can subclass FileClass
+    # in any version.
+    _FileClass = File
+
+elif Gnuplot_ori.__version__ =='1.7':
+    _FileClass = _BaseFileItem = PlotItems._FileItem
+    _BaseTempFileItem = PlotItems._TempFileItem
+    File = PlotItems.File
+
+else:  # changes in the newer version (svn as of March'06)
+     _FileClass = _BaseFileItem = PlotItems._FileItem
+     _BaseTempFileItem = PlotItems._NewFileItem
+     File = PlotItems.File
+
+
+# Now, we can add our generic code which is version independent
+
+# First some useful utilities
+def eps_fix_bbox(fname):
+    """Fix the bounding box of an eps file by running ps2eps on it.
+
+    If its name ends in .eps, the original file is removed.
+
+    This is particularly useful for plots made by Gnuplot with square aspect
+    ratio: there is a bug in Gnuplot which makes it generate a bounding box
+    which is far wider than the actual plot.
+
+    This function assumes that ps2eps is installed in your system."""
+
+    # note: ps2ps and eps2eps do NOT work, ONLY ps2eps works correctly. The
+    # others make output with bitmapped fonts, which looks horrible.
+    print 'Fixing eps file: <%s>' % fname
+    xsys('ps2eps -f -q -l %s' % fname)
+    if fname.endswith('.eps'):
+        os.rename(fname+'.eps',fname)
+
+def is_list1d(x,containers = [types.ListType,types.TupleType]):
+    """Returns true if x appears to be a 1d list/tuple/array.
+
+    The heuristics are: identify Numeric arrays, or lists/tuples whose first
+    element is not itself a list/tuple. This way zipped lists should work like
+    the original Gnuplot. There's no inexpensive way to know if a list doesn't
+    have a composite object after its first element, so that kind of input
+    will produce an error. But it should work well in most cases.
+    """
+    x_type = type(x)
+
+    return x_type == Numeric.ArrayType and len(x.shape)==1 or \
+           (x_type in containers and
+            type(x[0]) not in containers + [Numeric.ArrayType])
+
+def zip_items(items,titles=None):
+    """zip together neighboring 1-d arrays, and zip standalone ones
+    with their index. Leave other plot items alone."""
+
+    class StandaloneItem(Exception): pass
+    
+    def get_titles(titles):
+        """Return the next title and the input titles array.
+
+        The input array may be changed to None when no titles are left to
+        prevent extra unnecessary calls to this function."""
+        
+        try:
+            title = titles[tit_ct[0]]  # tit_ct[0] is in zip_items'scope
+        except IndexError:
+            titles = None # so we don't enter again
+            title = None
+        else:
+            tit_ct[0] += 1
+        return title,titles
+
+    new_items = []
+
+    if titles:
+        # Initialize counter. It was put in a list as a hack to allow the
+        # nested get_titles to modify it without raising a NameError.
+        tit_ct = [0]
+
+    n = 0  # this loop needs to be done by hand
+    while n < len(items):
+        item = items[n]
+        try:
+            if is_list1d(item):
+                if n==len(items)-1: # last in list
+                    raise StandaloneItem
+                else: # check the next item and zip together if needed
+                    next_item = items[n+1]
+                    if next_item is None:
+                        n += 1
+                        raise StandaloneItem
+                    elif is_list1d(next_item):
+                        # this would be best done with an iterator
+                        if titles:
+                            title,titles = get_titles(titles)
+                        else:
+                            title = None
+                        new_items.append(Data(zip(item,next_item),
+                                              title=title))
+                        n += 1  # avoid double-inclusion of next item
+                    else: # can't zip with next, zip with own index list
+                        raise StandaloneItem
+            else:  # not 1-d array
+                new_items.append(item)
+        except StandaloneItem:
+            if titles:
+                title,titles = get_titles(titles)
+            else:
+                title = None
+            new_items.append(Data(zip(range(len(item)),item),title=title))
+        except AttributeError:
+            new_items.append(item)
+        n+=1
+
+    return new_items
+
+# And some classes with enhanced functionality.
+class String(_FileClass):
+    """Make a PlotItem from data in a string with the same format as a File.
+
+    This allows writing data directly inside python scripts using the exact
+    same format and manipulation options which would be used for external
+    files."""
+
+    def __init__(self, data_str, **keyw):
+        """Construct a String object.
+
+        <data_str> is a string formatted exactly like a valid Gnuplot data
+        file would be. All options from the File constructor are valid here.
+
+        Warning: when used for interactive plotting in scripts which exit
+        immediately, you may get an error because the temporary file used to
+        hold the string data was deleted before Gnuplot had a chance to see
+        it. You can work around this problem by putting a raw_input() call at
+        the end of the script.
+
+        This problem does not appear when generating PostScript output, only
+        with Gnuplot windows."""
+
+        self.tmpfile = _BaseTempFileItem()
+        tmpfile = file(self.tmpfile.filename,'w')
+        tmpfile.write(data_str)
+        _BaseFileItem.__init__(self,self.tmpfile,**keyw)
+
+
+class Gnuplot(Gnuplot_ori.Gnuplot):
+    """Improved Gnuplot class.
+
+    Enhancements: better plot,replot and hardcopy methods. New methods for
+    quick range setting.
+    """
+
+    def xrange(self,min='*',max='*'):
+        """Set xrange. If min/max is omitted, it is set to '*' (auto).
+
+        Note that this is different from the regular Gnuplot behavior, where
+        an unspecified limit means no change. Here any unspecified limit is
+        set to autoscaling, allowing these functions to be used for full
+        autoscaling when called with no arguments.
+
+        To preserve one limit's current value while changing the other, an
+        explicit '' argument must be given as the limit to be kept.
+
+        Similar functions exist for [y{2}z{2}rtuv]range."""
+        
+        self('set xrange [%s:%s]' % (min,max))
+             
+    def yrange(self,min='*',max='*'):
+        self('set yrange [%s:%s]' % (min,max))
+             
+    def zrange(self,min='*',max='*'):
+        self('set zrange [%s:%s]' % (min,max))
+             
+    def x2range(self,min='*',max='*'):
+        self('set xrange [%s:%s]' % (min,max))
+             
+    def y2range(self,min='*',max='*'):
+        self('set yrange [%s:%s]' % (min,max))
+             
+    def z2range(self,min='*',max='*'):
+        self('set zrange [%s:%s]' % (min,max))
+             
+    def rrange(self,min='*',max='*'):
+        self('set rrange [%s:%s]' % (min,max))
+             
+    def trange(self,min='*',max='*'):
+        self('set trange [%s:%s]' % (min,max))
+             
+    def urange(self,min='*',max='*'):
+        self('set urange [%s:%s]' % (min,max))
+             
+    def vrange(self,min='*',max='*'):
+        self('set vrange [%s:%s]' % (min,max))
+
+    def set_ps(self,option):
+        """Set an option for the PostScript terminal and reset default term."""
+
+        self('set terminal postscript %s ' % option)
+        self('set terminal %s' % gp.GnuplotOpts.default_term)
+
+    def __plot_ps(self, plot_method,*items, **keyw):
+        """Wrapper for plot/splot/replot, with processing of hardcopy options.
+
+        For internal use only."""
+
+        # Filter out PostScript options which will crash the normal plot/replot
+        psargs = {'filename':None,
+                  'mode':None,
+                  'eps':None,
+                  'enhanced':None,
+                  'color':None,
+                  'solid':None,
+                  'duplexing':None,
+                  'fontname':None,
+                  'fontsize':None,
+                  'debug':0 }
+
+        for k in psargs.keys():
+            if keyw.has_key(k):
+                psargs[k] = keyw[k]
+                del keyw[k]
+
+        # Filter out other options the original plot doesn't know
+        hardcopy = popkey(keyw,'hardcopy',psargs['filename'] is not None)
+        titles = popkey(keyw,'titles',0)
+        
+        # the filename keyword should control hardcopy generation, this is an
+        # override switch only which needs to be explicitly set to zero
+        if hardcopy:
+            if psargs['filename'] is None:
+                raise ValueError, \
+                      'If you request hardcopy, you must give a filename.'
+
+            # set null output so nothing goes to screen. hardcopy() restores output
+            self('set term dumb')
+            # I don't know how to prevent screen output in Windows
+            if os.name == 'posix':
+                self('set output "/dev/null"')
+
+        new_items = zip_items(items,titles)
+        # plot_method is either plot or replot from the original Gnuplot class:
+        plot_method(self,*new_items,**keyw)
+
+        # Do hardcopy if requested
+        if hardcopy:
+            if psargs['filename'].endswith('.eps'):
+                psargs['eps'] = 1
+            self.hardcopy(**psargs)
+
+    def plot(self, *items, **keyw):
+        """Draw a new plot.
+
+        Clear the current plot and create a new 2-d plot containing
+        the specified items.  Each arguments should be of the
+        following types:
+
+        'PlotItem' (e.g., 'Data', 'File', 'Func') -- This is the most
+            flexible way to call plot because the PlotItems can
+            contain suboptions.  Moreover, PlotItems can be saved to
+            variables so that their lifetime is longer than one plot
+            command; thus they can be replotted with minimal overhead.
+
+        'string' (e.g., 'sin(x)') -- The string is interpreted as
+            'Func(string)' (a function that is computed by gnuplot).
+
+        Anything else -- The object, which should be convertible to an
+            array, is passed to the 'Data' constructor, and thus
+            plotted as data.  If the conversion fails, an exception is
+            raised.
+
+
+        This is a modified version of plot(). Compared to the original in
+        Gnuplot.py, this version has several enhancements, listed below.
+
+
+        Modifications to the input arguments
+        ------------------------------------
+
+        (1-d array means Numeric array, list or tuple):
+
+        (i) Any 1-d array which is NOT followed by another 1-d array, is
+        automatically zipped with range(len(array_1d)). Typing g.plot(y) will
+        plot y against its indices.
+
+        (ii) If two 1-d arrays are contiguous in the argument list, they are
+        automatically zipped together. So g.plot(x,y) plots y vs. x, and
+        g.plot(x1,y1,x2,y2) plots y1 vs. x1 and y2 vs. x2.
+
+        (iii) Any 1-d array which is followed by None is automatically zipped
+        with range(len(array_1d)). In this form, typing g.plot(y1,None,y2)
+        will plot both y1 and y2 against their respective indices (and NOT
+        versus one another). The None prevents zipping y1 and y2 together, and
+        since y2 is unpaired it is automatically zipped to its indices by (i)
+
+        (iv) Any other arguments which don't match these cases are left alone and
+        passed to the code below.
+
+        For lists or tuples, the heuristics used to determine whether they are
+        in fact 1-d is fairly simplistic: their first element is checked, and
+        if it is not a list or tuple itself, it is assumed that the whole
+        object is one-dimensional.
+
+        An additional optional keyword 'titles' has been added: it must be a
+        list of strings to be used as labels for the individual plots which
+        are NOT PlotItem objects (since those objects carry their own labels
+        within).
+
+
+        PostScript generation
+        ---------------------
+
+        This version of plot() also handles automatically the production of
+        PostScript output. The main options are (given as keyword arguments):
+
+        - filename: a string, typically ending in .eps. If given, the plot is
+        sent to this file in PostScript format.
+        
+        - hardcopy: this can be set to 0 to override 'filename'. It does not
+        need to be given to produce PostScript, its purpose is to allow
+        switching PostScript output off globally in scripts without having to
+        manually change 'filename' values in multiple calls.
+
+        All other keywords accepted by Gnuplot.hardcopy() are transparently
+        passed, and safely ignored if output is sent to the screen instead of
+        PostScript.
+
+        For example:
+        
+        In [1]: x=frange(0,2*pi,npts=100)
+
+        Generate a plot in file 'sin.eps':
+
+        In [2]: plot(x,sin(x),filename = 'sin.eps')
+
+        Plot to screen instead, without having to change the filename:
+
+        In [3]: plot(x,sin(x),filename = 'sin.eps',hardcopy=0)
+
+        Pass the 'color=0' option to hardcopy for monochrome output:
+
+        In [4]: plot(x,sin(x),filename = 'sin.eps',color=0)
+
+        PostScript generation through plot() is useful mainly for scripting
+        uses where you are not interested in interactive plotting. For
+        interactive use, the hardcopy() function is typically more convenient:
+        
+        In [5]: plot(x,sin(x))
+
+        In [6]: hardcopy('sin.eps')  """
+        
+        self.__plot_ps(Gnuplot_ori.Gnuplot.plot,*items,**keyw)
+        
+    def plot2(self,arg,**kw):
+        """Plot the entries of a dictionary or a list/tuple of arrays.        
+        
+        This simple utility calls plot() with a list of Gnuplot.Data objects
+        constructed either from the values of the input dictionary, or the entries
+        in it if it is a tuple or list.  Each item gets labeled with the key/index
+        in the Gnuplot legend.
+
+        Each item is plotted by zipping it with a list of its indices.
+
+        Any keywords are passed directly to plot()."""
+
+        if hasattr(arg,'keys'):
+            keys = arg.keys()
+            keys.sort()
+        else:
+            keys = range(len(arg))
+
+        pitems = [Data(zip(range(len(arg[k])),arg[k]),title=`k`) for k in keys]
+        self.plot(*pitems,**kw)
+
+    def splot(self, *items, **keyw):
+        """Draw a new three-dimensional plot.
+
+        Clear the current plot and create a new 3-d plot containing
+        the specified items.  Arguments can be of the following types:
+
+        'PlotItem' (e.g., 'Data', 'File', 'Func', 'GridData' ) -- This
+            is the most flexible way to call plot because the
+            PlotItems can contain suboptions.  Moreover, PlotItems can
+            be saved to variables so that their lifetime is longer
+            than one plot command--thus they can be replotted with
+            minimal overhead.
+
+        'string' (e.g., 'sin(x*y)') -- The string is interpreted as a
+            'Func()' (a function that is computed by gnuplot).
+
+        Anything else -- The object is converted to a Data() item, and
+            thus plotted as data.  Note that each data point should
+            normally have at least three values associated with it
+            (i.e., x, y, and z).  If the conversion fails, an
+            exception is raised.
+
+        This is a modified version of splot(). Compared to the original in
+        Gnuplot.py, this version has several enhancements, listed in the
+        plot() documentation.
+        """
+        
+        self.__plot_ps(Gnuplot_ori.Gnuplot.splot,*items,**keyw)
+
+    def replot(self, *items, **keyw):
+        """Replot the data, possibly adding new 'PlotItem's.
+
+        Replot the existing graph, using the items in the current
+        itemlist.  If arguments are specified, they are interpreted as
+        additional items to be plotted alongside the existing items on
+        the same graph.  See 'plot' for details.
+
+        If you want to replot to a postscript file, you MUST give the
+        'filename' keyword argument in each call to replot. The Gnuplot python
+        interface has no way of knowing that your previous call to
+        Gnuplot.plot() was meant for PostScript output."""
+        
+        self.__plot_ps(Gnuplot_ori.Gnuplot.replot,*items,**keyw)
+
+    # The original hardcopy has a bug. See fix at the end. The rest of the code
+    # was lifted verbatim from the original, so that people using IPython get the
+    # benefits without having to manually patch Gnuplot.py
+    def hardcopy(self, filename=None,
+                 mode=None,
+                 eps=None,
+                 enhanced=None,
+                 color=None,
+                 solid=None,
+                 duplexing=None,
+                 fontname=None,
+                 fontsize=None,
+                 debug = 0,
+                 ):
+        """Create a hardcopy of the current plot.
+
+        Create a postscript hardcopy of the current plot to the
+        default printer (if configured) or to the specified filename.
+
+        Note that gnuplot remembers the postscript suboptions across
+        terminal changes.  Therefore if you set, for example, color=1
+        for one hardcopy then the next hardcopy will also be color
+        unless you explicitly choose color=0.  Alternately you can
+        force all of the options to their defaults by setting
+        mode='default'.  I consider this to be a bug in gnuplot.
+
+        Keyword arguments:
+
+          'filename=<string>' -- if a filename is specified, save the
+              output in that file; otherwise print it immediately
+              using the 'default_lpr' configuration option.  If the
+              filename ends in '.eps', EPS mode is automatically
+              selected (like manually specifying eps=1 or mode='eps').
+
+          'mode=<string>' -- set the postscript submode ('landscape',
+              'portrait', 'eps', or 'default').  The default is
+              to leave this option unspecified.
+
+          'eps=<bool>' -- shorthand for 'mode="eps"'; asks gnuplot to
+              generate encapsulated postscript.
+
+          'enhanced=<bool>' -- if set (the default), then generate
+              enhanced postscript, which allows extra features like
+              font-switching, superscripts, and subscripts in axis
+              labels.  (Some old gnuplot versions do not support
+              enhanced postscript; if this is the case set
+              gp.GnuplotOpts.prefer_enhanced_postscript=None.)
+
+          'color=<bool>' -- if set, create a plot with color.  Default
+              is to leave this option unchanged.
+
+          'solid=<bool>' -- if set, force lines to be solid (i.e., not
+              dashed).
+
+          'duplexing=<string>' -- set duplexing option ('defaultplex',
+              'simplex', or 'duplex').  Only request double-sided
+              printing if your printer can handle it.  Actually this
+              option is probably meaningless since hardcopy() can only
+              print a single plot at a time.
+
+          'fontname=<string>' -- set the default font to <string>,
+              which must be a valid postscript font.  The default is
+              to leave this option unspecified.
+
+          'fontsize=<double>' -- set the default font size, in
+              postscript points.
+
+          'debug=<bool>' -- print extra debugging information (useful if
+              your PostScript files are misteriously not being created).
+        """
+
+        if filename is None:
+            assert gp.GnuplotOpts.default_lpr is not None, \
+                   OptionException('default_lpr is not set, so you can only '
+                                   'print to a file.')
+            filename = gp.GnuplotOpts.default_lpr
+            lpr_output = 1
+        else:
+            if filename.endswith('.eps'):
+                eps = 1
+            lpr_output = 0
+
+        # Be careful processing the options.  If the user didn't
+        # request an option explicitly, do not specify it on the 'set
+        # terminal' line (don't even specify the default value for the
+        # option).  This is to avoid confusing older versions of
+        # gnuplot that do not support all of these options.  The
+        # exception is 'enhanced', which is just too useful to have to
+        # specify each time!
+
+        setterm = ['set', 'terminal', 'postscript']
+        if eps:
+            assert mode is None or mode=='eps', \
+                   OptionException('eps option and mode are incompatible')
+            setterm.append('eps')
+        else:
+            if mode is not None:
+                assert mode in ['landscape', 'portrait', 'eps', 'default'], \
+                       OptionException('illegal mode "%s"' % mode)
+                setterm.append(mode)
+        if enhanced is None:
+            enhanced = gp.GnuplotOpts.prefer_enhanced_postscript
+        if enhanced is not None:
+            if enhanced: setterm.append('enhanced')
+            else: setterm.append('noenhanced')
+        if color is not None:
+            if color: setterm.append('color')
+            else: setterm.append('monochrome')
+        if solid is not None:
+            if solid: setterm.append('solid')
+            else: setterm.append('dashed')
+        if duplexing is not None:
+            assert duplexing in ['defaultplex', 'simplex', 'duplex'], \
+                   OptionException('illegal duplexing mode "%s"' % duplexing)
+            setterm.append(duplexing)
+        if fontname is not None:
+            setterm.append('"%s"' % fontname)
+        if fontsize is not None:
+            setterm.append('%s' % fontsize)
+
+        self(string.join(setterm))
+        self.set_string('output', filename)
+        # replot the current figure (to the printer):
+        self.refresh()
+
+        # fperez. Ugly kludge: often for some reason the file is NOT created
+        # and we must reissue the creation commands. I have no idea why!
+        if not lpr_output:
+            #print 'Hardcopy <%s>' % filename  # dbg
+            maxtries = 20
+            delay = 0.1  # delay (in seconds) between print attempts
+            for i in range(maxtries):
+                time.sleep(0.05)  # safety, very small delay
+                if os.path.isfile(filename):
+                    if debug:
+                        print 'Hardcopy to file <%s> success at attempt #%s.' \
+                        % (filename,i+1)
+                    break
+                time.sleep(delay)
+                # try again, issue all commands just in case
+                self(string.join(setterm))
+                self.set_string('output', filename)
+                self.refresh()
+            if not os.path.isfile(filename):
+                print >> sys.stderr,'ERROR: Tried %s times and failed to '\
+                'create hardcopy file `%s`' % (maxtries,filename)
+
+        # reset the terminal to its `default' setting:
+        self('set terminal %s' % gp.GnuplotOpts.default_term)
+        self.set_string('output')
+
+#********************** End of file <Gnuplot2.py> ************************
diff --git a/IPython/GnuplotInteractive.py b/IPython/GnuplotInteractive.py
new file mode 100644
index 0000000..988d4e6
--- /dev/null
+++ b/IPython/GnuplotInteractive.py
@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+"""Interactive functions and magic functions for Gnuplot usage.
+
+This requires the Gnuplot.py module for interfacing python with Gnuplot, which
+can be downloaded from:
+
+http://gnuplot-py.sourceforge.net/
+
+See gphelp() below for details on the services offered by this module.
+
+Inspired by a suggestion/request from Arnd Baecker.
+
+$Id: GnuplotInteractive.py 389 2004-10-09 07:59:30Z fperez $"""
+
+__all__ = ['Gnuplot','gp','gp_new','plot','plot2','splot','replot',
+           'hardcopy','gpdata','gpfile','gpstring','gpfunc','gpgrid',
+           'gphelp']
+
+import IPython.GnuplotRuntime as GRun
+from IPython.genutils import page,warn
+
+# Set global names for interactive use
+Gnuplot  = GRun.Gnuplot
+gp_new   = GRun.gp_new
+gp       = GRun.gp
+plot     = gp.plot
+plot2    = gp.plot2
+splot    = gp.splot
+replot   = gp.replot
+hardcopy = gp.hardcopy
+
+# Accessors for the main plot object constructors:
+gpdata   = Gnuplot.Data
+gpfile   = Gnuplot.File
+gpstring = Gnuplot.String
+gpfunc   = Gnuplot.Func
+gpgrid   = Gnuplot.GridData
+
+def gphelp():
+    """Print information about the Gnuplot facilities in IPython."""
+
+    page("""
+IPython provides an interface to access the Gnuplot scientific plotting
+system, in an environment similar to that of Mathematica or Matlab.
+
+New top-level global objects
+----------------------------
+
+Please see their respective docstrings for further details.
+
+- gp: a running Gnuplot instance. You can access its methods as
+gp.<method>. gp(`a string`) will execute the given string as if it had been
+typed in an interactive gnuplot window.
+
+- plot, splot, replot and hardcopy: aliases to the methods of the same name in
+the global running Gnuplot instance gp. These allow you to simply type:
+
+In [1]: plot(x,sin(x),title='Sin(x)')  # assuming x is a Numeric array
+
+and obtain a plot of sin(x) vs x with the title 'Sin(x)'.
+
+- gp_new: a function which returns a new Gnuplot instance. This can be used to
+have multiple Gnuplot instances running in your session to compare different
+plots, each in a separate window.
+
+- Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
+the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
+functions with improved versions (Gnuplot2 comes with IPython).
+
+- gpdata, gpfile, gpstring, gpfunc, gpgrid: aliases to Gnuplot.Data,
+Gnuplot.File, Gnuplot.String, Gnuplot.Func and Gnuplot.GridData
+respectively. These functions create objects which can then be passed to the
+plotting commands. See the Gnuplot.py documentation for details.
+
+Keep in mind that all commands passed to a Gnuplot instance are executed in
+the Gnuplot namespace, where no Python variables exist. For example, for
+plotting sin(x) vs x as above, typing
+
+In [2]: gp('plot x,sin(x)')
+
+would not work. Instead, you would get the plot of BOTH the functions 'x' and
+'sin(x)', since Gnuplot doesn't know about the 'x' Python array. The plot()
+method lives in python and does know about these variables.
+
+
+New magic functions
+-------------------
+
+%gpc: pass one command to Gnuplot and execute it or open a Gnuplot shell where
+each line of input is executed.
+
+%gp_set_default: reset the value of IPython's global Gnuplot instance.""")
+    
+# Code below is all for IPython use
+# Define the magic functions for communicating with the above gnuplot instance.
+def magic_gpc(self,parameter_s=''):
+    """Execute a gnuplot command or open a gnuplot shell.
+
+    Usage (omit the % if automagic is on). There are two ways to use it:
+
+      1) %gpc 'command' -> passes 'command' directly to the gnuplot instance.
+
+      2) %gpc -> will open up a prompt (gnuplot>>>) which takes input like the
+      standard gnuplot interactive prompt. If you need to type a multi-line
+      command, use \\ at the end of each intermediate line.
+
+      Upon exiting of the gnuplot sub-shell, you return to your IPython
+      session (the gnuplot sub-shell can be invoked as many times as needed).
+      """
+
+    if parameter_s.strip():
+        self.shell.gnuplot(parameter_s)
+    else:
+        self.shell.gnuplot.interact()
+
+def magic_gp_set_default(self,parameter_s=''):
+    """Set the default gnuplot instance accessed by the %gp magic function.
+
+    %gp_set_default name
+
+    Call with the name of the new instance at the command line. If you want to
+    set this instance in your own code (using an embedded IPython, for
+    example), simply set the variable __IPYTHON__.gnuplot to your own gnuplot
+    instance object."""
+
+    gname = parameter_s.strip()
+    G = eval(gname,self.shell.user_ns)
+    self.shell.gnuplot = G
+    self.shell.user_ns.update({'plot':G.plot,'splot':G.splot,'plot2':G.plot2,
+                               'replot':G.replot,'hardcopy':G.hardcopy})
+
+try:
+    __IPYTHON__
+except NameError:
+    pass
+else:
+    # make the global Gnuplot instance known to IPython
+    __IPYTHON__.gnuplot = GRun.gp
+    __IPYTHON__.gnuplot.shell_first_time = 1
+
+    print """*** Type `gphelp` for help on the Gnuplot integration features."""
+
+    # Add the new magic functions to the class dict
+    from IPython.iplib import InteractiveShell
+    InteractiveShell.magic_gpc = magic_gpc
+    InteractiveShell.magic_gp_set_default = magic_gp_set_default
+
+#********************** End of file <GnuplotInteractive.py> *******************
diff --git a/IPython/GnuplotRuntime.py b/IPython/GnuplotRuntime.py
new file mode 100644
index 0000000..2c5e660
--- /dev/null
+++ b/IPython/GnuplotRuntime.py
@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+"""Basic Gnuplot functionality for inclusion in other code.
+
+This module creates a running Gnuplot instance called 'gp' and builds other
+convenient globals for quick use in running scripts. It is intended to allow
+you to script plotting tasks in Python with a minimum of effort. A typical
+usage would be:
+
+import IPython.GnuplotRuntime as GP  # or some other short name
+GP.gp.plot(GP.File('your_data.dat'))
+
+
+This module exposes the following objects:
+
+- gp: a running Gnuplot instance. You can access its methods as
+gp.<method>. gp(`a string`) will execute the given string as if it had been
+typed in an interactive gnuplot window.
+
+- gp_new: a function which returns a new Gnuplot instance. This can be used to
+have multiple Gnuplot instances running in your session to compare different
+plots.
+
+- Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
+the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
+functions with improved versions (Gnuplot2 comes with IPython).
+
+- Data: alias to Gnuplot.Data, makes a PlotItem from array data.
+
+- File: alias to Gnuplot.File, makes a PlotItem from a file.
+
+- String: alias to Gnuplot.String, makes a PlotItem from a string formatted
+exactly like a file for Gnuplot.File would be.
+
+- Func: alias to Gnuplot.Func, makes a PlotItem from a function string.
+
+- GridData: alias to Gnuplot.GridData, makes a PlotItem from grid data.
+
+- pm3d_config: a string with Gnuplot commands to set up the pm3d mode for
+surface plotting. You can activate it simply by calling gp(pm3d_config).
+
+- eps_fix_bbox: A Unix-only function to fix eps files with bad bounding boxes
+(which Gnuplot generates when the plot size is set to square).
+
+This requires the Gnuplot.py module for interfacing Python with Gnuplot, which
+can be downloaded from:
+
+http://gnuplot-py.sourceforge.net/
+
+Inspired by a suggestion/request from Arnd Baecker.
+
+$Id: GnuplotRuntime.py 389 2004-10-09 07:59:30Z fperez $"""
+
+__all__ = ['Gnuplot','gp','gp_new','Data','File','Func','GridData',
+           'pm3d_config','eps_fix_bbox']
+
+import os,tempfile,sys
+from IPython.genutils import getoutput
+
+#---------------------------------------------------------------------------
+# Notes on mouse support for Gnuplot.py
+
+# If you do not have a mouse-enabled gnuplot, set gnuplot_mouse to 0. If you
+# use gnuplot, you should really grab a recent, mouse enabled copy. It is an
+# extremely useful feature.  Mouse support is official as of gnuplot 4.0,
+# released in April 2004.
+
+# For the mouse features to work correctly, you MUST set your Gnuplot.py
+# module to use temporary files instead of 'inline data' for data
+# communication. Note that this is the default, so unless you've manually
+# fiddled with it you should be ok. If you need to make changes, in the
+# Gnuplot module directory, loook for the gp_unix.py file and make sure the
+# prefer_inline_data variable is set to 0. If you set it to 1 Gnuplot.py will
+# try to pass the data to gnuplot via standard input, which completely
+# confuses the mouse control system (even though it may be a bit faster than
+# using temp files).
+
+# As of Gnuplot.py v1.7, a new option was added to use FIFOs (pipes).  This
+# mechanism, while fast, also breaks the mouse system.  You must therefore set
+# the variable prefer_fifo_data to 0 in gp_unix.py.
+
+tmpname = tempfile.mktemp()
+open(tmpname,'w').write('set mouse')
+gnu_out = getoutput('gnuplot '+ tmpname)
+os.unlink(tmpname)
+if gnu_out:  # Gnuplot won't print anything if it has mouse support
+    print "*** Your version of Gnuplot appears not to have mouse support."
+    gnuplot_mouse = 0
+else:
+    gnuplot_mouse = 1
+del tmpname,gnu_out
+
+# Default state for persistence of new gnuplot instances
+if os.name in ['nt','dos'] or sys.platform == 'cygwin':
+    gnuplot_persist = 0
+else:
+    gnuplot_persist = 1
+
+import IPython.Gnuplot2 as Gnuplot
+
+class NotGiven: pass
+
+def gp_new(mouse=NotGiven,persist=NotGiven):
+    """Return a new Gnuplot instance.
+
+    The instance returned uses the improved methods defined in Gnuplot2.
+
+    Options (boolean):
+
+    - mouse: if unspecified, the module global gnuplot_mouse is used.
+
+    - persist: if unspecified, the module global gnuplot_persist is used."""
+    
+    if mouse is NotGiven:
+        mouse = gnuplot_mouse
+    if persist is NotGiven:
+        persist = gnuplot_persist
+    g = Gnuplot.Gnuplot(persist=persist)
+    if mouse:
+        g('set mouse')
+    return g
+
+# Global-level names.
+
+# A global Gnuplot instance for interactive use:
+gp = gp_new()
+
+# Accessors for the main plot object constructors:
+Data = Gnuplot.Data
+File = Gnuplot.File
+Func = Gnuplot.Func
+String = Gnuplot.String
+GridData = Gnuplot.GridData
+
+# A Unix-only function to fix eps files with bad bounding boxes (which Gnuplot
+# generates when the plot size is set to square):
+eps_fix_bbox = Gnuplot.eps_fix_bbox
+
+# String for configuring pm3d. Simply call g(pm3d_config) to execute it.  pm3d
+# is a very nice mode for plotting colormaps on surfaces. Modify the defaults
+# below to suit your taste.
+pm3d_config = """
+set pm3d solid
+set hidden3d
+unset surface
+set isosamples 50
+"""
+#******************** End of file <GnuplotRuntime.py> ******************
diff --git a/IPython/Itpl.py b/IPython/Itpl.py
new file mode 100644
index 0000000..4d60dcb
--- /dev/null
+++ b/IPython/Itpl.py
@@ -0,0 +1,284 @@
+# -*- coding: utf-8 -*-
+"""String interpolation for Python (by Ka-Ping Yee, 14 Feb 2000).
+
+This module lets you quickly and conveniently interpolate values into
+strings (in the flavour of Perl or Tcl, but with less extraneous
+punctuation).  You get a bit more power than in the other languages,
+because this module allows subscripting, slicing, function calls,
+attribute lookup, or arbitrary expressions.  Variables and expressions
+are evaluated in the namespace of the caller.
+
+The itpl() function returns the result of interpolating a string, and
+printpl() prints out an interpolated string.  Here are some examples:
+
+    from Itpl import printpl
+    printpl("Here is a $string.")
+    printpl("Here is a $module.member.")
+    printpl("Here is an $object.member.")
+    printpl("Here is a $functioncall(with, arguments).")
+    printpl("Here is an ${arbitrary + expression}.")
+    printpl("Here is an $array[3] member.")
+    printpl("Here is a $dictionary['member'].")
+
+The filter() function filters a file object so that output through it
+is interpolated.  This lets you produce the illusion that Python knows
+how to do interpolation:
+
+    import Itpl
+    sys.stdout = Itpl.filter()
+    f = "fancy"
+    print "Isn't this $f?"
+    print "Standard output has been replaced with a $sys.stdout object."
+    sys.stdout = Itpl.unfilter()
+    print "Okay, back $to $normal."
+
+Under the hood, the Itpl class represents a string that knows how to
+interpolate values.  An instance of the class parses the string once
+upon initialization; the evaluation and substitution can then be done
+each time the instance is evaluated with str(instance).  For example:
+
+    from Itpl import Itpl
+    s = Itpl("Here is $foo.")
+    foo = 5
+    print str(s)
+    foo = "bar"
+    print str(s)
+
+$Id: Itpl.py 2918 2007-12-31 14:34:47Z vivainio $
+"""                   # ' -> close an open quote for stupid emacs
+
+#*****************************************************************************
+#
+# Copyright (c) 2001 Ka-Ping Yee <ping@lfw.org>
+#
+#
+# Published under the terms of the MIT license, hereby reproduced:
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+#*****************************************************************************
+
+__author__  = 'Ka-Ping Yee <ping@lfw.org>'
+__license__ = 'MIT'
+
+import string
+import sys
+from tokenize import tokenprog
+from types import StringType
+
+class ItplError(ValueError):
+    def __init__(self, text, pos):
+        self.text = text
+        self.pos = pos
+    def __str__(self):
+        return "unfinished expression in %s at char %d" % (
+            repr(self.text), self.pos)
+
+def matchorfail(text, pos):
+    match = tokenprog.match(text, pos)
+    if match is None:
+        raise ItplError(text, pos)
+    return match, match.end()
+
+class Itpl:
+    """Class representing a string with interpolation abilities.
+    
+    Upon creation, an instance works out what parts of the format
+    string are literal and what parts need to be evaluated.  The
+    evaluation and substitution happens in the namespace of the
+    caller when str(instance) is called."""
+
+    def __init__(self, format,codec=sys.stdin.encoding,encoding_errors='backslashreplace'):
+        """The single mandatory argument to this constructor is a format
+        string.
+
+        The format string is parsed according to the following rules:
+
+        1.  A dollar sign and a name, possibly followed by any of: 
+              - an open-paren, and anything up to the matching paren 
+              - an open-bracket, and anything up to the matching bracket 
+              - a period and a name 
+            any number of times, is evaluated as a Python expression.
+
+        2.  A dollar sign immediately followed by an open-brace, and
+            anything up to the matching close-brace, is evaluated as
+            a Python expression.
+
+        3.  Outside of the expressions described in the above two rules,
+            two dollar signs in a row give you one literal dollar sign.
+
+        Optional arguments:
+
+        - codec('utf_8'): a string containing the name of a valid Python
+        codec.
+
+        - encoding_errors('backslashreplace'): a string with a valid error handling
+        policy.  See the codecs module documentation for details.
+
+        These are used to encode the format string if a call to str() fails on
+        the expanded result."""
+
+        if not isinstance(format,basestring):
+            raise TypeError, "needs string initializer"
+        self.format = format
+        self.codec = codec
+        self.encoding_errors = encoding_errors
+        
+        namechars = "abcdefghijklmnopqrstuvwxyz" \
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
+        chunks = []
+        pos = 0
+
+        while 1:
+            dollar = string.find(format, "$", pos)
+            if dollar < 0: break
+            nextchar = format[dollar+1]
+
+            if nextchar == "{":
+                chunks.append((0, format[pos:dollar]))
+                pos, level = dollar+2, 1
+                while level:
+                    match, pos = matchorfail(format, pos)
+                    tstart, tend = match.regs[3]
+                    token = format[tstart:tend]
+                    if token == "{": level = level+1
+                    elif token == "}": level = level-1
+                chunks.append((1, format[dollar+2:pos-1]))
+
+            elif nextchar in namechars:
+                chunks.append((0, format[pos:dollar]))
+                match, pos = matchorfail(format, dollar+1)
+                while pos < len(format):
+                    if format[pos] == "." and \
+                        pos+1 < len(format) and format[pos+1] in namechars:
+                        match, pos = matchorfail(format, pos+1)
+                    elif format[pos] in "([":
+                        pos, level = pos+1, 1
+                        while level:
+                            match, pos = matchorfail(format, pos)
+                            tstart, tend = match.regs[3]
+                            token = format[tstart:tend]
+                            if token[0] in "([": level = level+1
+                            elif token[0] in ")]": level = level-1
+                    else: break
+                chunks.append((1, format[dollar+1:pos]))
+
+            else:
+                chunks.append((0, format[pos:dollar+1]))
+                pos = dollar + 1 + (nextchar == "$")
+
+        if pos < len(format): chunks.append((0, format[pos:]))
+        self.chunks = chunks
+
+    def __repr__(self):
+        return "<Itpl %s >" % repr(self.format)
+
+    def _str(self,glob,loc):
+        """Evaluate to a string in the given globals/locals.
+
+        The final output is built by calling str(), but if this fails, the
+        result is encoded with the instance's codec and error handling policy,
+        via a call to out.encode(self.codec,self.encoding_errors)"""
+        result = []
+        app = result.append
+        for live, chunk in self.chunks:
+            if live:
+                val = eval(chunk,glob,loc)
+                try:
+                    app(str(val))
+                except UnicodeEncodeError:
+                    app(unicode(val))
+                
+            else: app(chunk)
+        out = ''.join(result)
+        try:
+            return str(out)
+        except UnicodeError:
+            return out.encode(self.codec,self.encoding_errors)
+
+    def __str__(self):
+        """Evaluate and substitute the appropriate parts of the string."""
+
+        # We need to skip enough frames to get to the actual caller outside of
+        # Itpl.
+        frame = sys._getframe(1)
+        while frame.f_globals["__name__"] == __name__: frame = frame.f_back
+        loc, glob = frame.f_locals, frame.f_globals
+
+        return self._str(glob,loc)
+    
+class ItplNS(Itpl):
+    """Class representing a string with interpolation abilities.
+
+    This inherits from Itpl, but at creation time a namespace is provided
+    where the evaluation will occur.  The interpolation becomes a bit more
+    efficient, as no traceback needs to be extracte.  It also allows the
+    caller to supply a different namespace for the interpolation to occur than
+    its own."""
+    
+    def __init__(self, format,globals,locals=None,
+                 codec='utf_8',encoding_errors='backslashreplace'):
+        """ItplNS(format,globals[,locals]) -> interpolating string instance.
+
+        This constructor, besides a format string, takes a globals dictionary
+        and optionally a locals (which defaults to globals if not provided).
+
+        For further details, see the Itpl constructor."""
+
+        if locals is None:
+            locals = globals
+        self.globals = globals
+        self.locals = locals
+        Itpl.__init__(self,format,codec,encoding_errors)
+        
+    def __str__(self):
+        """Evaluate and substitute the appropriate parts of the string."""
+        return self._str(self.globals,self.locals)
+
+    def __repr__(self):
+        return "<ItplNS %s >" % repr(self.format)
+
+# utilities for fast printing
+def itpl(text): return str(Itpl(text))
+def printpl(text): print itpl(text)
+# versions with namespace
+def itplns(text,globals,locals=None): return str(ItplNS(text,globals,locals))
+def printplns(text,globals,locals=None): print itplns(text,globals,locals)
+
+class ItplFile:
+    """A file object that filters each write() through an interpolator."""
+    def __init__(self, file): self.file = file
+    def __repr__(self): return "<interpolated " + repr(self.file) + ">"
+    def __getattr__(self, attr): return getattr(self.file, attr)
+    def write(self, text): self.file.write(str(Itpl(text)))
+
+def filter(file=sys.stdout):
+    """Return an ItplFile that filters writes to the given file object.
+    
+    'file = filter(file)' replaces 'file' with a filtered object that
+    has a write() method.  When called with no argument, this creates
+    a filter to sys.stdout."""
+    return ItplFile(file)
+
+def unfilter(ifile=None):
+    """Return the original file that corresponds to the given ItplFile.
+    
+    'file = unfilter(file)' undoes the effect of 'file = filter(file)'.
+    'sys.stdout = unfilter()' undoes the effect of 'sys.stdout = filter()'."""
+    return ifile and ifile.file or sys.stdout.file
diff --git a/IPython/Logger.py b/IPython/Logger.py
new file mode 100644
index 0000000..83ca6fa
--- /dev/null
+++ b/IPython/Logger.py
@@ -0,0 +1,270 @@
+# -*- coding: utf-8 -*-
+"""
+Logger class for IPython's logging facilities.
+
+$Id: Logger.py 2875 2007-11-26 08:37:39Z fperez $
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  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 glob
+import os
+import time
+
+#****************************************************************************
+# FIXME: This class isn't a mixin anymore, but it still needs attributes from
+# ipython and does input cache management.  Finish cleanup later...
+
+class Logger(object):
+    """A Logfile class with different policies for file creation"""
+
+    def __init__(self,shell,logfname='Logger.log',loghead='',logmode='over'):
+
+        self._i00,self._i,self._ii,self._iii = '','','',''
+
+        # this is the full ipython instance, we need some attributes from it
+        # which won't exist until later. What a mess, clean up later...
+        self.shell = shell
+
+        self.logfname = logfname
+        self.loghead = loghead
+        self.logmode = logmode
+        self.logfile = None
+
+        # Whether to log raw or processed input
+        self.log_raw_input = False
+
+        # whether to also log output
+        self.log_output = False
+
+        # whether to put timestamps before each log entry
+        self.timestamp = False
+
+        # activity control flags
+        self.log_active = False
+
+    # logmode is a validated property
+    def _set_mode(self,mode):
+        if mode not in ['append','backup','global','over','rotate']:
+            raise ValueError,'invalid log mode %s given' % mode
+        self._logmode = mode
+
+    def _get_mode(self):
+        return self._logmode
+
+    logmode = property(_get_mode,_set_mode)
+    
+    def logstart(self,logfname=None,loghead=None,logmode=None,
+                 log_output=False,timestamp=False,log_raw_input=False):
+        """Generate a new log-file with a default header.
+
+        Raises RuntimeError if the log has already been started"""
+
+        if self.logfile is not None:
+            raise RuntimeError('Log file is already active: %s' %
+                               self.logfname)
+        
+        self.log_active = True
+
+        # The parameters can override constructor defaults
+        if logfname is not None: self.logfname = logfname
+        if loghead is not None: self.loghead = loghead
+        if logmode is not None: self.logmode = logmode
+
+        # Parameters not part of the constructor
+        self.timestamp = timestamp
+        self.log_output = log_output
+        self.log_raw_input = log_raw_input
+        
+        # init depending on the log mode requested
+        isfile = os.path.isfile
+        logmode = self.logmode
+
+        if logmode == 'append':
+            self.logfile = open(self.logfname,'a')
+
+        elif logmode == 'backup':
+            if isfile(self.logfname):
+                backup_logname = self.logfname+'~'
+                # Manually remove any old backup, since os.rename may fail
+                # under Windows.
+                if isfile(backup_logname):
+                    os.remove(backup_logname)
+                os.rename(self.logfname,backup_logname)
+            self.logfile = open(self.logfname,'w')
+
+        elif logmode == 'global':
+            self.logfname = os.path.join(self.shell.home_dir,self.logfname)
+            self.logfile = open(self.logfname, 'a')
+
+        elif logmode == 'over':
+            if isfile(self.logfname):
+                os.remove(self.logfname) 
+            self.logfile = open(self.logfname,'w')
+
+        elif logmode == 'rotate':
+            if isfile(self.logfname):
+                if isfile(self.logfname+'.001~'): 
+                    old = glob.glob(self.logfname+'.*~')
+                    old.sort()
+                    old.reverse()
+                    for f in old:
+                        root, ext = os.path.splitext(f)
+                        num = int(ext[1:-1])+1
+                        os.rename(f, root+'.'+`num`.zfill(3)+'~')
+                os.rename(self.logfname, self.logfname+'.001~')
+            self.logfile = open(self.logfname,'w')
+            
+        if logmode != 'append':
+            self.logfile.write(self.loghead)
+
+        self.logfile.flush()
+
+    def switch_log(self,val):
+        """Switch logging on/off. val should be ONLY a boolean."""
+
+        if val not in [False,True,0,1]:
+            raise ValueError, \
+                  'Call switch_log ONLY with a boolean argument, not with:',val
+        
+        label = {0:'OFF',1:'ON',False:'OFF',True:'ON'}
+
+        if self.logfile is None:
+            print """
+Logging hasn't been started yet (use logstart for that).
+
+%logon/%logoff are for temporarily starting and stopping logging for a logfile
+which already exists. But you must first start the logging process with
+%logstart (optionally giving a logfile name)."""
+            
+        else:
+            if self.log_active == val:
+                print 'Logging is already',label[val]
+            else:
+                print 'Switching logging',label[val]
+                self.log_active = not self.log_active
+                self.log_active_out = self.log_active
+
+    def logstate(self):
+        """Print a status message about the logger."""
+        if self.logfile is None:
+            print 'Logging has not been activated.'
+        else:
+            state = self.log_active and 'active' or 'temporarily suspended'
+            print 'Filename       :',self.logfname
+            print 'Mode           :',self.logmode
+            print 'Output logging :',self.log_output
+            print 'Raw input log  :',self.log_raw_input
+            print 'Timestamping   :',self.timestamp
+            print 'State          :',state
+
+    def log(self,line_ori,line_mod,continuation=None):
+        """Write the line to a log and create input cache variables _i*.
+
+        Inputs:
+
+        - line_ori: unmodified input line from the user.  This is not
+        necessarily valid Python.
+
+        - line_mod: possibly modified input, such as the transformations made
+        by input prefilters or input handlers of various kinds.  This should
+        always be valid Python.
+
+        - continuation: if True, indicates this is part of multi-line input."""
+
+        # update the auto _i tables
+        #print '***logging line',line_mod # dbg
+        #print '***cache_count', self.shell.outputcache.prompt_count # dbg
+        try:
+            input_hist = self.shell.user_ns['_ih']
+        except:
+            print 'userns:',self.shell.user_ns.keys()
+            return
+        
+        out_cache = self.shell.outputcache
+
+        # add blank lines if the input cache fell out of sync.
+        if out_cache.do_full_cache and \
+            out_cache.prompt_count +1 > len(input_hist):
+            input_hist.extend(['\n'] * (out_cache.prompt_count - len(input_hist)))
+            
+        if not continuation and line_mod:
+            self._iii = self._ii
+            self._ii = self._i
+            self._i = self._i00
+            # put back the final \n of every input line
+            self._i00 = line_mod+'\n'
+            #print 'Logging input:<%s>' % line_mod  # dbg
+            input_hist.append(self._i00)
+        #print '---[%s]' % (len(input_hist)-1,) # dbg
+
+        # hackish access to top-level namespace to create _i1,_i2... dynamically
+        to_main = {'_i':self._i,'_ii':self._ii,'_iii':self._iii}
+        if self.shell.outputcache.do_full_cache:
+            in_num = self.shell.outputcache.prompt_count
+
+            # but if the opposite is true (a macro can produce multiple inputs
+            # with no output display called), then bring the output counter in
+            # sync:
+            last_num = len(input_hist)-1
+            if in_num != last_num:
+                in_num = self.shell.outputcache.prompt_count = last_num
+            new_i = '_i%s' % in_num
+            if continuation:
+                self._i00 = '%s%s\n' % (self.shell.user_ns[new_i],line_mod)
+                input_hist[in_num] = self._i00
+            to_main[new_i] = self._i00
+        self.shell.user_ns.update(to_main)
+
+        # Write the log line, but decide which one according to the
+        # log_raw_input flag, set when the log is started.
+        if self.log_raw_input:
+            self.log_write(line_ori)
+        else:
+            self.log_write(line_mod)
+
+    def log_write(self,data,kind='input'):
+        """Write data to the log file, if active"""
+
+        #print 'data: %r' % data # dbg
+        if self.log_active and data:
+            write = self.logfile.write
+            if kind=='input':
+                if self.timestamp:
+                    write(time.strftime('# %a, %d %b %Y %H:%M:%S\n',
+                                        time.localtime()))
+                write('%s\n' % data)
+            elif kind=='output' and self.log_output:
+                odata = '\n'.join(['#[Out]# %s' % s
+                                   for s in data.split('\n')])
+                write('%s\n' % odata)
+            self.logfile.flush()
+
+    def logstop(self):
+        """Fully stop logging and close log file.
+
+        In order to start logging again, a new logstart() call needs to be
+        made, possibly (though not necessarily) with a new filename, mode and
+        other options."""
+        
+        self.logfile.close()
+        self.logfile = None
+        self.log_active = False
+
+    # For backwards compatibility, in case anyone was using this.
+    close_log = logstop
diff --git a/IPython/Magic.py b/IPython/Magic.py
new file mode 100644
index 0000000..9045b79
--- /dev/null
+++ b/IPython/Magic.py
@@ -0,0 +1,3283 @@
+# -*- coding: utf-8 -*-
+"""Magic functions for InteractiveShell.
+
+$Id: Magic.py 2996 2008-01-30 06:31:39Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  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 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
+from sets import Set
+
+# cProfile was added in Python2.5
+try:
+    import cProfile as profile
+    import pstats
+except ImportError:
+    # 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
+import IPython.generics
+import IPython.ipapi
+from IPython.ipapi import UsageError
+#***************************************************************************
+# 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
+
+def compress_dhist(dh):
+    head, tail = dh[:-10], dh[-10:]
+
+    newhead = []
+    done = Set()
+    for h in head:
+        if h in done:
+            continue
+        newhead.append(h)
+        done.add(h)
+
+    return newhead + tail        
+        
+
+#***************************************************************************
+# 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, namespaces=None):
+        """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()
+
+        alias_ns = None
+        if namespaces is None:
+            # Namespaces to search in:
+            # Put them in a list. The order is important so that we
+            # find things in the same order that Python finds them.
+            namespaces = [ ('Interactive', self.shell.user_ns),
+                           ('IPython internal', self.shell.internal_ns),
+                           ('Python builtin', __builtin__.__dict__),
+                           ('Alias', self.shell.alias_table),
+                           ]
+            alias_ns = self.shell.alias_table
+
+        # 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:
+                #print 'oname_rest:', oname_rest  # dbg
+                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.
+
+          -posix (True): whether to split the input line in POSIX mode or not,
+          as per the conventions outlined in the shlex module from the
+          standard library."""
+ 
+        # 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)
+        posix = kw.get('posix',True)
+
+        # 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 = arg_split(arg_str,posix)
+            # Do regular option processing
+            try:
+                opts,args = getopt(argv,opt_str,*long_opts)
+            except GetoptError,e:
+                raise UsageError('%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_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_automagic(self, parameter_s = ''):
+        """Make magic functions callable without having to type the initial %.
+
+        Without argumentsl toggles on/off (when off, you must call it as
+        %automagic, of course).  With arguments it sets the value, and you can
+        use any of (case insensitive):
+
+         - on,1,True: to activate
+
+         - off,0,False: to deactivate.
+
+        Note that magic functions have lowest priority, so if there's a
+        variable whose name collides with that of a magic fn, automagic won't
+        work for that function (you get the variable instead). However, if you
+        delete the variable (del var), the previously shadowed magic function
+        becomes visible to automagic again."""
+
+        rc = self.shell.rc
+        arg = parameter_s.lower()
+        if parameter_s in ('on','1','true'):
+            rc.automagic = True
+        elif parameter_s in ('off','0','false'):
+            rc.automagic = False
+        else:
+            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).
+
+        In more detail, these values mean:
+
+        0 -> fully disabled
+
+        1 -> active, but do not apply if there are no arguments on the line.
+
+        In this mode, you get:
+
+        In [1]: callable
+        Out[1]: <built-in function callable>
+
+        In [2]: callable 'hello'
+        ------> callable('hello')
+        Out[2]: False
+
+        2 -> Active always.  Even if no arguments are present, the callable
+        object is called:
+
+        In [4]: callable
+        ------> callable()
+
+        Note that even with autocall off, you can still use '/' at the start of
+        a line to treat the first argument on the command line as a function
+        and add parentheses to it:
+
+        In [8]: /str 43
+        ------> str(43)
+        Out[8]: '43'
+        """
+
+        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_system_verbose(self, parameter_s = ''):
+        """Set verbose printing of system calls.
+
+        If called without an argument, act as a toggle"""
+
+        if parameter_s:
+            val = bool(eval(parameter_s))
+        else:
+            val = None
+            
+        self.shell.rc_set_toggle('system_verbose',val)
+        print "System verbose printing is:",\
+              ['OFF','ON'][self.shell.rc.system_verbose]
+
+
+    def magic_page(self, parameter_s=''):
+        """Pretty print the object and display it through a pager.
+        
+        %page [options] OBJECT
+
+        If no object is given, use _ (last output).
+        
+        Options:
+
+          -r: page str(object), don't pretty-print it."""
+
+        # After a function contributed by Olivier Aubert, slightly modified.
+
+        # Process options/args
+        opts,args = self.parse_options(parameter_s,'r')
+        raw = 'r' in opts
+
+        oname = args and args or '_'
+        info = self._ofind(oname)
+        if info['found']:
+            txt = (raw and str or pformat)( info['obj'] )
+            page(txt)
+        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 magic_pinfo(self, parameter_s='', namespaces=None):
+        """Provide detailed information about an object.
+    
+        '%pinfo object' is just a synonym for object? or ?object."""
+    
+        #print 'pinfo par: <%s>' % parameter_s  # dbg
+    
+        
+        # detail_level: 0 -> obj? , 1 -> obj??
+        detail_level = 0
+        # We need to detect if we got called as 'pinfo pinfo foo', which can
+        # happen if the user types 'pinfo foo?' at the cmd line.
+        pinfo,qmark1,oname,qmark2 = \
+               re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
+        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,
+                          namespaces=namespaces)
+
+    def magic_pdef(self, parameter_s='', namespaces=None):
+        """Print the definition header for any callable object.
+
+        If the object is a class, print the constructor information."""
+        self._inspect('pdef',parameter_s, namespaces)
+
+    def magic_pdoc(self, parameter_s='', namespaces=None):
+        """Print the docstring for an object.
+
+        If the given object is a class, it will print both the class and the
+        constructor docstrings."""
+        self._inspect('pdoc',parameter_s, namespaces)
+
+    def magic_psource(self, parameter_s='', namespaces=None):
+        """Print (or run through pager) the source code for an object."""
+        self._inspect('psource',parameter_s, namespaces)
+
+    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 _inspect(self,meth,oname,namespaces=None,**kw):
+        """Generic interface to the inspector system.
+
+        This function is meant to be called by pdef, pdoc & friends."""
+
+        #oname = oname.strip()
+        #print '1- oname: <%r>' % oname  # dbg
+        try:
+            oname = oname.strip().encode('ascii')
+            #print '2- oname: <%r>' % oname  # dbg
+        except UnicodeEncodeError:
+            print 'Python identifiers can only contain ascii characters.'
+            return 'not found'
+            
+        info = Struct(self._ofind(oname, namespaces))
+        
+        if info.found:
+            try:
+                IPython.generics.inspect_object(info.obj)
+                return
+            except IPython.ipapi.TryNext:
+                pass
+            # 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_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"""
+        try:
+            parameter_s = parameter_s.encode('ascii')
+        except UnicodeEncodeError:
+            print 'Python identifiers can only contain ascii characters.'
+            return
+
+        # 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:
+            if parameter_s:
+                print 'No variables match your requested type.'
+            else:
+                print 'Interactive namespace is empty.'
+            return
+
+        # if we have variables, move on...
+        count = 0
+        for i in varlist:
+            print i+'\t',
+            count += 1
+            if count > 8:
+                count = 0
+                print
+        print
+
+    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 numpy and Numeric arrays, a summary with shape, number of
+          elements, typecode and size in memory.
+
+          - Everything else: a string representation, snipping their middle if
+          too long."""
+        
+        varnames = self.magic_who_ls(parameter_s)
+        if not varnames:
+            if parameter_s:
+                print 'No variables match your requested type.'
+            else:
+                print 'Interactive namespace is empty.'
+            return
+
+        # if we have variables, move on...
+
+        # for these types, show len() instead of data:
+        seq_types = [types.DictType,types.ListType,types.TupleType]
+
+        # for numpy/Numeric arrays, display summary info
+        try:
+            import numpy
+        except ImportError:
+            ndarray_type = None
+        else:
+            ndarray_type = numpy.ndarray.__name__
+        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
+        def get_vars(i):
+            return self.shell.user_ns[i]
+        
+        # some types are well known and can be shorter
+        abbrevs = {'IPython.macro.Macro' : 'Macro'}
+        def type_name(v):
+            tn = type(v).__name__
+            return abbrevs.get(tn,tn)
+            
+        varlist = map(get_vars,varnames)
+
+        typelist = []
+        for vv in varlist:
+            tt = type_name(vv)
+
+            if tt=='instance':
+                typelist.append( abbrevs.get(str(vv.__class__),
+                                             str(vv.__class__)))
+            else:
+                typelist.append(tt)
+
+        # column labels and # of spaces as separator
+        varlabel = 'Variable'
+        typelabel = 'Type'
+        datalabel = 'Data/Info'
+        colsep = 3
+        # variable format strings
+        vformat    = "$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 in [array_type,ndarray_type]:
+                vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
+                if vtype==ndarray_type:
+                    # numpy
+                    vsize  = var.size
+                    vbytes = vsize*var.itemsize
+                    vdtype = var.dtype
+                else:
+                    # Numeric
+                    vsize  = Numeric.size(var)
+                    vbytes = vsize*var.itemsize()
+                    vdtype = var.typecode()
+                    
+                if vbytes < 100000:
+                    print aformat % (vshape,vsize,vdtype,vbytes)
+                else:
+                    print aformat % (vshape,vsize,vdtype,vbytes),
+                    if vbytes < Mb:
+                        print '(%s kb)' % (vbytes/kb,)
+                    else:
+                        print '(%s Mb)' % (vbytes/Mb,)
+            else:
+                try:
+                    vstr = str(var)
+                except UnicodeEncodeError:
+                    vstr = unicode(var).encode(sys.getdefaultencoding(),
+                                               'backslashreplace')
+                vstr = vstr.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])
+            
+        # Also flush the private list of module references kept for script
+        # execution protection
+        self.shell._user_main_modules[:] = []
+
+    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_logstop(self,parameter_s=''):
+        """Fully stop logging and close log file.
+
+        In order to start logging again, a new %logstart call needs to be made,
+        possibly (though not necessarily) with a new filename, mode and other
+        options."""
+        self.logger.logstop()
+
+    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 automatic calling of the pdb interactive debugger.
+
+        Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
+        argument it works as a toggle.
+
+        When an exception is triggered, IPython can optionally call the
+        interactive pdb debugger after the traceback printout. %pdb toggles
+        this feature on and off.
+
+        The initial state of this feature is set in your ipythonrc
+        configuration file (the variable is called 'pdb').
+
+        If you want to just activate the debugger AFTER an exception has fired,
+        without having to type '%pdb on' and rerunning your code, you can use
+        the %debug magic."""
+
+        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.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_debug(self, parameter_s=''):
+        """Activate the interactive debugger in post-mortem mode.
+
+        If an exception has just occurred, this lets you inspect its stack
+        frames interactively.  Note that this will always work only on the last
+        traceback that occurred, so you must call this quickly after an
+        exception that you wish to inspect has fired, because if another one
+        occurs, it clobbers the previous one.
+
+        If you want IPython to automatically do this on every exception, see
+        the %pdb magic for more details.
+        """
+        
+        self.shell.debugger(force=True)
+
+    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.
+
+       -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.
+        stdout_trap = StringIO()
+
+        if hasattr(stats,'stream'):
+            # In newer versions of python, the stats object has a 'stream'
+            # attribute to write into.
+            stats.stream = stdout_trap
+            stats.print_stats(*lims)
+        else:
+            # For older versions, we manually redirect stdout during printing
+            sys_stdout = sys.stdout
+            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:
+            pfile = file(text_file,'w')
+            pfile.write(output)
+            pfile.close()
+            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
+        (except for sharing global objects such as previously imported
+        modules). But after execution, the IPython interactive namespace gets
+        updated with all variables defined in the program (except for __name__
+        and sys.argv). This allows for very convenient loading of code for
+        interactive work, while giving each program a 'clean sheet' to run in.
+
+        Options:
+        
+        -n: __name__ is NOT set to '__main__', but to the running file's name
+        without extension (as python does under import).  This allows running
+        scripts and reloading the definitions in them without calling code
+        protected by an ' if __name__ == "__main__" ' clause.
+
+        -i: run the file in IPython's namespace instead of an empty one. This
+        is useful if you are experimenting with code written in a text editor
+        which depends on variables defined interactively.
+
+        -e: ignore sys.exit() calls or SystemExit exceptions in the script
+        being run.  This is particularly useful if IPython is being used to
+        run unittests, which always exit with a sys.exit() call.  In such
+        cases you are interested in the output of the test results, not in
+        seeing a traceback of the unittest module.
+
+        -t: print timing information at the end of the run.  IPython will give
+        you an estimated CPU time consumption for your script, which under
+        Unix uses the resource module to avoid the wraparound problems of
+        time.clock().  Under Unix, an estimate of time spent on system tasks
+        is also given (for Windows platforms this is reported as 0.0).
+
+        If -t is given, an additional -N<N> option can be given, where <N>
+        must be an integer indicating how many times you want the script to
+        run.  The final timing report will include total and per run results.
+
+        For example (testing the script uniq_stable.py):
+
+            In [1]: run -t uniq_stable
+
+            IPython CPU timings (estimated):\\
+              User  :    0.19597 s.\\
+              System:        0.0 s.\\
+
+            In [2]: run -t -N5 uniq_stable
+
+            IPython CPU timings (estimated):\\
+            Total runs performed: 5\\
+              Times :      Total       Per run\\
+              User  :   0.910862 s,  0.1821724 s.\\
+              System:        0.0 s,        0.0 s.
+
+        -d: run your program under the control of pdb, the Python debugger.
+        This allows you to execute your program step by step, watch variables,
+        etc.  Internally, what IPython does is similar to calling:
+        
+          pdb.run('execfile("YOURFILENAME")')
+
+        with a breakpoint set on line 1 of your file.  You can change the line
+        number for this automatic breakpoint to be <N> by using the -bN option
+        (where N must be an integer).  For example:
+
+          %run -d -b40 myscript
+
+        will set the first breakpoint at line 40 in myscript.py.  Note that
+        the first breakpoint must be set on a line which actually does
+        something (not a comment or docstring) for it to stop execution.
+
+        When the pdb debugger starts, you will see a (Pdb) prompt.  You must
+        first enter 'c' (without qoutes) to start execution up to the first
+        breakpoint.
+
+        Entering 'help' gives information about the use of the debugger.  You
+        can easily see pdb's full documentation with "import pdb;pdb.help()"
+        at a prompt.
+
+        -p: run program under the control of the Python profiler module (which
+        prints a detailed report of execution times, function calls, etc).
+
+        You can pass other options after -p which affect the behavior of the
+        profiler itself. See the docs for %prun for details.
+
+        In this mode, the program's variables do NOT propagate back to the
+        IPython interactive namespace (because they remain in the namespace
+        where the profiler executes them).
+
+        Internally this triggers a call to %prun, see its documentation for
+        details on the options available specifically for profiling.
+
+        There is one special usage for which the text above doesn't apply:
+        if the filename ends with .ipy, the file is run as ipython script,
+        just as if the commands were written on IPython prompt.
+        """
+
+        # 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
+
+        if filename.lower().endswith('.ipy'):
+            self.api.runlines(open(filename).read())
+            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'):
+            # Run in user's interactive namespace
+            prog_ns = self.shell.user_ns
+            __name__save = self.shell.user_ns['__name__']
+            prog_ns['__name__'] = '__main__'
+            main_mod = FakeModule(prog_ns)
+        else:
+            # Run in a fresh, empty namespace
+            if opts.has_key('n'):
+                name = os.path.splitext(os.path.basename(filename))[0]
+            else:
+                name = '__main__'
+            main_mod = FakeModule()
+            prog_ns = main_mod.__dict__
+            prog_ns['__name__'] = name
+            # The shell MUST hold a reference to main_mod so after %run exits,
+            # the python deletion mechanism doesn't zero it out (leaving
+            # dangling references)
+            self.shell._user_main_modules.append(main_mod)
+
+        # 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__']] = main_mod
+        
+        stats = None
+        try:
+            self.shell.savehist()
+
+            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 "%s prompt to start your script." % deb.prompt
+                    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'):
+                        # timed execution
+                        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:
+                        # regular execution
+                        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
+            self.shell.reloadhist()
+                
+        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:',
+                                        posix=False)
+        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"}
+        # Track compilation time so it can be reported if too long
+        # Minimum time above which compilation time will be reported
+        tc_min = 0.1
+        
+        t0 = clock()
+        code = compile(src, "<magic-timeit>", "exec")
+        tc = clock()-t0
+        
+        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])
+        if tc > tc_min:
+            print "Compiler time: %.2f s" % tc
+        
+    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
+
+          Note that the time needed by Python to compile the given expression
+          will be reported if it is more than 0.1s.  In this example, the
+          actual exponentiation is done by Python at compilation time, so while
+          the expression can take a noticeable amount of time to compute, that
+          time is purely due to the compilation:
+
+          In [5]: time 3**9999;
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00 s
+
+          In [6]: time 3**999999;
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00 s
+          Compiler : 0.78 s
+          """
+        
+        # fail immediately if the given expression can't be compiled
+        
+        expr = self.shell.prefilter(parameter_s,False)
+
+        # Minimum time above which compilation time will be reported
+        tc_min = 0.1
+        
+        try:
+            mode = 'eval'
+            t0 = clock()
+            code = compile(expr,'<timed eval>',mode)
+            tc = clock()-t0
+        except SyntaxError:
+            mode = 'exec'
+            t0 = clock()
+            code = compile(expr,'<timed exec>',mode)
+            tc = clock()-t0
+        # 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 s" % wall_time
+        if tc > tc_min:
+            print "Compiler : %.2f s" % tc
+        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')
+        if not args:
+            macs = [k for k,v in self.shell.user_ns.items() if isinstance(v, Macro)]
+            macs.sort()
+            return macs
+        if len(args) == 1:
+            raise UsageError(
+                "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
+        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)
+                    if 'fakemodule' in filename.lower() and inspect.isclass(data):                     
+                        # class created by %edit? Try to find source
+                        # by looking for method definitions instead, the
+                        # __module__ in those classes is FakeModule.
+                        attrs = [getattr(data, aname) for aname in dir(data)]
+                        for attr in attrs:
+                            if not inspect.ismethod(attr):
+                                continue
+                            filename = inspect.getabsfile(attr)
+                            if filename and 'fakemodule' not in filename.lower():
+                                # change the attribute to be the edit target instead
+                                data = attr 
+                                break
+                    
+                    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,
+                                         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:
+            raise UsageError(
+                "%colors: you must specify a color scheme. See '%colors?'")
+            return
+        # local shortcut
+        shell = self.shell
+
+        import IPython.rlineimpl as readline
+
+        if not readline.have_readline and sys.platform == "win32":
+            msg = """\
+Proper color support under MS Windows requires the pyreadline library.
+You can find it at:
+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)
+        
+        # readline option is 0
+        if not shell.has_readline:
+            new_scheme = 'NoColor'
+            
+        # 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
+
+    #......................................................................
+    # 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:
+            stored = self.db.get('stored_aliases', {} )
+            atab = self.shell.alias_table
+            aliases = atab.keys()
+            aliases.sort()
+            res = []
+            showlast = []
+            for alias in aliases:
+                special = False
+                try:
+                    tgt = atab[alias][1]
+                except (TypeError, AttributeError):
+                    # unsubscriptable? probably a callable
+                    tgt = atab[alias]
+                    special = True
+                # 'interesting' aliases
+                if (alias in stored or
+                    special or 
+                    alias.lower() != os.path.splitext(tgt)[0].lower() or
+                    ' ' in tgt):
+                    showlast.append((alias, tgt))
+                else:
+                    res.append((alias, tgt ))                
+            
+            # show most interesting aliases last
+            res.extend(showlast)
+            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]
+        stored = self.db.get('stored_aliases', {} )
+        if aname in stored:
+            print "Removing %stored alias",aname
+            del stored[aname]
+            self.db['stored_aliases'] = stored
+            
+
+    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'.
+        
+        This function also resets the root module cache of module completer,
+        used on slow filesystems.
+        """
+        
+        
+        ip = self.api
+
+        # for the benefit of module completer in ipy_completers.py
+        del ip.db['rootmodules']
+        
+        path = [os.path.abspath(os.path.expanduser(p)) for p in 
+            os.environ.get('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|py'
+            if 'py' not in winext:
+                winext += '|py'
+            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):
+                        base, ext = os.path.splitext(ff)
+                        if isexec(ff) and base not in self.shell.no_alias:
+                            if ext.lower() == '.exe':
+                                ff = base
+                            alias_table[base.lower()] = (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
+            
+            # no, we don't want them. if %rehashx clobbers them, good,
+            # we'll probably get better versions
+            # self.shell.init_auto_alias()
+            db = ip.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. You can also
+        do 'cd -<tab>' to see directory history conveniently.
+
+        Usage:
+
+          cd 'dir': changes to directory 'dir'.
+
+          cd -: changes to the last visited directory.
+
+          cd -<n>: changes to the n-th directory in the directory history.
+
+          cd -b <bookmark_name>: jump to a bookmark set by %bookmark
+             (note: cd <bookmark_name> is enough if there is no
+              directory <bookmark_name>, but a bookmark with the name exists.)
+              'cd -b <tab>' allows you to tab-complete bookmark names. 
+
+        Options:
+
+        -q: quiet.  Do not print the working directory after the cd command is
+        executed.  By default IPython's cd command does print this directory,
+        since the default prompts do not display path information.
+        
+        Note that !cd doesn't work for this purpose because the shell where
+        !command runs is immediately discarded after executing 'command'."""
+
+        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:
+                raise UsageError('%cd -: No previous directory to change to.')
+        # 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'):
+                        raise UsageError("Bookmark '%s' not found.  "
+                              "Use '%%bookmark -l' to see your bookmarks." % ps)
+            
+        # at this point ps should point to the target dir
+        if ps:
+            try:
+                os.chdir(os.path.expanduser(ps))
+                if self.shell.rc.term_title:
+                    #print 'set term title:',self.shell.rc.term_title  # dbg
+                    ttitle = 'IPy ' + abbrev_cwd()
+                    platutils.set_term_title(ttitle)
+            except OSError:
+                print sys.exc_info()[1]
+            else:
+                cwd = os.getcwd()
+                dhist = self.shell.user_ns['_dh']
+                dhist.append(cwd)
+                self.db['dhist'] = compress_dhist(dhist)[-100:]
+                
+        else:
+            os.chdir(self.shell.home_dir)
+            if self.shell.rc.term_title:
+                platutils.set_term_title("IPy ~")
+            cwd = os.getcwd()
+            dhist = self.shell.user_ns['_dh']
+            dhist.append(cwd)
+            self.db['dhist'] = compress_dhist(dhist)[-100:]
+        if not 'q' in opts and self.shell.user_ns['_dh']:
+            print self.shell.user_ns['_dh'][-1]
+
+
+    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']
+        """
+        
+        dir_s = self.shell.dir_stack
+        tgt = os.path.expanduser(parameter_s)
+        cwd = os.getcwd().replace(self.home_dir,'~')
+        if tgt:
+            self.magic_cd(parameter_s)
+        dir_s.insert(0,cwd)
+        return self.magic_dirs()
+
+    def magic_popd(self, parameter_s=''):
+        """Change to directory popped off the top of the stack.
+        """
+        if not self.shell.dir_stack:
+            raise UsageError("%popd on empty stack")
+        top = self.shell.dir_stack.pop(0)
+        self.magic_cd(top)
+        print "popd ->",top
+
+    def magic_dirs(self, parameter_s=''):
+        """Return the current directory stack."""
+
+        return self.shell.dir_stack
+
+    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>.
+        
+        Note that most of time, you should view directory history by entering
+        cd -<TAB>.
+        
+        """
+
+        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_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_r(self, parameter_s=''):
+        """Repeat previous input.
+
+        Note: Consider using the more powerfull %rep instead!
+        
+        If given an argument, repeats the previous command which starts with
+        the same string, otherwise it just repeats the previous input.
+
+        Shell escaped commands (with ! as first character) are not recognized
+        by this system, only pure python code and magic commands.
+        """
+
+        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_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:
+            raise UsageError("%bookmark: too many arguments")
+
+        bkms = self.db.get('bookmarks',{})
+            
+        if opts.has_key('d'):
+            try:
+                todel = args[0]
+            except IndexError:
+                raise UsageError(
+                    "%bookmark -d: must provide a bookmark to delete")
+            else:
+                try:
+                    del bkms[todel]
+                except KeyError:
+                    raise UsageError(
+                        "%%bookmark -d: 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:
+                raise UsageError("%bookmark: 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. '>' and '+' characters at the beginning of a line are
+        ignored, to allow pasting directly from e-mails or diff files. The
+        executed block is also assigned to variable named 'pasted_block' for
+        later editing with '%edit pasted_block'.
+        
+        You can also pass a variable name as an argument, e.g. '%cpaste foo'.
+        This assigns the pasted block to variable 'foo' as string, without 
+        dedenting or executing it.
+        
+        Do not be alarmed by garbled output on Windows (it's a readline bug). 
+        Just press enter and type -- (and press enter again) and the block 
+        will be what was just pasted.
+        
+        IPython statements (magics, shell escapes) are not supported (yet).
+        """
+        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('>').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')
+
+
+    def magic_doctest_mode(self,parameter_s=''):
+        """Toggle doctest mode on and off.
+
+        This mode allows you to toggle the prompt behavior between normal
+        IPython prompts and ones that are as similar to the default IPython
+        interpreter as possible.
+
+        It also supports the pasting of code snippets that have leading '>>>'
+        and '...' prompts in them.  This means that you can paste doctests from
+        files or docstrings (even if they have leading whitespace), and the
+        code will execute correctly.  You can then use '%history -tn' to see
+        the translated history without line numbers; this will give you the
+        input after removal of all the leading prompts and whitespace, which
+        can be pasted back into an editor.
+
+        With these features, you can switch into this mode easily whenever you
+        need to do testing and changes to doctests, without having to leave
+        your existing IPython session.
+        """
+
+        # XXX - Fix this to have cleaner activate/deactivate calls.
+        from IPython.Extensions import InterpreterPasteInput as ipaste
+        from IPython.ipstruct import Struct
+
+        # Shorthands
+        shell = self.shell
+        oc = shell.outputcache
+        rc = shell.rc
+        meta = shell.meta
+        # dstore is a data store kept in the instance metadata bag to track any
+        # changes we make, so we can undo them later.
+        dstore = meta.setdefault('doctest_mode',Struct())
+        save_dstore = dstore.setdefault
+
+        # save a few values we'll need to recover later
+        mode = save_dstore('mode',False)
+        save_dstore('rc_pprint',rc.pprint)
+        save_dstore('xmode',shell.InteractiveTB.mode)
+        save_dstore('rc_separate_out',rc.separate_out)
+        save_dstore('rc_separate_out2',rc.separate_out2)
+        save_dstore('rc_prompts_pad_left',rc.prompts_pad_left)
+
+        if mode == False:
+            # turn on
+            ipaste.activate_prefilter()
+
+            oc.prompt1.p_template = '>>> '
+            oc.prompt2.p_template = '... '
+            oc.prompt_out.p_template = ''
+
+            oc.output_sep = ''
+            oc.output_sep2 = ''
+
+            oc.prompt1.pad_left = oc.prompt2.pad_left = \
+                                  oc.prompt_out.pad_left = False
+
+            rc.pprint = False
+
+            shell.magic_xmode('Plain')
+
+        else:
+            # turn off
+            ipaste.deactivate_prefilter()
+
+            oc.prompt1.p_template = rc.prompt_in1
+            oc.prompt2.p_template = rc.prompt_in2
+            oc.prompt_out.p_template = rc.prompt_out
+
+            oc.output_sep = dstore.rc_separate_out
+            oc.output_sep2 = dstore.rc_separate_out2
+
+            oc.prompt1.pad_left = oc.prompt2.pad_left = \
+                         oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
+
+            rc.pprint = dstore.rc_pprint
+
+            shell.magic_xmode(dstore.xmode)
+
+        # Store new mode and inform
+        dstore.mode = bool(1-int(mode))
+        print 'Doctest mode is:',
+        print ['OFF','ON'][dstore.mode]
+
+# end Magic
diff --git a/IPython/OInspect.py b/IPython/OInspect.py
new file mode 100644
index 0000000..0acc53f
--- /dev/null
+++ b/IPython/OInspect.py
@@ -0,0 +1,582 @@
+# -*- coding: utf-8 -*-
+"""Tools for inspecting Python objects.
+
+Uses syntax highlighting for presenting the various information elements.
+
+Similar in spirit to the inspect module, but all calls take a name argument to
+reference the name under which an object is being read.
+
+$Id: OInspect.py 2843 2007-10-15 21:22:32Z fperez $
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+__all__ = ['Inspector','InspectColors']
+
+# stdlib modules
+import __builtin__
+import inspect
+import linecache
+import string
+import StringIO
+import types
+import os
+import sys
+# IPython's own
+from IPython import PyColorize
+from IPython.genutils import page,indent,Term,mkdict
+from IPython.Itpl import itpl
+from IPython.wildcard import list_namespace
+from IPython.ColorANSI import *
+
+#****************************************************************************
+# HACK!!! This is a crude fix for bugs in python 2.3's inspect module.  We
+# simply monkeypatch inspect with code copied from python 2.4.
+if sys.version_info[:2] == (2,3):
+    from inspect import ismodule, getabsfile, modulesbyfile
+    def getmodule(object):
+        """Return the module an object was defined in, or None if not found."""
+        if ismodule(object):
+            return object
+        if hasattr(object, '__module__'):
+            return sys.modules.get(object.__module__)
+        try:
+            file = getabsfile(object)
+        except TypeError:
+            return None
+        if file in modulesbyfile:
+            return sys.modules.get(modulesbyfile[file])
+        for module in sys.modules.values():
+            if hasattr(module, '__file__'):
+                modulesbyfile[
+                    os.path.realpath(
+                            getabsfile(module))] = module.__name__
+        if file in modulesbyfile:
+            return sys.modules.get(modulesbyfile[file])
+        main = sys.modules['__main__']
+        if not hasattr(object, '__name__'):
+            return None
+        if hasattr(main, object.__name__):
+            mainobject = getattr(main, object.__name__)
+            if mainobject is object:
+                return main
+        builtin = sys.modules['__builtin__']
+        if hasattr(builtin, object.__name__):
+            builtinobject = getattr(builtin, object.__name__)
+            if builtinobject is object:
+                return builtin
+
+    inspect.getmodule = getmodule
+
+#****************************************************************************
+# Builtin color schemes
+
+Colors = TermColors  # just a shorthand
+
+# Build a few color schemes
+NoColor = ColorScheme(
+    'NoColor',{
+    'header' : Colors.NoColor,
+    'normal' : Colors.NoColor  # color off (usu. Colors.Normal)
+    }  )
+
+LinuxColors = ColorScheme(
+    'Linux',{
+    'header' : Colors.LightRed,
+    'normal' : Colors.Normal  # color off (usu. Colors.Normal)
+    } )
+
+LightBGColors = ColorScheme(
+    'LightBG',{
+    'header' : Colors.Red,
+    'normal' : Colors.Normal  # color off (usu. Colors.Normal)
+    }  )
+
+# Build table of color schemes (needed by the parser)
+InspectColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
+                                 'Linux')
+
+#****************************************************************************
+# Auxiliary functions
+def getdoc(obj):
+    """Stable wrapper around inspect.getdoc.
+
+    This can't crash because of attribute problems.
+
+    It also attempts to call a getdoc() method on the given object.  This
+    allows objects which provide their docstrings via non-standard mechanisms
+    (like Pyro proxies) to still be inspected by ipython's ? system."""
+
+    ds = None  # default return value
+    try:
+        ds = inspect.getdoc(obj)
+    except:
+        # Harden against an inspect failure, which can occur with
+        # SWIG-wrapped extensions.
+        pass
+    # Allow objects to offer customized documentation via a getdoc method:
+    try:
+        ds2 = obj.getdoc()
+    except:
+        pass
+    else:
+        # if we get extra info, we add it to the normal docstring.
+        if ds is None:
+            ds = ds2
+        else:
+            ds = '%s\n%s' % (ds,ds2)
+    return ds
+
+def getsource(obj,is_binary=False):
+    """Wrapper around inspect.getsource.
+
+    This can be modified by other projects to provide customized source
+    extraction.
+
+    Inputs:
+
+    - obj: an object whose source code we will attempt to extract.
+
+    Optional inputs:
+
+    - is_binary: whether the object is known to come from a binary source.
+    This implementation will skip returning any output for binary objects, but
+    custom extractors may know how to meaningfully process them."""
+    
+    if is_binary:
+        return None
+    else:
+        return inspect.getsource(obj)
+
+#****************************************************************************
+# Class definitions
+
+class myStringIO(StringIO.StringIO):
+    """Adds a writeln method to normal StringIO."""
+    def writeln(self,*arg,**kw):
+        """Does a write() and then a write('\n')"""
+        self.write(*arg,**kw)
+        self.write('\n')
+
+class Inspector:
+    def __init__(self,color_table,code_color_table,scheme,
+                 str_detail_level=0):
+        self.color_table = color_table
+        self.parser = PyColorize.Parser(code_color_table,out='str')
+        self.format = self.parser.format
+        self.str_detail_level = str_detail_level
+        self.set_active_scheme(scheme)
+
+    def __getargspec(self,obj):
+        """Get the names and default values of a function's arguments.
+
+        A tuple of four things is returned: (args, varargs, varkw, defaults).
+        'args' is a list of the argument names (it may contain nested lists).
+        'varargs' and 'varkw' are the names of the * and ** arguments or None.
+        'defaults' is an n-tuple of the default values of the last n arguments.
+
+        Modified version of inspect.getargspec from the Python Standard
+        Library."""
+
+        if inspect.isfunction(obj):
+            func_obj = obj
+        elif inspect.ismethod(obj):
+            func_obj = obj.im_func
+        else:
+            raise TypeError, 'arg is not a Python function'
+        args, varargs, varkw = inspect.getargs(func_obj.func_code)
+        return args, varargs, varkw, func_obj.func_defaults
+
+    def __getdef(self,obj,oname=''):
+        """Return the definition header for any callable object.
+
+        If any exception is generated, None is returned instead and the
+        exception is suppressed."""
+        
+        try:
+            return oname + inspect.formatargspec(*self.__getargspec(obj))
+        except:
+            return None
+ 
+    def __head(self,h):
+        """Return a header string with proper colors."""
+        return '%s%s%s' % (self.color_table.active_colors.header,h,
+                           self.color_table.active_colors.normal)
+
+    def set_active_scheme(self,scheme):
+        self.color_table.set_active_scheme(scheme)
+        self.parser.color_table.set_active_scheme(scheme)
+    
+    def noinfo(self,msg,oname):
+        """Generic message when no information is found."""
+        print 'No %s found' % msg,
+        if oname:
+            print 'for %s' % oname
+        else:
+            print
+            
+    def pdef(self,obj,oname=''):
+        """Print the definition header for any callable object.
+
+        If the object is a class, print the constructor information."""
+
+        if not callable(obj):
+            print 'Object is not callable.'
+            return
+
+        header = ''
+
+        if inspect.isclass(obj):
+            header = self.__head('Class constructor information:\n')
+            obj = obj.__init__
+        elif type(obj) is types.InstanceType:
+            obj = obj.__call__
+
+        output = self.__getdef(obj,oname)
+        if output is None:
+            self.noinfo('definition header',oname)
+        else:
+            print >>Term.cout, header,self.format(output),
+
+    def pdoc(self,obj,oname='',formatter = None):
+        """Print the docstring for any object.
+
+        Optional:
+        -formatter: a function to run the docstring through for specially
+        formatted docstrings."""
+
+        head = self.__head  # so that itpl can find it even if private
+        ds = getdoc(obj)
+        if formatter:
+            ds = formatter(ds)
+        if inspect.isclass(obj):
+            init_ds = getdoc(obj.__init__)
+            output = itpl('$head("Class Docstring:")\n'
+                          '$indent(ds)\n'
+                          '$head("Constructor Docstring"):\n'
+                          '$indent(init_ds)')
+        elif (type(obj) is types.InstanceType or isinstance(obj,object)) \
+                 and hasattr(obj,'__call__'):
+            call_ds = getdoc(obj.__call__)
+            if call_ds:
+                output = itpl('$head("Class Docstring:")\n$indent(ds)\n'
+                              '$head("Calling Docstring:")\n$indent(call_ds)')
+            else:
+                output = ds
+        else:
+            output = ds
+        if output is None:
+            self.noinfo('documentation',oname)
+            return
+        page(output)
+
+    def psource(self,obj,oname=''):
+        """Print the source code for an object."""
+
+        # Flush the source cache because inspect can return out-of-date source
+        linecache.checkcache()
+        try:
+            src = getsource(obj) 
+        except:
+            self.noinfo('source',oname)
+        else:
+            page(self.format(src))
+
+    def pfile(self,obj,oname=''):
+        """Show the whole file where an object was defined."""
+        try:
+            sourcelines,lineno = inspect.getsourcelines(obj)
+        except:
+            self.noinfo('file',oname)
+        else:
+            # run contents of file through pager starting at line
+            # where the object is defined
+            ofile = inspect.getabsfile(obj)
+            
+            if (ofile.endswith('.so') or ofile.endswith('.dll')):
+                print 'File %r is binary, not printing.' % ofile
+            elif not os.path.isfile(ofile):
+                print 'File %r does not exist, not printing.' % ofile
+            else:
+                # Print only text files, not extension binaries.
+                page(self.format(open(ofile).read()),lineno)
+            #page(self.format(open(inspect.getabsfile(obj)).read()),lineno)
+
+    def pinfo(self,obj,oname='',formatter=None,info=None,detail_level=0):
+        """Show detailed information about an object.
+
+        Optional arguments:
+        
+        - oname: name of the variable pointing to the object.
+
+        - formatter: special formatter for docstrings (see pdoc)
+
+        - info: a structure with some information fields which may have been
+        precomputed already.
+
+        - detail_level: if set to 1, more information is given.
+        """
+
+        obj_type = type(obj)
+
+        header = self.__head
+        if info is None:
+            ismagic = 0
+            isalias = 0
+            ospace = ''
+        else:
+            ismagic = info.ismagic
+            isalias = info.isalias
+            ospace = info.namespace
+        # Get docstring, special-casing aliases:
+        if isalias:
+            if not callable(obj):
+                try:
+                    ds = "Alias to the system command:\n  %s" % obj[1]
+                except:
+                    ds = "Alias: " + str(obj)
+            else:
+                ds = "Alias to " + str(obj)
+                if obj.__doc__:
+                    ds += "\nDocstring:\n" + obj.__doc__
+        else:
+            ds = getdoc(obj)
+            if ds is None:
+                ds = '<no docstring>'
+        if formatter is not None:
+            ds = formatter(ds)
+
+        # store output in a list which gets joined with \n at the end.
+        out = myStringIO()
+        
+        string_max = 200 # max size of strings to show (snipped if longer)
+        shalf = int((string_max -5)/2)
+
+        if ismagic:
+            obj_type_name = 'Magic function'
+        elif isalias:
+            obj_type_name = 'System alias'
+        else:
+            obj_type_name = obj_type.__name__
+        out.writeln(header('Type:\t\t')+obj_type_name)
+
+        try:
+            bclass = obj.__class__
+            out.writeln(header('Base Class:\t')+str(bclass))
+        except: pass
+
+        # String form, but snip if too long in ? form (full in ??)
+        if detail_level >= self.str_detail_level:
+            try:
+                ostr = str(obj)
+                str_head = 'String Form:'
+                if not detail_level and len(ostr)>string_max:
+                    ostr = ostr[:shalf] + ' <...> ' + ostr[-shalf:]
+                    ostr = ("\n" + " " * len(str_head.expandtabs())).\
+                           join(map(string.strip,ostr.split("\n")))
+                if ostr.find('\n') > -1:
+                    # Print multi-line strings starting at the next line.
+                    str_sep = '\n'
+                else:
+                    str_sep = '\t'
+                out.writeln("%s%s%s" % (header(str_head),str_sep,ostr))
+            except:
+                pass
+
+        if ospace:
+            out.writeln(header('Namespace:\t')+ospace)
+
+        # Length (for strings and lists)
+        try:
+            length = str(len(obj))
+            out.writeln(header('Length:\t\t')+length)
+        except: pass
+
+        # Filename where object was defined
+        binary_file = False
+        try:
+            fname = inspect.getabsfile(obj)
+            if fname.endswith('<string>'):
+                fname = 'Dynamically generated function. No source code available.'
+            if (fname.endswith('.so') or fname.endswith('.dll')):
+                binary_file = True
+            out.writeln(header('File:\t\t')+fname)
+        except:
+            # if anything goes wrong, we don't want to show source, so it's as
+            # if the file was binary
+            binary_file = True
+
+        # reconstruct the function definition and print it:
+        defln = self.__getdef(obj,oname)
+        if defln:
+            out.write(header('Definition:\t')+self.format(defln))
+ 
+        # Docstrings only in detail 0 mode, since source contains them (we
+        # avoid repetitions).  If source fails, we add them back, see below.
+        if ds and detail_level == 0:
+                out.writeln(header('Docstring:\n') + indent(ds))
+                
+        # Original source code for any callable
+        if detail_level:
+            # Flush the source cache because inspect can return out-of-date
+            # source
+            linecache.checkcache()
+            source_success = False
+            try:
+                source = self.format(getsource(obj,binary_file))
+                if source:
+                    out.write(header('Source:\n')+source.rstrip())
+                    source_success = True
+            except Exception, msg:
+                pass
+            
+            if ds and not source_success:
+                out.writeln(header('Docstring [source file open failed]:\n')
+                            + indent(ds))
+
+        # Constructor docstring for classes
+        if inspect.isclass(obj):
+            # reconstruct the function definition and print it:
+            try:
+                obj_init =  obj.__init__
+            except AttributeError:
+                init_def = init_ds = None
+            else:
+                init_def = self.__getdef(obj_init,oname)
+                init_ds  = getdoc(obj_init)
+                # Skip Python's auto-generated docstrings
+                if init_ds and \
+                       init_ds.startswith('x.__init__(...) initializes'):
+                    init_ds = None
+
+            if init_def or init_ds:
+                out.writeln(header('\nConstructor information:'))
+                if init_def:
+                    out.write(header('Definition:\t')+ self.format(init_def))
+                if init_ds:
+                    out.writeln(header('Docstring:\n') + indent(init_ds))
+        # and class docstring for instances:
+        elif obj_type is types.InstanceType or \
+                 isinstance(obj,object):
+
+            # First, check whether the instance docstring is identical to the
+            # class one, and print it separately if they don't coincide.  In
+            # most cases they will, but it's nice to print all the info for
+            # objects which use instance-customized docstrings.
+            if ds:
+                try:
+                    cls = getattr(obj,'__class__')
+                except:
+                    class_ds = None
+                else:
+                    class_ds = getdoc(cls)
+                # Skip Python's auto-generated docstrings
+                if class_ds and \
+                       (class_ds.startswith('function(code, globals[,') or \
+                   class_ds.startswith('instancemethod(function, instance,') or \
+                   class_ds.startswith('module(name[,') ):
+                    class_ds = None
+                if class_ds and ds != class_ds:
+                    out.writeln(header('Class Docstring:\n') +
+                                indent(class_ds))
+
+            # Next, try to show constructor docstrings
+            try:
+                init_ds = getdoc(obj.__init__)
+                # Skip Python's auto-generated docstrings
+                if init_ds and \
+                       init_ds.startswith('x.__init__(...) initializes'):
+                    init_ds = None
+            except AttributeError:
+                init_ds = None
+            if init_ds:
+                out.writeln(header('Constructor Docstring:\n') +
+                            indent(init_ds))
+
+            # Call form docstring for callable instances
+            if hasattr(obj,'__call__'):
+                #out.writeln(header('Callable:\t')+'Yes')
+                call_def = self.__getdef(obj.__call__,oname)
+                #if call_def is None:
+                #    out.writeln(header('Call def:\t')+
+                #              'Calling definition not available.')
+                if call_def is not None:
+                    out.writeln(header('Call def:\t')+self.format(call_def))
+                call_ds = getdoc(obj.__call__)
+                # Skip Python's auto-generated docstrings
+                if call_ds and call_ds.startswith('x.__call__(...) <==> x(...)'):
+                    call_ds = None
+                if call_ds:
+                    out.writeln(header('Call docstring:\n') + indent(call_ds))
+
+        # Finally send to printer/pager
+        output = out.getvalue()
+        if output:
+            page(output)
+        # end pinfo
+
+    def psearch(self,pattern,ns_table,ns_search=[],
+                ignore_case=False,show_all=False):
+        """Search namespaces with wildcards for objects.
+
+        Arguments:
+
+        - pattern: string containing shell-like wildcards to use in namespace
+        searches and optionally a type specification to narrow the search to
+        objects of that type.
+
+        - ns_table: dict of name->namespaces for search.
+
+        Optional arguments:
+        
+          - ns_search: list of namespace names to include in search.
+
+          - ignore_case(False): make the search case-insensitive.
+
+          - show_all(False): show all names, including those starting with
+          underscores.
+        """
+        #print 'ps pattern:<%r>' % pattern # dbg
+        
+        # defaults
+        type_pattern = 'all'
+        filter = ''
+
+        cmds = pattern.split()
+        len_cmds  =  len(cmds)
+        if len_cmds == 1:
+            # Only filter pattern given
+            filter = cmds[0]
+        elif len_cmds == 2:
+            # Both filter and type specified
+            filter,type_pattern = cmds
+        else:
+            raise ValueError('invalid argument string for psearch: <%s>' %
+                             pattern)
+
+        # filter search namespaces
+        for name in ns_search:
+            if name not in ns_table:
+                raise ValueError('invalid namespace <%s>. Valid names: %s' %
+                                 (name,ns_table.keys()))
+
+        #print 'type_pattern:',type_pattern # dbg
+        search_result = []
+        for ns_name in ns_search:
+            ns = ns_table[ns_name]
+            tmp_res = list(list_namespace(ns,type_pattern,filter,
+                                          ignore_case=ignore_case,
+                                          show_all=show_all))
+            search_result.extend(tmp_res)
+        search_result.sort()
+
+        page('\n'.join(search_result))
diff --git a/IPython/OutputTrap.py b/IPython/OutputTrap.py
new file mode 100644
index 0000000..c1d1d3b
--- /dev/null
+++ b/IPython/OutputTrap.py
@@ -0,0 +1,263 @@
+# -*- coding: utf-8 -*-
+"""Class to trap stdout and stderr and log them separately.
+
+$Id: OutputTrap.py 958 2005-12-27 23:17:51Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+import exceptions
+import sys
+from cStringIO import StringIO
+
+class OutputTrapError(exceptions.Exception):
+    """Exception for OutputTrap class."""
+
+    def __init__(self,args=None):
+        exceptions.Exception.__init__(self)
+        self.args = args
+
+class OutputTrap:
+
+    """Class to trap standard output and standard error. They get logged in
+    StringIO objects which are available as <instance>.out and
+    <instance>.err. The class also offers summary methods which format this
+    data a bit.
+
+    A word of caution: because it blocks messages, using this class can make
+    debugging very tricky. If you are having bizarre problems silently, try
+    turning your output traps off for a while. You can call the constructor
+    with the parameter debug=1 for these cases. This turns actual trapping
+    off, but you can keep the rest of your code unchanged (this has already
+    been a life saver).
+
+    Example:
+
+    # config: trapper with a line of dots as log separator (final '\\n' needed)
+    config = OutputTrap('Config','Out ','Err ','.'*80+'\\n')
+
+    # start trapping output
+    config.trap_all()
+
+    # now all output is logged ...
+    # do stuff...
+
+    # output back to normal:
+    config.release_all()
+
+    # print all that got logged:
+    print config.summary()
+
+    # print individual raw data:
+    print config.out.getvalue()
+    print config.err.getvalue()
+    """
+
+    def __init__(self,name='Generic Output Trap',
+                 out_head='Standard Output. ',err_head='Standard Error. ',
+                 sum_sep='\n',debug=0,trap_out=0,trap_err=0,
+                 quiet_out=0,quiet_err=0):
+        self.name = name
+        self.out_head = out_head
+        self.err_head = err_head
+        self.sum_sep = sum_sep
+        self.out = StringIO()
+        self.err = StringIO()
+        self.out_save = None
+        self.err_save = None
+        self.debug = debug
+        self.quiet_out = quiet_out
+        self.quiet_err = quiet_err
+        if trap_out:
+            self.trap_out()
+        if trap_err:
+            self.trap_err()
+
+    def trap_out(self):
+        """Trap and log stdout."""
+        if sys.stdout is self.out:
+            raise OutputTrapError,'You are already trapping stdout.'
+        if not self.debug:
+            self._out_save = sys.stdout
+            sys.stdout = self.out
+
+    def release_out(self):
+        """Release stdout."""
+        if not self.debug:
+            if not sys.stdout is self.out:
+                raise OutputTrapError,'You are not trapping stdout.'
+            sys.stdout = self._out_save
+            self.out_save = None
+
+    def summary_out(self):
+        """Return as a string the log from stdout."""
+        out = self.out.getvalue()
+        if out:
+            if self.quiet_out:
+                return out
+            else:
+                return self.out_head + 'Log by '+ self.name + ':\n' + out
+        else:
+            return ''
+
+    def flush_out(self):
+        """Flush the stdout log. All data held in the log is lost."""
+
+        self.out.close()
+        self.out = StringIO()
+
+    def trap_err(self):
+        """Trap and log stderr."""
+        if sys.stderr is self.err:
+            raise OutputTrapError,'You are already trapping stderr.'
+        if not self.debug:
+            self._err_save = sys.stderr
+            sys.stderr = self.err
+
+    def release_err(self):
+        """Release stderr."""
+        if not self.debug:
+            if not sys.stderr is self.err:
+                raise OutputTrapError,'You are not trapping stderr.'
+            sys.stderr = self._err_save
+            self.err_save = None
+
+    def summary_err(self):
+        """Return as a string the log from stderr."""
+        err = self.err.getvalue()
+        if err:
+            if self.quiet_err:
+                return err
+            else:
+                return self.err_head + 'Log by '+ self.name + ':\n' + err
+        else:
+            return ''
+
+    def flush_err(self):
+        """Flush the stdout log. All data held in the log is lost."""
+
+        self.err.close()
+        self.err = StringIO()
+
+    def trap_all(self):
+        """Trap and log both stdout and stderr.
+
+        Cacthes and discards OutputTrapError exceptions raised."""
+        try:
+            self.trap_out()
+        except OutputTrapError:
+            pass
+        try:
+            self.trap_err()
+        except OutputTrapError:
+            pass
+
+    def release_all(self):
+        """Release both stdout and stderr.
+
+        Cacthes and discards OutputTrapError exceptions raised."""
+        try:
+            self.release_out()
+        except OutputTrapError:
+            pass
+        try:
+            self.release_err()
+        except OutputTrapError:
+            pass
+        
+    def summary_all(self):
+        """Return as a string the log from stdout and stderr, prepending a separator
+        to each (defined in __init__ as sum_sep)."""
+        sum = ''
+        sout = self.summary_out()
+        if sout:
+            sum += self.sum_sep + sout
+        serr = self.summary_err()
+        if serr:
+            sum += '\n'+self.sum_sep + serr
+        return sum
+
+    def flush_all(self):
+        """Flush stdout and stderr"""
+        self.flush_out()
+        self.flush_err()
+
+    # a few shorthands
+    trap = trap_all
+    release = release_all
+    summary = summary_all
+    flush = flush_all
+# end OutputTrap
+
+
+#****************************************************************************
+# Module testing. Incomplete, I'm lazy...
+
+def _test_all():
+
+    """Module testing functions, activated when the module is called as a
+    script (not imported)."""
+
+    # Put tests for this module in here.
+    # Define them as nested functions so they don't clobber the
+    # pydoc-generated docs
+
+    def _test_():
+        name = ''
+        print '#'*50+'\nRunning test for ' + name
+        # ...
+        print 'Finished test for '+ name +'\n'+'#'*50
+
+    def _test_OutputTrap():
+        trap = OutputTrap(name = 'Test Trap', sum_sep = '.'*50+'\n',
+                          out_head = 'SOut. ', err_head = 'SErr. ')
+
+        name = 'OutputTrap class'
+        print '#'*50+'\nRunning test for ' + name
+        print 'Trapping out'
+        trap.trap_out()
+        print >>sys.stdout, '>>stdout. stdout is trapped.'
+        print >>sys.stderr, '>>stderr. stdout is trapped.'
+        trap.release_out()
+        print trap.summary_out()
+
+        print 'Trapping err'
+        trap.trap_err()
+        print >>sys.stdout, '>>stdout. stderr is trapped.'
+        print >>sys.stderr, '>>stderr. stderr is trapped.'
+        trap.release_err()
+        print trap.summary_err()
+
+        print 'Trapping all (no flushing)'
+        trap.trap_all()
+        print >>sys.stdout, '>>stdout. stdout/err is trapped.'
+        print >>sys.stderr, '>>stderr. stdout/err is trapped.'
+        trap.release_all()
+        print trap.summary_all()
+
+        print 'Trapping all (flushing first)'
+        trap.flush()
+        trap.trap_all()
+        print >>sys.stdout, '>>stdout. stdout/err is trapped.'
+        print >>sys.stderr, '>>stderr. stdout/err is trapped.'
+        trap.release_all()
+        print trap.summary_all()
+        print 'Finished test for '+ name +'\n'+'#'*50
+
+    # call the actual tests here:
+    _test_OutputTrap()
+
+
+if __name__=="__main__":
+    # _test_all() # XXX BROKEN.
+    pass
+
+#************************ end of file <OutputTrap.py> ************************
diff --git a/IPython/Prompts.py b/IPython/Prompts.py
new file mode 100644
index 0000000..5c87271
--- /dev/null
+++ b/IPython/Prompts.py
@@ -0,0 +1,625 @@
+# -*- coding: utf-8 -*-
+"""
+Classes for handling input/output prompts.
+
+$Id: Prompts.py 3026 2008-02-07 16:03:16Z vivainio $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+__version__ = Release.version
+
+#****************************************************************************
+# Required modules
+import __builtin__
+import os
+import socket
+import sys
+import time
+
+# IPython's own
+from IPython import ColorANSI
+from IPython.Itpl import ItplNS
+from IPython.ipstruct import Struct
+from IPython.macro import Macro
+from IPython.genutils import *
+from IPython.ipapi import TryNext
+
+#****************************************************************************
+#Color schemes for Prompts.
+
+PromptColors = ColorANSI.ColorSchemeTable()
+InputColors = ColorANSI.InputTermColors  # just a shorthand
+Colors = ColorANSI.TermColors  # just a shorthand
+
+PromptColors.add_scheme(ColorANSI.ColorScheme(
+    'NoColor',
+    in_prompt  = InputColors.NoColor,  # Input prompt
+    in_number  = InputColors.NoColor,  # Input prompt number
+    in_prompt2 = InputColors.NoColor, # Continuation prompt
+    in_normal  = InputColors.NoColor,  # color off (usu. Colors.Normal)
+    
+    out_prompt = Colors.NoColor, # Output prompt
+    out_number = Colors.NoColor, # Output prompt number
+
+    normal = Colors.NoColor  # color off (usu. Colors.Normal)
+    ))
+
+# make some schemes as instances so we can copy them for modification easily:
+__PColLinux =  ColorANSI.ColorScheme(
+    'Linux',
+    in_prompt  = InputColors.Green,
+    in_number  = InputColors.LightGreen,
+    in_prompt2 = InputColors.Green,
+    in_normal  = InputColors.Normal,  # color off (usu. Colors.Normal)
+
+    out_prompt = Colors.Red,
+    out_number = Colors.LightRed,
+
+    normal = Colors.Normal
+    )
+# Don't forget to enter it into the table!
+PromptColors.add_scheme(__PColLinux)
+
+# Slightly modified Linux for light backgrounds
+__PColLightBG  = __PColLinux.copy('LightBG')
+
+__PColLightBG.colors.update(
+    in_prompt  = InputColors.Blue,
+    in_number  = InputColors.LightBlue,
+    in_prompt2 = InputColors.Blue
+)
+PromptColors.add_scheme(__PColLightBG)
+
+del Colors,InputColors
+
+#-----------------------------------------------------------------------------
+def multiple_replace(dict, text):
+    """ Replace in 'text' all occurences of any key in the given
+    dictionary by its corresponding value.  Returns the new string."""
+
+    # Function by Xavier Defrang, originally found at:
+    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330
+
+    # Create a regular expression  from the dictionary keys
+    regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
+    # For each match, look-up corresponding value in dictionary
+    return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
+
+#-----------------------------------------------------------------------------
+# Special characters that can be used in prompt templates, mainly bash-like
+
+# If $HOME isn't defined (Windows), make it an absurd string so that it can
+# never be expanded out into '~'.  Basically anything which can never be a
+# reasonable directory name will do, we just want the $HOME -> '~' operation
+# to become a no-op.  We pre-compute $HOME here so it's not done on every
+# prompt call.
+
+# FIXME:
+
+# - This should be turned into a class which does proper namespace management,
+# since the prompt specials need to be evaluated in a certain namespace.
+# Currently it's just globals, which need to be managed manually by code
+# below.
+
+# - I also need to split up the color schemes from the prompt specials
+# somehow.  I don't have a clean design for that quite yet.
+
+HOME = os.environ.get("HOME","//////:::::ZZZZZ,,,~~~")
+
+# We precompute a few more strings here for the prompt_specials, which are
+# fixed once ipython starts.  This reduces the runtime overhead of computing
+# prompt strings.
+USER           = os.environ.get("USER")
+HOSTNAME       = socket.gethostname()
+HOSTNAME_SHORT = HOSTNAME.split(".")[0]
+ROOT_SYMBOL    = "$#"[os.name=='nt' or os.getuid()==0]
+
+prompt_specials_color = {
+    # Prompt/history count
+    '%n' : '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
+    r'\#': '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
+    # Just the prompt counter number, WITHOUT any coloring wrappers, so users
+    # can get numbers displayed in whatever color they want.
+    r'\N': '${self.cache.prompt_count}',
+    # Prompt/history count, with the actual digits replaced by dots.  Used
+    # mainly in continuation prompts (prompt_in2)
+    r'\D': '${"."*len(str(self.cache.prompt_count))}',
+    # Current working directory
+    r'\w': '${os.getcwd()}',
+    # Current time
+    r'\t' : '${time.strftime("%H:%M:%S")}',
+    # Basename of current working directory.
+    # (use os.sep to make this portable across OSes)
+    r'\W' : '${os.getcwd().split("%s")[-1]}' % os.sep,
+    # These X<N> are an extension to the normal bash prompts.  They return
+    # N terms of the path, after replacing $HOME with '~'
+    r'\X0': '${os.getcwd().replace("%s","~")}' % HOME,
+    r'\X1': '${self.cwd_filt(1)}',
+    r'\X2': '${self.cwd_filt(2)}',
+    r'\X3': '${self.cwd_filt(3)}',
+    r'\X4': '${self.cwd_filt(4)}',
+    r'\X5': '${self.cwd_filt(5)}',
+    # Y<N> are similar to X<N>, but they show '~' if it's the directory
+    # N+1 in the list.  Somewhat like %cN in tcsh.
+    r'\Y0': '${self.cwd_filt2(0)}',
+    r'\Y1': '${self.cwd_filt2(1)}',
+    r'\Y2': '${self.cwd_filt2(2)}',
+    r'\Y3': '${self.cwd_filt2(3)}',
+    r'\Y4': '${self.cwd_filt2(4)}',
+    r'\Y5': '${self.cwd_filt2(5)}',
+    # Hostname up to first .
+    r'\h': HOSTNAME_SHORT,
+    # Full hostname
+    r'\H': HOSTNAME,
+    # Username of current user
+    r'\u': USER,
+    # Escaped '\'
+    '\\\\': '\\',
+    # Newline
+    r'\n': '\n',
+    # Carriage return
+    r'\r': '\r',
+    # Release version
+    r'\v': __version__,
+    # Root symbol ($ or #)
+    r'\$': ROOT_SYMBOL,
+    }
+
+# A copy of the prompt_specials dictionary but with all color escapes removed,
+# so we can correctly compute the prompt length for the auto_rewrite method.
+prompt_specials_nocolor = prompt_specials_color.copy()
+prompt_specials_nocolor['%n'] = '${self.cache.prompt_count}'
+prompt_specials_nocolor[r'\#'] = '${self.cache.prompt_count}'
+
+# Add in all the InputTermColors color escapes as valid prompt characters.
+# They all get added as \\C_COLORNAME, so that we don't have any conflicts
+# with a color name which may begin with a letter used by any other of the
+# allowed specials.  This of course means that \\C will never be allowed for
+# anything else.
+input_colors = ColorANSI.InputTermColors
+for _color in dir(input_colors):
+    if _color[0] != '_':
+        c_name = r'\C_'+_color
+        prompt_specials_color[c_name] = getattr(input_colors,_color)
+        prompt_specials_nocolor[c_name] = ''
+
+# we default to no color for safety.  Note that prompt_specials is a global
+# variable used by all prompt objects.
+prompt_specials = prompt_specials_nocolor
+
+#-----------------------------------------------------------------------------
+def str_safe(arg):
+    """Convert to a string, without ever raising an exception.
+
+    If str(arg) fails, <ERROR: ... > is returned, where ... is the exception
+    error message."""
+
+    try:
+        out = str(arg)
+    except UnicodeError:
+        try:
+            out = arg.encode('utf_8','replace')
+        except Exception,msg:
+            # let's keep this little duplication here, so that the most common
+            # case doesn't suffer from a double try wrapping.
+            out = '<ERROR: %s>' % msg
+    except Exception,msg:
+        out = '<ERROR: %s>' % msg
+    return out
+
+class BasePrompt(object):
+    """Interactive prompt similar to Mathematica's."""
+
+    def _get_p_template(self):
+        return self._p_template
+
+    def _set_p_template(self,val):
+        self._p_template = val
+        self.set_p_str()
+
+    p_template = property(_get_p_template,_set_p_template,
+                          doc='Template for prompt string creation')
+
+    def __init__(self,cache,sep,prompt,pad_left=False):
+
+        # Hack: we access information about the primary prompt through the
+        # cache argument.  We need this, because we want the secondary prompt
+        # to be aligned with the primary one.  Color table info is also shared
+        # by all prompt classes through the cache.  Nice OO spaghetti code!
+        self.cache = cache
+        self.sep = sep
+        
+        # regexp to count the number of spaces at the end of a prompt
+        # expression, useful for prompt auto-rewriting
+        self.rspace = re.compile(r'(\s*)$')
+        # Flag to left-pad prompt strings to match the length of the primary
+        # prompt
+        self.pad_left = pad_left
+
+        # Set template to create each actual prompt (where numbers change).
+        # Use a property
+        self.p_template = prompt
+        self.set_p_str()
+
+    def set_p_str(self):
+        """ Set the interpolating prompt strings.
+
+        This must be called every time the color settings change, because the
+        prompt_specials global may have changed."""
+
+        import os,time  # needed in locals for prompt string handling
+        loc = locals()
+        try:
+            self.p_str = ItplNS('%s%s%s' %
+                                ('${self.sep}${self.col_p}',
+                                 multiple_replace(prompt_specials, self.p_template),
+                                 '${self.col_norm}'),self.cache.user_ns,loc)
+    
+            self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
+                                                         self.p_template),
+                                        self.cache.user_ns,loc)
+        except:
+            print "Illegal prompt template (check $ usage!):",self.p_template
+            self.p_str = self.p_template
+            self.p_str_nocolor = self.p_template
+
+    def write(self,msg):  # dbg
+        sys.stdout.write(msg)
+        return ''
+
+    def __str__(self):
+        """Return a string form of the prompt.
+
+        This for is useful for continuation and output prompts, since it is
+        left-padded to match lengths with the primary one (if the
+        self.pad_left attribute is set)."""
+
+        out_str = str_safe(self.p_str)
+        if self.pad_left:
+            # We must find the amount of padding required to match lengths,
+            # taking the color escapes (which are invisible on-screen) into
+            # account.
+            esc_pad = len(out_str) - len(str_safe(self.p_str_nocolor))
+            format = '%%%ss' % (len(str(self.cache.last_prompt))+esc_pad)
+            return format % out_str
+        else:
+            return out_str
+
+    # these path filters are put in as methods so that we can control the
+    # namespace where the prompt strings get evaluated
+    def cwd_filt(self,depth):
+        """Return the last depth elements of the current working directory.
+
+        $HOME is always replaced with '~'.
+        If depth==0, the full path is returned."""
+
+        cwd = os.getcwd().replace(HOME,"~")
+        out = os.sep.join(cwd.split(os.sep)[-depth:])
+        if out:
+            return out
+        else:
+            return os.sep
+
+    def cwd_filt2(self,depth):
+        """Return the last depth elements of the current working directory.
+
+        $HOME is always replaced with '~'.
+        If depth==0, the full path is returned."""
+
+        full_cwd = os.getcwd()
+        cwd = full_cwd.replace(HOME,"~").split(os.sep)
+        if '~' in cwd and len(cwd) == depth+1:
+            depth += 1
+        drivepart = ''
+        if sys.platform == 'win32' and len(cwd) > depth:
+            drivepart = os.path.splitdrive(full_cwd)[0]
+        out = drivepart + '/'.join(cwd[-depth:])
+
+        if out:
+            return out
+        else:
+            return os.sep
+
+    def __nonzero__(self):
+        """Implement boolean behavior.
+
+        Checks whether the p_str attribute is non-empty"""
+
+        return bool(self.p_template)
+
+class Prompt1(BasePrompt):
+    """Input interactive prompt similar to Mathematica's."""
+
+    def __init__(self,cache,sep='\n',prompt='In [\\#]: ',pad_left=True):
+        BasePrompt.__init__(self,cache,sep,prompt,pad_left)
+
+    def set_colors(self):
+        self.set_p_str()
+        Colors = self.cache.color_table.active_colors # shorthand
+        self.col_p = Colors.in_prompt
+        self.col_num = Colors.in_number
+        self.col_norm = Colors.in_normal
+        # We need a non-input version of these escapes for the '--->'
+        # auto-call prompts used in the auto_rewrite() method.
+        self.col_p_ni = self.col_p.replace('\001','').replace('\002','') 
+        self.col_norm_ni = Colors.normal        
+        
+    def __str__(self):
+        self.cache.prompt_count += 1
+        self.cache.last_prompt = str_safe(self.p_str_nocolor).split('\n')[-1]
+        return str_safe(self.p_str)
+
+    def auto_rewrite(self):
+        """Print a string of the form '--->' which lines up with the previous
+        input string. Useful for systems which re-write the user input when
+        handling automatically special syntaxes."""
+
+        curr = str(self.cache.last_prompt)
+        nrspaces = len(self.rspace.search(curr).group())
+        return '%s%s>%s%s' % (self.col_p_ni,'-'*(len(curr)-nrspaces-1),
+                              ' '*nrspaces,self.col_norm_ni)
+
+class PromptOut(BasePrompt):
+    """Output interactive prompt similar to Mathematica's."""
+
+    def __init__(self,cache,sep='',prompt='Out[\\#]: ',pad_left=True):
+        BasePrompt.__init__(self,cache,sep,prompt,pad_left)
+        if not self.p_template:
+            self.__str__ = lambda: ''
+
+    def set_colors(self):
+        self.set_p_str()
+        Colors = self.cache.color_table.active_colors # shorthand
+        self.col_p = Colors.out_prompt
+        self.col_num = Colors.out_number
+        self.col_norm = Colors.normal
+
+class Prompt2(BasePrompt):
+    """Interactive continuation prompt."""
+    
+    def __init__(self,cache,prompt='   .\\D.: ',pad_left=True):
+        self.cache = cache
+        self.p_template = prompt
+        self.pad_left = pad_left
+        self.set_p_str()
+
+    def set_p_str(self):
+        import os,time  # needed in locals for prompt string handling
+        loc = locals()
+        self.p_str = ItplNS('%s%s%s' %
+                            ('${self.col_p2}',
+                             multiple_replace(prompt_specials, self.p_template),
+                             '$self.col_norm'),
+                            self.cache.user_ns,loc)
+        self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
+                                                     self.p_template),
+                                    self.cache.user_ns,loc)
+
+    def set_colors(self):
+        self.set_p_str()
+        Colors = self.cache.color_table.active_colors
+        self.col_p2 = Colors.in_prompt2
+        self.col_norm = Colors.in_normal
+        # FIXME (2004-06-16) HACK: prevent crashes for users who haven't
+        # updated their prompt_in2 definitions.  Remove eventually.
+        self.col_p = Colors.out_prompt
+        self.col_num = Colors.out_number
+
+
+#-----------------------------------------------------------------------------
+class CachedOutput:
+    """Class for printing output from calculations while keeping a cache of
+    reults. It dynamically creates global variables prefixed with _ which
+    contain these results.
+
+    Meant to be used as a sys.displayhook replacement, providing numbered
+    prompts and cache services.
+
+    Initialize with initial and final values for cache counter (this defines
+    the maximum size of the cache."""
+
+    def __init__(self,shell,cache_size,Pprint,
+                 colors='NoColor',input_sep='\n',
+                 output_sep='\n',output_sep2='',
+                 ps1 = None, ps2 = None,ps_out = None,pad_left=True):
+
+        cache_size_min = 3
+        if cache_size <= 0:
+            self.do_full_cache = 0
+            cache_size = 0
+        elif cache_size < cache_size_min:
+            self.do_full_cache = 0
+            cache_size = 0
+            warn('caching was disabled (min value for cache size is %s).' %
+                 cache_size_min,level=3)
+        else:
+            self.do_full_cache = 1
+
+        self.cache_size = cache_size
+        self.input_sep = input_sep
+
+        # we need a reference to the user-level namespace
+        self.shell = shell
+        self.user_ns = shell.user_ns
+        # and to the user's input
+        self.input_hist = shell.input_hist
+        # and to the user's logger, for logging output
+        self.logger = shell.logger
+
+        # Set input prompt strings and colors
+        if cache_size == 0:
+            if ps1.find('%n') > -1 or ps1.find(r'\#') > -1 \
+                   or ps1.find(r'\N') > -1:
+                ps1 = '>>> '
+            if ps2.find('%n') > -1 or ps2.find(r'\#') > -1 \
+                   or ps2.find(r'\N') > -1:
+                ps2 = '... '
+        self.ps1_str = self._set_prompt_str(ps1,'In [\\#]: ','>>> ')
+        self.ps2_str = self._set_prompt_str(ps2,'   .\\D.: ','... ')
+        self.ps_out_str = self._set_prompt_str(ps_out,'Out[\\#]: ','')
+
+        self.color_table = PromptColors
+        self.prompt1 = Prompt1(self,sep=input_sep,prompt=self.ps1_str,
+                               pad_left=pad_left)
+        self.prompt2 = Prompt2(self,prompt=self.ps2_str,pad_left=pad_left)
+        self.prompt_out = PromptOut(self,sep='',prompt=self.ps_out_str,
+                                    pad_left=pad_left)
+        self.set_colors(colors)
+
+        # other more normal stuff
+        # b/c each call to the In[] prompt raises it by 1, even the first.
+        self.prompt_count = 0
+        # Store the last prompt string each time, we need it for aligning
+        # continuation and auto-rewrite prompts
+        self.last_prompt = ''
+        self.Pprint = Pprint
+        self.output_sep = output_sep
+        self.output_sep2 = output_sep2
+        self._,self.__,self.___ = '','',''
+        self.pprint_types = map(type,[(),[],{}])
+        
+        # these are deliberately global:
+        to_user_ns = {'_':self._,'__':self.__,'___':self.___}
+        self.user_ns.update(to_user_ns)
+
+    def _set_prompt_str(self,p_str,cache_def,no_cache_def):
+        if p_str is None:
+            if self.do_full_cache:
+                return cache_def
+            else:
+                return no_cache_def
+        else:
+            return p_str
+                
+    def set_colors(self,colors):
+        """Set the active color scheme and configure colors for the three
+        prompt subsystems."""
+
+        # FIXME: the prompt_specials global should be gobbled inside this
+        # class instead.  Do it when cleaning up the whole 3-prompt system.
+        global prompt_specials
+        if colors.lower()=='nocolor':
+            prompt_specials = prompt_specials_nocolor
+        else:
+            prompt_specials = prompt_specials_color
+        
+        self.color_table.set_active_scheme(colors)
+        self.prompt1.set_colors()
+        self.prompt2.set_colors()
+        self.prompt_out.set_colors()
+
+    def __call__(self,arg=None):
+        """Printing with history cache management.
+        
+        This is invoked everytime the interpreter needs to print, and is
+        activated by setting the variable sys.displayhook to it."""
+
+        # If something injected a '_' variable in __builtin__, delete
+        # ipython's automatic one so we don't clobber that.  gettext() in
+        # particular uses _, so we need to stay away from it.
+        if '_' in __builtin__.__dict__:
+            try:
+                del self.user_ns['_']
+            except KeyError:
+                pass
+        if arg is not None:
+            cout_write = Term.cout.write # fast lookup
+            # first handle the cache and counters
+
+            # do not print output if input ends in ';'
+            try:
+                if self.input_hist[self.prompt_count].endswith(';\n'):
+                    return
+            except IndexError:
+                # some uses of ipshellembed may fail here
+                pass
+            # don't use print, puts an extra space
+            cout_write(self.output_sep)
+            outprompt = self.shell.hooks.generate_output_prompt()
+            if self.do_full_cache:
+                cout_write(outprompt)
+
+            # and now call a possibly user-defined print mechanism
+            manipulated_val = self.display(arg)
+            
+            # user display hooks can change the variable to be stored in
+            # output history
+            
+            if manipulated_val is not None:
+                arg = manipulated_val
+                
+            # avoid recursive reference when displaying _oh/Out
+            if arg is not self.user_ns['_oh']:
+                self.update(arg)
+
+            if self.logger.log_output:
+                self.logger.log_write(repr(arg),'output')
+            cout_write(self.output_sep2)
+            Term.cout.flush()
+
+    def _display(self,arg):
+        """Default printer method, uses pprint.
+
+        Do ip.set_hook("result_display", my_displayhook) for custom result
+        display, e.g. when your own objects need special formatting.
+        """
+        try:
+            return IPython.generics.result_display(arg)
+        except TryNext:            
+            return self.shell.hooks.result_display(arg)
+
+    # Assign the default display method:
+    display = _display
+
+    def update(self,arg):
+        #print '***cache_count', self.cache_count # dbg
+        if len(self.user_ns['_oh']) >= self.cache_size and self.do_full_cache:
+            warn('Output cache limit (currently '+
+                  `self.cache_size`+' entries) hit.\n'
+                 'Flushing cache and resetting history counter...\n'
+                 'The only history variables available will be _,__,___ and _1\n'
+                 'with the current result.')
+
+            self.flush()
+        # Don't overwrite '_' and friends if '_' is in __builtin__ (otherwise
+        # we cause buggy behavior for things like gettext).
+        if '_' not in __builtin__.__dict__:
+            self.___ = self.__
+            self.__ = self._
+            self._ = arg
+            self.user_ns.update({'_':self._,'__':self.__,'___':self.___})
+            
+        # hackish access to top-level  namespace to create _1,_2... dynamically
+        to_main = {}
+        if self.do_full_cache:
+            new_result = '_'+`self.prompt_count`
+            to_main[new_result] = arg
+            self.user_ns.update(to_main)
+            self.user_ns['_oh'][self.prompt_count] = arg
+
+    def flush(self):
+        if not self.do_full_cache:
+            raise ValueError,"You shouldn't have reached the cache flush "\
+                  "if full caching is not enabled!"
+        # delete auto-generated vars from global namespace
+        
+        for n in range(1,self.prompt_count + 1):
+            key = '_'+`n`
+            try:
+                del self.user_ns[key]
+            except: pass
+        self.user_ns['_oh'].clear()
+        
+        if '_' not in __builtin__.__dict__:
+            self.user_ns.update({'_':None,'__':None, '___':None})
+        import gc
+        gc.collect() # xxx needed?
+
diff --git a/IPython/PyColorize.py b/IPython/PyColorize.py
new file mode 100644
index 0000000..c435ff5
--- /dev/null
+++ b/IPython/PyColorize.py
@@ -0,0 +1,301 @@
+# -*- coding: utf-8 -*-
+"""
+    Class and program to colorize python source code for ANSI terminals.
+
+    Based on an HTML code highlighter by Jurgen Hermann found at:
+    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52298
+
+    Modifications by Fernando Perez (fperez@colorado.edu).
+
+    Information on the original HTML highlighter follows:
+    
+    MoinMoin - Python Source Parser
+
+    Title: Colorize Python source using the built-in tokenizer
+           
+    Submitter: Jurgen Hermann
+    Last Updated:2001/04/06
+           
+    Version no:1.2
+
+    Description:
+
+    This code is part of MoinMoin (http://moin.sourceforge.net/) and converts
+    Python source code to HTML markup, rendering comments, keywords,
+    operators, numeric and string literals in different colors.
+
+    It shows how to use the built-in keyword, token and tokenize modules to
+    scan Python source code and re-emit it with no changes to its original
+    formatting (which is the hard part).
+
+    $Id: PyColorize.py 2586 2007-08-06 19:30:09Z vivainio $"""
+
+__all__ = ['ANSICodeColors','Parser']
+
+_scheme_default = 'Linux'
+
+# Imports
+import cStringIO
+import keyword
+import os
+import optparse
+import string
+import sys
+import token
+import tokenize
+
+from IPython.ColorANSI import *
+
+#############################################################################
+### Python Source Parser (does Hilighting)
+#############################################################################
+
+_KEYWORD = token.NT_OFFSET + 1
+_TEXT    = token.NT_OFFSET + 2
+
+#****************************************************************************
+# Builtin color schemes
+
+Colors = TermColors  # just a shorthand
+
+# Build a few color schemes
+NoColor = ColorScheme(
+    'NoColor',{
+    token.NUMBER     : Colors.NoColor,
+    token.OP         : Colors.NoColor,
+    token.STRING     : Colors.NoColor,
+    tokenize.COMMENT : Colors.NoColor,
+    token.NAME       : Colors.NoColor,
+    token.ERRORTOKEN : Colors.NoColor,
+
+    _KEYWORD         : Colors.NoColor,
+    _TEXT            : Colors.NoColor,
+
+    'normal'         : Colors.NoColor  # color off (usu. Colors.Normal)
+    }  )
+
+LinuxColors = ColorScheme(
+    'Linux',{
+    token.NUMBER     : Colors.LightCyan,
+    token.OP         : Colors.Yellow,
+    token.STRING     : Colors.LightBlue,
+    tokenize.COMMENT : Colors.LightRed,
+    token.NAME       : Colors.White,
+    token.ERRORTOKEN : Colors.Red,
+
+    _KEYWORD         : Colors.LightGreen,
+    _TEXT            : Colors.Yellow,
+
+    'normal'         : Colors.Normal  # color off (usu. Colors.Normal)
+    } )
+
+LightBGColors = ColorScheme(
+    'LightBG',{
+    token.NUMBER     : Colors.Cyan,
+    token.OP         : Colors.Blue,
+    token.STRING     : Colors.Blue,
+    tokenize.COMMENT : Colors.Red,
+    token.NAME       : Colors.Black,
+    token.ERRORTOKEN : Colors.Red,
+
+    _KEYWORD         : Colors.Green,
+    _TEXT            : Colors.Blue,
+
+    'normal'         : Colors.Normal  # color off (usu. Colors.Normal)
+    }  )
+
+# Build table of color schemes (needed by the parser)
+ANSICodeColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
+                                  _scheme_default)
+
+class Parser:
+    """ Format colored Python source.
+    """
+
+    def __init__(self, color_table=None,out = sys.stdout):
+        """ Create a parser with a specified color table and output channel.
+
+        Call format() to process code.
+        """
+        self.color_table = color_table and color_table or ANSICodeColors
+        self.out = out
+
+    def format(self, raw, out = None, scheme = ''):
+        return self.format2(raw, out, scheme)[0]
+
+    def format2(self, raw, out = None, scheme = ''):
+        """ Parse and send the colored source.
+
+        If out and scheme are not specified, the defaults (given to
+        constructor) are used.
+
+        out should be a file-type object. Optionally, out can be given as the
+        string 'str' and the parser will automatically return the output in a
+        string."""
+        
+        string_output = 0
+        if out == 'str' or self.out == 'str' or \
+           isinstance(self.out,cStringIO.OutputType):
+            # XXX - I don't really like this state handling logic, but at this
+            # point I don't want to make major changes, so adding the
+            # isinstance() check is the simplest I can do to ensure correct
+            # behavior.
+            out_old = self.out
+            self.out = cStringIO.StringIO()
+            string_output = 1
+        elif out is not None:
+            self.out = out
+
+        # Fast return of the unmodified input for NoColor scheme
+        if scheme == 'NoColor':
+            error = False
+            self.out.write(raw)
+            if string_output:
+                return raw,error
+            else:
+                return None,error
+        
+        # local shorthands
+        colors = self.color_table[scheme].colors
+        self.colors = colors # put in object so __call__ sees it
+
+        # Remove trailing whitespace and normalize tabs
+        self.raw = raw.expandtabs().rstrip()
+        
+        # store line offsets in self.lines
+        self.lines = [0, 0]
+        pos = 0
+        raw_find = self.raw.find
+        lines_append = self.lines.append
+        while 1:
+            pos = raw_find('\n', pos) + 1
+            if not pos: break
+            lines_append(pos)
+        lines_append(len(self.raw))
+
+        # parse the source and write it
+        self.pos = 0
+        text = cStringIO.StringIO(self.raw)
+
+        error = False
+        try:
+            tokenize.tokenize(text.readline, self)
+        except tokenize.TokenError, ex:
+            msg = ex[0]
+            line = ex[1][0]
+            self.out.write("%s\n\n*** ERROR: %s%s%s\n" %
+                           (colors[token.ERRORTOKEN],
+                            msg, self.raw[self.lines[line]:],
+                            colors.normal)
+                           )
+            error = True
+        self.out.write(colors.normal+'\n')
+        if string_output:
+            output = self.out.getvalue()
+            self.out = out_old
+            return (output, error)
+        return (None, error)
+
+    def __call__(self, toktype, toktext, (srow,scol), (erow,ecol), line):
+        """ Token handler, with syntax highlighting."""
+
+        # local shorthands
+        colors = self.colors
+        owrite = self.out.write
+
+        # line separator, so this works across platforms
+        linesep = os.linesep
+
+        # calculate new positions
+        oldpos = self.pos
+        newpos = self.lines[srow] + scol
+        self.pos = newpos + len(toktext)
+
+        # handle newlines
+        if toktype in [token.NEWLINE, tokenize.NL]:
+            owrite(linesep)
+            return
+
+        # send the original whitespace, if needed
+        if newpos > oldpos:
+            owrite(self.raw[oldpos:newpos])
+
+        # skip indenting tokens
+        if toktype in [token.INDENT, token.DEDENT]:
+            self.pos = newpos
+            return
+
+        # map token type to a color group
+        if token.LPAR <= toktype and toktype <= token.OP:
+            toktype = token.OP
+        elif toktype == token.NAME and keyword.iskeyword(toktext):
+            toktype = _KEYWORD
+        color = colors.get(toktype, colors[_TEXT])
+
+        #print '<%s>' % toktext,    # dbg
+
+        # Triple quoted strings must be handled carefully so that backtracking
+        # in pagers works correctly. We need color terminators on _each_ line.
+        if linesep in toktext:
+            toktext = toktext.replace(linesep, '%s%s%s' %
+                                      (colors.normal,linesep,color))
+
+        # send text
+        owrite('%s%s%s' % (color,toktext,colors.normal))
+            
+def main(argv=None):
+    """Run as a command-line script: colorize a python file or stdin using ANSI
+    color escapes and print to stdout.
+
+    Inputs:
+
+      - argv(None): a list of strings like sys.argv[1:] giving the command-line
+        arguments. If None, use sys.argv[1:].
+    """
+
+    usage_msg = """%prog [options] [filename]
+
+Colorize a python file or stdin using ANSI color escapes and print to stdout.
+If no filename is given, or if filename is -, read standard input."""
+
+    parser = optparse.OptionParser(usage=usage_msg)
+    newopt = parser.add_option
+    newopt('-s','--scheme',metavar='NAME',dest='scheme_name',action='store',
+           choices=['Linux','LightBG','NoColor'],default=_scheme_default,
+           help="give the color scheme to use. Currently only 'Linux'\
+ (default) and 'LightBG' and 'NoColor' are implemented (give without\
+ quotes)")
+
+    opts,args = parser.parse_args(argv)
+
+    if len(args) > 1:
+        parser.error("you must give at most one filename.")
+
+    if len(args) == 0:
+        fname = '-' # no filename given; setup to read from stdin
+    else:
+        fname = args[0]
+
+    if fname == '-':
+        stream = sys.stdin
+    else:
+        stream = file(fname)
+
+    parser = Parser()
+
+    # we need nested try blocks because pre-2.5 python doesn't support unified
+    # try-except-finally
+    try:
+        try:
+            # write colorized version to stdout
+            parser.format(stream.read(),scheme=opts.scheme_name)
+        except IOError,msg:
+            # if user reads through a pager and quits, don't print traceback
+            if msg.args != (32,'Broken pipe'):
+                raise
+    finally:
+        if stream is not sys.stdin:
+            stream.close() # in case a non-handled exception happened above
+
+if __name__ == "__main__":
+    main()
diff --git a/IPython/Release.py b/IPython/Release.py
new file mode 100644
index 0000000..ad37817
--- /dev/null
+++ b/IPython/Release.py
@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+"""Release data for the IPython project.
+
+$Id: Release.py 3002 2008-02-01 07:17:00Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#       Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray
+#       <n8gray@caltech.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+# Name of the package for release purposes.  This is the name which labels
+# the tarballs and RPMs made by distutils, so it's best to lowercase it.
+name = 'ipython'
+
+# For versions with substrings (like 0.6.16.svn), use an extra . to separate
+# the new substring.  We have to avoid using either dashes or underscores,
+# because bdist_rpm does not accept dashes (an RPM) convention, and
+# bdist_deb does not accept underscores (a Debian convention).
+
+revision = '3001'
+
+version = '0.8.3.svn.r' + revision.rstrip('M')
+
+description = "An enhanced interactive Python shell."
+
+long_description = \
+"""
+IPython provides a replacement for the interactive Python interpreter with
+extra functionality.
+
+Main features:
+
+ * Comprehensive object introspection.
+
+ * Input history, persistent across sessions.
+
+ * Caching of output results during a session with automatically generated
+   references.
+
+ * Readline based name completion.
+
+ * Extensible system of 'magic' commands for controlling the environment and
+   performing many tasks related either to IPython or the operating system.
+
+ * Configuration system with easy switching between different setups (simpler
+   than changing $PYTHONSTARTUP environment variables every time).
+
+ * Session logging and reloading.
+
+ * Extensible syntax processing for special purpose situations.
+
+ * Access to the system shell with user-extensible alias system.
+
+ * Easily embeddable in other Python programs.
+
+ * Integrated access to the pdb debugger and the Python profiler. 
+
+ The latest development version is always available at the IPython subversion
+ repository_.
+
+.. _repository: http://ipython.scipy.org/svn/ipython/ipython/trunk#egg=ipython-dev
+ """
+
+license = 'BSD'
+
+authors = {'Fernando' : ('Fernando Perez','fperez@colorado.edu'),
+           'Janko'    : ('Janko Hauser','jhauser@zscout.de'),
+           'Nathan'   : ('Nathaniel Gray','n8gray@caltech.edu'),
+           'Ville'    : ('Ville Vainio','vivainio@gmail.com')           
+           }
+
+url = 'http://ipython.scipy.org'
+
+download_url = 'http://ipython.scipy.org/dist'
+
+platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME']
+
+keywords = ['Interactive','Interpreter','Shell']
diff --git a/IPython/Shell.py b/IPython/Shell.py
new file mode 100644
index 0000000..64d93b2
--- /dev/null
+++ b/IPython/Shell.py
@@ -0,0 +1,1205 @@
+# -*- coding: utf-8 -*-
+"""IPython Shell classes.
+
+All the matplotlib support code was co-developed with John Hunter,
+matplotlib's author.
+
+$Id: Shell.py 3024 2008-02-07 15:34:42Z darren.dale $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+# Code begins
+# Stdlib imports
+import __builtin__
+import __main__
+import Queue
+import inspect
+import os
+import sys
+import thread
+import threading
+import time
+
+from signal import signal, SIGINT
+
+try:
+    import ctypes
+    HAS_CTYPES = True
+except ImportError:
+    HAS_CTYPES = False
+
+# IPython imports
+import IPython
+from IPython import ultraTB, ipapi
+from IPython.genutils import Term,warn,error,flag_calls, ask_yes_no
+from IPython.iplib import InteractiveShell
+from IPython.ipmaker import make_IPython
+from IPython.Magic import Magic
+from IPython.ipstruct import Struct
+
+# Globals
+# global flag to pass around information about Ctrl-C without exceptions
+KBINT = False
+
+# global flag to turn on/off Tk support.
+USE_TK = False
+
+# ID for the main thread, used for cross-thread exceptions
+MAIN_THREAD_ID = thread.get_ident()
+
+# Tag when runcode() is active, for exception handling
+CODE_RUN = None
+
+#-----------------------------------------------------------------------------
+# This class is trivial now, but I want to have it in to publish a clean
+# interface. Later when the internals are reorganized, code that uses this
+# shouldn't have to change.
+
+class IPShell:
+    """Create an IPython instance."""
+    
+    def __init__(self,argv=None,user_ns=None,user_global_ns=None,
+                 debug=1,shell_class=InteractiveShell):
+        self.IP = make_IPython(argv,user_ns=user_ns,
+                               user_global_ns=user_global_ns,
+                               debug=debug,shell_class=shell_class)
+
+    def mainloop(self,sys_exit=0,banner=None):
+        self.IP.mainloop(banner)
+        if sys_exit:
+            sys.exit()
+
+#-----------------------------------------------------------------------------
+def kill_embedded(self,parameter_s=''):
+    """%kill_embedded : deactivate for good the current embedded IPython.
+
+    This function (after asking for confirmation) sets an internal flag so that
+    an embedded IPython will never activate again.  This is useful to
+    permanently disable a shell that is being called inside a loop: once you've
+    figured out what you needed from it, you may then kill it and the program
+    will then continue to run without the interactive shell interfering again.
+    """
+    
+    kill = ask_yes_no("Are you sure you want to kill this embedded instance "
+                     "(y/n)? [y/N] ",'n')
+    if kill:
+        self.shell.embedded_active = False
+        print "This embedded IPython will not reactivate anymore once you exit."
+    
+class IPShellEmbed:
+    """Allow embedding an IPython shell into a running program.
+
+    Instances of this class are callable, with the __call__ method being an
+    alias to the embed() method of an InteractiveShell instance.
+
+    Usage (see also the example-embed.py file for a running example):
+
+    ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
+
+    - argv: list containing valid command-line options for IPython, as they
+    would appear in sys.argv[1:].
+
+    For example, the following command-line options:
+
+      $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
+
+    would be passed in the argv list as:
+
+      ['-prompt_in1','Input <\\#>','-colors','LightBG']
+
+    - banner: string which gets printed every time the interpreter starts.
+
+    - exit_msg: string which gets printed every time the interpreter exits.
+
+    - rc_override: a dict or Struct of configuration options such as those
+    used by IPython. These options are read from your ~/.ipython/ipythonrc
+    file when the Shell object is created. Passing an explicit rc_override
+    dict with any options you want allows you to override those values at
+    creation time without having to modify the file. This way you can create
+    embeddable instances configured in any way you want without editing any
+    global files (thus keeping your interactive IPython configuration
+    unchanged).
+
+    Then the ipshell instance can be called anywhere inside your code:
+    
+    ipshell(header='') -> Opens up an IPython shell.
+
+    - header: string printed by the IPython shell upon startup. This can let
+    you know where in your code you are when dropping into the shell. Note
+    that 'banner' gets prepended to all calls, so header is used for
+    location-specific information.
+
+    For more details, see the __call__ method below.
+
+    When the IPython shell is exited with Ctrl-D, normal program execution
+    resumes.
+
+    This functionality was inspired by a posting on comp.lang.python by cmkl
+    <cmkleffner@gmx.de> on Dec. 06/01 concerning similar uses of pyrepl, and
+    by the IDL stop/continue commands."""
+
+    def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None,
+                 user_ns=None):
+        """Note that argv here is a string, NOT a list."""
+        self.set_banner(banner)
+        self.set_exit_msg(exit_msg)
+        self.set_dummy_mode(0)
+
+        # sys.displayhook is a global, we need to save the user's original
+        # Don't rely on __displayhook__, as the user may have changed that.
+        self.sys_displayhook_ori = sys.displayhook
+
+        # save readline completer status
+        try:
+            #print 'Save completer',sys.ipcompleter  # dbg
+            self.sys_ipcompleter_ori = sys.ipcompleter
+        except:
+            pass # not nested with IPython
+        
+        self.IP = make_IPython(argv,rc_override=rc_override,
+                               embedded=True,
+                               user_ns=user_ns)
+
+        ip = ipapi.IPApi(self.IP)
+        ip.expose_magic("kill_embedded",kill_embedded)
+
+        # copy our own displayhook also
+        self.sys_displayhook_embed = sys.displayhook
+        # and leave the system's display hook clean
+        sys.displayhook = self.sys_displayhook_ori
+        # don't use the ipython crash handler so that user exceptions aren't
+        # trapped
+        sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
+                                             mode = self.IP.rc.xmode,
+                                             call_pdb = self.IP.rc.pdb)
+        self.restore_system_completer()
+
+    def restore_system_completer(self):
+        """Restores the readline completer which was in place.
+
+        This allows embedded IPython within IPython not to disrupt the
+        parent's completion.
+        """
+        
+        try:
+            self.IP.readline.set_completer(self.sys_ipcompleter_ori)
+            sys.ipcompleter = self.sys_ipcompleter_ori
+        except:
+            pass
+
+    def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
+        """Activate the interactive interpreter.
+
+        __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
+        the interpreter shell with the given local and global namespaces, and
+        optionally print a header string at startup.
+
+        The shell can be globally activated/deactivated using the
+        set/get_dummy_mode methods. This allows you to turn off a shell used
+        for debugging globally.
+
+        However, *each* time you call the shell you can override the current
+        state of dummy_mode with the optional keyword parameter 'dummy'. For
+        example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
+        can still have a specific call work by making it as IPShell(dummy=0).
+
+        The optional keyword parameter dummy controls whether the call
+        actually does anything.  """
+
+        # If the user has turned it off, go away
+        if not self.IP.embedded_active:
+            return
+
+        # Normal exits from interactive mode set this flag, so the shell can't
+        # re-enter (it checks this variable at the start of interactive mode).
+        self.IP.exit_now = False
+
+        # Allow the dummy parameter to override the global __dummy_mode
+        if dummy or (dummy != 0 and self.__dummy_mode):
+            return
+
+        # Set global subsystems (display,completions) to our values
+        sys.displayhook = self.sys_displayhook_embed
+        if self.IP.has_readline:
+            self.IP.set_completer()
+
+        if self.banner and header:
+            format = '%s\n%s\n'
+        else:
+            format = '%s%s\n'
+        banner =  format % (self.banner,header)
+
+        # Call the embedding code with a stack depth of 1 so it can skip over
+        # our call and get the original caller's namespaces.
+        self.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
+
+        if self.exit_msg:
+            print self.exit_msg
+            
+        # Restore global systems (display, completion)
+        sys.displayhook = self.sys_displayhook_ori
+        self.restore_system_completer()
+    
+    def set_dummy_mode(self,dummy):
+        """Sets the embeddable shell's dummy mode parameter.
+
+        set_dummy_mode(dummy): dummy = 0 or 1.
+
+        This parameter is persistent and makes calls to the embeddable shell
+        silently return without performing any action. This allows you to
+        globally activate or deactivate a shell you're using with a single call.
+
+        If you need to manually"""
+
+        if dummy not in [0,1,False,True]:
+            raise ValueError,'dummy parameter must be boolean'
+        self.__dummy_mode = dummy
+
+    def get_dummy_mode(self):
+        """Return the current value of the dummy mode parameter.
+        """
+        return self.__dummy_mode
+    
+    def set_banner(self,banner):
+        """Sets the global banner.
+
+        This banner gets prepended to every header printed when the shell
+        instance is called."""
+
+        self.banner = banner
+
+    def set_exit_msg(self,exit_msg):
+        """Sets the global exit_msg.
+
+        This exit message gets printed upon exiting every time the embedded
+        shell is called. It is None by default. """
+
+        self.exit_msg = exit_msg
+
+#-----------------------------------------------------------------------------
+if HAS_CTYPES:
+    #  Add async exception support.  Trick taken from:
+    # http://sebulba.wikispaces.com/recipe+thread2
+    def _async_raise(tid, exctype):
+        """raises the exception, performs cleanup if needed"""
+        if not inspect.isclass(exctype):
+            raise TypeError("Only types can be raised (not instances)")
+        res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid,
+                                                         ctypes.py_object(exctype))
+        if res == 0:
+            raise ValueError("invalid thread id")
+        elif res != 1:
+            # """if it returns a number greater than one, you're in trouble, 
+            # and you should call it again with exc=NULL to revert the effect"""
+            ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
+            raise SystemError("PyThreadState_SetAsyncExc failed")
+
+    def sigint_handler (signum,stack_frame):
+        """Sigint handler for threaded apps.
+
+        This is a horrible hack to pass information about SIGINT _without_
+        using exceptions, since I haven't been able to properly manage
+        cross-thread exceptions in GTK/WX.  In fact, I don't think it can be
+        done (or at least that's my understanding from a c.l.py thread where
+        this was discussed)."""
+
+        global KBINT
+
+        if CODE_RUN:
+            _async_raise(MAIN_THREAD_ID,KeyboardInterrupt)
+        else:
+            KBINT = True
+            print '\nKeyboardInterrupt - Press <Enter> to continue.',
+            Term.cout.flush()
+
+else:
+    def sigint_handler (signum,stack_frame):
+        """Sigint handler for threaded apps.
+
+        This is a horrible hack to pass information about SIGINT _without_
+        using exceptions, since I haven't been able to properly manage
+        cross-thread exceptions in GTK/WX.  In fact, I don't think it can be
+        done (or at least that's my understanding from a c.l.py thread where
+        this was discussed)."""
+
+        global KBINT
+
+        print '\nKeyboardInterrupt - Press <Enter> to continue.',
+        Term.cout.flush()
+        # Set global flag so that runsource can know that Ctrl-C was hit
+        KBINT = True
+
+
+class MTInteractiveShell(InteractiveShell):
+    """Simple multi-threaded shell."""
+
+    # Threading strategy taken from:
+    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
+    # McErlean and John Finlay.  Modified with corrections by Antoon Pardon,
+    # from the pygtk mailing list, to avoid lockups with system calls.
+
+    # class attribute to indicate whether the class supports threads or not.
+    # Subclasses with thread support should override this as needed.
+    isthreaded = True
+
+    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
+                 user_ns=None,user_global_ns=None,banner2='',**kw):
+        """Similar to the normal InteractiveShell, but with threading control"""
+        
+        InteractiveShell.__init__(self,name,usage,rc,user_ns,
+                                  user_global_ns,banner2)
+
+        # Locking control variable.
+        self.thread_ready = threading.Condition(threading.RLock())
+
+        # A queue to hold the code to be executed.  A scalar variable is NOT
+        # enough, because uses like macros cause reentrancy.
+        self.code_queue = Queue.Queue()
+
+        # Stuff to do at closing time
+        self._kill = False
+        on_kill = kw.get('on_kill')
+        if on_kill is None:
+            on_kill = []
+        # Check that all things to kill are callable:
+        for t in on_kill:
+            if not callable(t):
+                raise TypeError,'on_kill must be a list of callables'
+        self.on_kill = on_kill
+
+    def runsource(self, source, filename="<input>", symbol="single"):
+        """Compile and run some source in the interpreter.
+
+        Modified version of code.py's runsource(), to handle threading issues.
+        See the original for full docstring details."""
+
+        global KBINT
+        
+        # If Ctrl-C was typed, we reset the flag and return right away
+        if KBINT:
+            KBINT = False
+            return False
+        
+        try:
+            code = self.compile(source, filename, symbol)
+        except (OverflowError, SyntaxError, ValueError):
+            # Case 1
+            self.showsyntaxerror(filename)
+            return False
+
+        if code is None:
+            # Case 2
+            return True
+
+        # Case 3
+        # Store code in queue, so the execution thread can handle it.
+
+        # Note that with macros and other applications, we MAY re-enter this
+        # section, so we have to acquire the lock with non-blocking semantics,
+        # else we deadlock.
+        got_lock = self.thread_ready.acquire()
+        self.code_queue.put(code)
+        if got_lock:
+           self.thread_ready.wait()  # Wait until processed in timeout interval
+        self.thread_ready.release()
+
+        return False
+
+    def runcode(self):
+        """Execute a code object.
+
+        Multithreaded wrapper around IPython's runcode()."""
+
+        global CODE_RUN
+
+        # lock thread-protected stuff
+        got_lock = self.thread_ready.acquire()
+
+        if self._kill:
+            print >>Term.cout, 'Closing threads...',
+            Term.cout.flush()
+            for tokill in self.on_kill:
+                tokill()
+            print >>Term.cout, 'Done.'
+
+        # Install sigint handler.  We do it every time to ensure that if user
+        # code modifies it, we restore our own handling.
+        try:
+            signal(SIGINT,sigint_handler)
+        except SystemError:
+            # This happens under Windows, which seems to have all sorts
+            # of problems with signal handling.  Oh well...
+            pass
+
+        # Flush queue of pending code by calling the run methood of the parent
+        # class with all items which may be in the queue.
+        code_to_run = None
+        while 1:
+            try:
+                code_to_run = self.code_queue.get_nowait()
+            except Queue.Empty:
+                break
+
+            # Exceptions need to be raised differently depending on which
+            # thread is active.  This convoluted try/except is only there to
+            # protect against asynchronous exceptions, to ensure that a KBINT
+            # at the wrong time doesn't deadlock everything.  The global
+            # CODE_TO_RUN is set to true/false as close as possible to the
+            # runcode() call, so that the KBINT handler is correctly informed.
+            try:
+                try:
+                   CODE_RUN = True
+                   InteractiveShell.runcode(self,code_to_run)
+                except KeyboardInterrupt:
+                   print "Keyboard interrupted in mainloop"
+                   while not self.code_queue.empty():
+                      self.code_queue.get_nowait()
+                   break
+            finally:
+               if got_lock:
+                  CODE_RUN = False
+
+        # We're done with thread-protected variables
+        if code_to_run is not None:
+           self.thread_ready.notify()
+        self.thread_ready.release()
+
+        # We're done...
+        CODE_RUN = False
+        # This MUST return true for gtk threading to work
+        return True
+
+    def kill(self):
+        """Kill the thread, returning when it has been shut down."""
+        got_lock = self.thread_ready.acquire(False)
+        self._kill = True
+        if got_lock:
+            self.thread_ready.release()
+
+class MatplotlibShellBase:
+    """Mixin class to provide the necessary modifications to regular IPython
+    shell classes for matplotlib support.
+
+    Given Python's MRO, this should be used as the FIRST class in the
+    inheritance hierarchy, so that it overrides the relevant methods."""
+    
+    def _matplotlib_config(self,name,user_ns):
+        """Return items needed to setup the user's shell with matplotlib"""
+
+        # Initialize matplotlib to interactive mode always
+        import matplotlib
+        from matplotlib import backends
+        matplotlib.interactive(True)
+
+        def use(arg):
+            """IPython wrapper for matplotlib's backend switcher.
+
+            In interactive use, we can not allow switching to a different
+            interactive backend, since thread conflicts will most likely crash
+            the python interpreter.  This routine does a safety check first,
+            and refuses to perform a dangerous switch.  It still allows
+            switching to non-interactive backends."""
+
+            if arg in backends.interactive_bk and arg != self.mpl_backend:
+                m=('invalid matplotlib backend switch.\n'
+                   'This script attempted to switch to the interactive '
+                   'backend: `%s`\n'
+                   'Your current choice of interactive backend is: `%s`\n\n'
+                   'Switching interactive matplotlib backends at runtime\n'
+                   'would crash the python interpreter, '
+                   'and IPython has blocked it.\n\n'
+                   'You need to either change your choice of matplotlib backend\n'
+                   'by editing your .matplotlibrc file, or run this script as a \n'
+                   'standalone file from the command line, not using IPython.\n' %
+                   (arg,self.mpl_backend) )
+                raise RuntimeError, m
+            else:
+                self.mpl_use(arg)
+                self.mpl_use._called = True
+        
+        self.matplotlib = matplotlib
+        self.mpl_backend = matplotlib.rcParams['backend']
+
+        # we also need to block switching of interactive backends by use()
+        self.mpl_use = matplotlib.use
+        self.mpl_use._called = False
+        # overwrite the original matplotlib.use with our wrapper
+        matplotlib.use = use
+
+        # This must be imported last in the matplotlib series, after
+        # backend/interactivity choices have been made
+        import matplotlib.pylab as pylab
+        self.pylab = pylab
+
+        self.pylab.show._needmain = False
+        # We need to detect at runtime whether show() is called by the user.
+        # For this, we wrap it into a decorator which adds a 'called' flag.
+        self.pylab.draw_if_interactive = flag_calls(self.pylab.draw_if_interactive)
+
+        # Build a user namespace initialized with matplotlib/matlab features.
+        user_ns = IPython.ipapi.make_user_ns(user_ns)
+
+        exec ("import matplotlib\n"
+              "import matplotlib.pylab as pylab\n") in user_ns
+        
+        # Build matplotlib info banner
+        b="""
+  Welcome to pylab, a matplotlib-based Python environment.
+  For more information, type 'help(pylab)'.
+"""
+        return user_ns,b
+
+    def mplot_exec(self,fname,*where,**kw):
+        """Execute a matplotlib script.
+
+        This is a call to execfile(), but wrapped in safeties to properly
+        handle interactive rendering and backend switching."""
+
+        #print '*** Matplotlib runner ***' # dbg
+        # turn off rendering until end of script
+        isInteractive = self.matplotlib.rcParams['interactive']
+        self.matplotlib.interactive(False)
+        self.safe_execfile(fname,*where,**kw)
+        self.matplotlib.interactive(isInteractive)
+        # make rendering call now, if the user tried to do it
+        if self.pylab.draw_if_interactive.called:
+            self.pylab.draw()
+            self.pylab.draw_if_interactive.called = False
+                
+        # if a backend switch was performed, reverse it now
+        if self.mpl_use._called:
+            self.matplotlib.rcParams['backend'] = self.mpl_backend
+        
+    def magic_run(self,parameter_s=''):
+        Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
+
+    # Fix the docstring so users see the original as well
+    magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
+                                    "\n        *** Modified %run for Matplotlib,"
+                                    " with proper interactive handling ***")
+
+# Now we provide 2 versions of a matplotlib-aware IPython base shells, single
+# and multithreaded.  Note that these are meant for internal use, the IPShell*
+# classes below are the ones meant for public consumption.
+
+class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
+    """Single-threaded shell with matplotlib support."""
+
+    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
+                 user_ns=None,user_global_ns=None,**kw):
+        user_ns,b2 = self._matplotlib_config(name,user_ns)
+        InteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
+                                  banner2=b2,**kw)
+
+class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
+    """Multi-threaded shell with matplotlib support."""
+
+    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
+                 user_ns=None,user_global_ns=None, **kw):
+        user_ns,b2 = self._matplotlib_config(name,user_ns)
+        MTInteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
+                                    banner2=b2,**kw)
+
+#-----------------------------------------------------------------------------
+# Utility functions for the different GUI enabled IPShell* classes.
+
+def get_tk():
+    """Tries to import Tkinter and returns a withdrawn Tkinter root
+    window.  If Tkinter is already imported or not available, this
+    returns None.  This function calls `hijack_tk` underneath.
+    """
+    if not USE_TK or sys.modules.has_key('Tkinter'):
+        return None
+    else:
+        try:
+            import Tkinter
+        except ImportError:
+            return None
+        else:
+            hijack_tk()
+            r = Tkinter.Tk()
+            r.withdraw()
+            return r
+
+def hijack_tk():
+    """Modifies Tkinter's mainloop with a dummy so when a module calls
+    mainloop, it does not block.
+
+    """
+    def misc_mainloop(self, n=0):
+        pass
+    def tkinter_mainloop(n=0):
+        pass
+    
+    import Tkinter
+    Tkinter.Misc.mainloop = misc_mainloop
+    Tkinter.mainloop = tkinter_mainloop
+
+def update_tk(tk):
+    """Updates the Tkinter event loop.  This is typically called from
+    the respective WX or GTK mainloops.
+    """    
+    if tk:
+        tk.update()
+
+def hijack_wx():
+    """Modifies wxPython's MainLoop with a dummy so user code does not
+    block IPython.  The hijacked mainloop function is returned.
+    """    
+    def dummy_mainloop(*args, **kw):
+        pass
+
+    try:
+        import wx
+    except ImportError:
+        # For very old versions of WX
+        import wxPython as wx
+        
+    ver = wx.__version__
+    orig_mainloop = None
+    if ver[:3] >= '2.5':
+        import wx
+        if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
+        elif hasattr(wx, '_core'): core = getattr(wx, '_core')
+        else: raise AttributeError('Could not find wx core module')
+        orig_mainloop = core.PyApp_MainLoop
+        core.PyApp_MainLoop = dummy_mainloop
+    elif ver[:3] == '2.4':
+        orig_mainloop = wx.wxc.wxPyApp_MainLoop
+        wx.wxc.wxPyApp_MainLoop = dummy_mainloop
+    else:
+        warn("Unable to find either wxPython version 2.4 or >= 2.5.")
+    return orig_mainloop
+
+def hijack_gtk():
+    """Modifies pyGTK's mainloop with a dummy so user code does not
+    block IPython.  This function returns the original `gtk.mainloop`
+    function that has been hijacked.
+    """    
+    def dummy_mainloop(*args, **kw):
+        pass
+    import gtk
+    if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
+    else:                            orig_mainloop = gtk.mainloop
+    gtk.mainloop = dummy_mainloop
+    gtk.main = dummy_mainloop
+    return orig_mainloop
+
+def hijack_qt():
+    """Modifies PyQt's mainloop with a dummy so user code does not 
+    block IPython.  This function returns the original 
+    `qt.qApp.exec_loop` function that has been hijacked.
+    """    
+    def dummy_mainloop(*args, **kw):
+        pass
+    import qt
+    orig_mainloop = qt.qApp.exec_loop
+    qt.qApp.exec_loop = dummy_mainloop
+    qt.QApplication.exec_loop = dummy_mainloop
+    return orig_mainloop
+
+def hijack_qt4():
+    """Modifies PyQt4's mainloop with a dummy so user code does not
+    block IPython.  This function returns the original 
+    `QtGui.qApp.exec_` function that has been hijacked.
+    """    
+    def dummy_mainloop(*args, **kw):
+        pass
+    from PyQt4 import QtGui, QtCore
+    orig_mainloop = QtGui.qApp.exec_
+    QtGui.qApp.exec_ = dummy_mainloop
+    QtGui.QApplication.exec_ = dummy_mainloop
+    QtCore.QCoreApplication.exec_ = dummy_mainloop
+    return orig_mainloop
+
+#-----------------------------------------------------------------------------
+# The IPShell* classes below are the ones meant to be run by external code as
+# IPython instances.  Note that unless a specific threading strategy is
+# desired, the factory function start() below should be used instead (it
+# selects the proper threaded class).
+
+class IPThread(threading.Thread):
+    def run(self):
+        self.IP.mainloop(self._banner)
+        self.IP.kill()
+
+class IPShellGTK(IPThread):
+    """Run a gtk mainloop() in a separate thread.
+    
+    Python commands can be passed to the thread where they will be executed.
+    This is implemented by periodically checking for passed code using a
+    GTK timeout callback."""
+    
+    TIMEOUT = 100 # Millisecond interval between timeouts.
+
+    def __init__(self,argv=None,user_ns=None,user_global_ns=None,
+                 debug=1,shell_class=MTInteractiveShell):
+
+        import gtk
+        
+        self.gtk = gtk
+        self.gtk_mainloop = hijack_gtk()
+
+        # Allows us to use both Tk and GTK.
+        self.tk = get_tk()
+        
+        if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
+        else:                            mainquit = self.gtk.mainquit
+
+        self.IP = make_IPython(argv,user_ns=user_ns,
+                               user_global_ns=user_global_ns,
+                               debug=debug,
+                               shell_class=shell_class,
+                               on_kill=[mainquit])
+
+        # HACK: slot for banner in self; it will be passed to the mainloop
+        # method only and .run() needs it.  The actual value will be set by
+        # .mainloop().
+        self._banner = None 
+
+        threading.Thread.__init__(self)
+
+    def mainloop(self,sys_exit=0,banner=None):
+
+        self._banner = banner
+        
+        if self.gtk.pygtk_version >= (2,4,0):
+            import gobject
+            gobject.idle_add(self.on_timer)
+        else:
+            self.gtk.idle_add(self.on_timer)
+
+        if sys.platform != 'win32':
+            try:
+                if self.gtk.gtk_version[0] >= 2:
+                    self.gtk.gdk.threads_init()
+            except AttributeError:
+                pass
+            except RuntimeError:
+                error('Your pyGTK likely has not been compiled with '
+                      'threading support.\n'
+                      'The exception printout is below.\n'
+                      'You can either rebuild pyGTK with threads, or '
+                      'try using \n'
+                      'matplotlib with a different backend (like Tk or WX).\n'
+                      'Note that matplotlib will most likely not work in its '
+                      'current state!')
+                self.IP.InteractiveTB()
+
+        self.start()
+        self.gtk.gdk.threads_enter()
+        self.gtk_mainloop()
+        self.gtk.gdk.threads_leave()
+        self.join()
+
+    def on_timer(self):
+        """Called when GTK is idle.
+
+        Must return True always, otherwise GTK stops calling it"""
+        
+        update_tk(self.tk)
+        self.IP.runcode()
+        time.sleep(0.01)
+        return True
+
+
+class IPShellWX(IPThread):
+    """Run a wx mainloop() in a separate thread.
+    
+    Python commands can be passed to the thread where they will be executed.
+    This is implemented by periodically checking for passed code using a
+    GTK timeout callback."""
+    
+    TIMEOUT = 100 # Millisecond interval between timeouts.
+
+    def __init__(self,argv=None,user_ns=None,user_global_ns=None,
+                 debug=1,shell_class=MTInteractiveShell):
+
+        self.IP = make_IPython(argv,user_ns=user_ns,
+                               user_global_ns=user_global_ns,
+                               debug=debug,
+                               shell_class=shell_class,
+                               on_kill=[self.wxexit])
+
+        wantedwxversion=self.IP.rc.wxversion
+        if wantedwxversion!="0":
+            try:
+                import wxversion
+            except ImportError:
+                error('The wxversion module is needed for WX version selection')
+            else:
+                try:
+                    wxversion.select(wantedwxversion)
+                except:
+                    self.IP.InteractiveTB()
+                    error('Requested wxPython version %s could not be loaded' %
+                                                               wantedwxversion)
+
+        import wx
+
+        threading.Thread.__init__(self)
+        self.wx = wx
+        self.wx_mainloop = hijack_wx()
+
+        # Allows us to use both Tk and GTK.
+        self.tk = get_tk()
+        
+        # HACK: slot for banner in self; it will be passed to the mainloop
+        # method only and .run() needs it.  The actual value will be set by
+        # .mainloop().
+        self._banner = None 
+
+        self.app = None
+
+    def wxexit(self, *args):
+        if self.app is not None:
+            self.app.agent.timer.Stop()
+            self.app.ExitMainLoop()
+
+    def mainloop(self,sys_exit=0,banner=None):
+
+        self._banner = banner
+        
+        self.start()
+
+        class TimerAgent(self.wx.MiniFrame):
+            wx = self.wx
+            IP = self.IP
+            tk = self.tk
+            def __init__(self, parent, interval):
+                style = self.wx.DEFAULT_FRAME_STYLE | self.wx.TINY_CAPTION_HORIZ
+                self.wx.MiniFrame.__init__(self, parent, -1, ' ', pos=(200, 200),
+                                             size=(100, 100),style=style)
+                self.Show(False)
+                self.interval = interval
+                self.timerId = self.wx.NewId()                                
+
+            def StartWork(self):
+                self.timer = self.wx.Timer(self, self.timerId)
+                self.wx.EVT_TIMER(self,  self.timerId, self.OnTimer)
+                self.timer.Start(self.interval)
+
+            def OnTimer(self, event):
+                update_tk(self.tk)
+                self.IP.runcode()
+
+        class App(self.wx.App):
+            wx = self.wx
+            TIMEOUT = self.TIMEOUT
+            def OnInit(self):
+                'Create the main window and insert the custom frame'
+                self.agent = TimerAgent(None, self.TIMEOUT)
+                self.agent.Show(False)
+                self.agent.StartWork()
+                return True
+
+        self.app = App(redirect=False)
+        self.wx_mainloop(self.app)
+        self.join()
+
+
+class IPShellQt(IPThread):
+    """Run a Qt event loop in a separate thread.
+    
+    Python commands can be passed to the thread where they will be executed.
+    This is implemented by periodically checking for passed code using a
+    Qt timer / slot."""
+    
+    TIMEOUT = 100 # Millisecond interval between timeouts.
+
+    def __init__(self, argv=None, user_ns=None, user_global_ns=None,
+                 debug=0, shell_class=MTInteractiveShell):
+
+        import qt
+
+        self.exec_loop = hijack_qt()
+
+        # Allows us to use both Tk and QT.
+        self.tk = get_tk()
+
+        self.IP = make_IPython(argv,
+                               user_ns=user_ns,
+                               user_global_ns=user_global_ns,
+                               debug=debug,
+                               shell_class=shell_class,
+                               on_kill=[qt.qApp.exit])
+
+        # HACK: slot for banner in self; it will be passed to the mainloop
+        # method only and .run() needs it.  The actual value will be set by
+        # .mainloop().
+        self._banner = None 
+        
+        threading.Thread.__init__(self)
+
+    def mainloop(self, sys_exit=0, banner=None):
+
+        import qt
+
+        self._banner = banner
+
+        if qt.QApplication.startingUp():
+            a = qt.QApplication(sys.argv)
+
+        self.timer = qt.QTimer()
+        qt.QObject.connect(self.timer,
+                           qt.SIGNAL('timeout()'),
+                           self.on_timer)
+
+        self.start()
+        self.timer.start(self.TIMEOUT, True)
+        while True:
+            if self.IP._kill: break
+            self.exec_loop()
+        self.join()
+
+    def on_timer(self):
+        update_tk(self.tk)
+        result = self.IP.runcode()
+        self.timer.start(self.TIMEOUT, True)
+        return result
+
+
+class IPShellQt4(IPThread):
+    """Run a Qt event loop in a separate thread.
+
+    Python commands can be passed to the thread where they will be executed.
+    This is implemented by periodically checking for passed code using a
+    Qt timer / slot."""
+
+    TIMEOUT = 100 # Millisecond interval between timeouts.
+
+    def __init__(self, argv=None, user_ns=None, user_global_ns=None,
+                 debug=0, shell_class=MTInteractiveShell):
+
+        from PyQt4 import QtCore, QtGui
+
+        try:
+            # present in PyQt4-4.2.1 or later
+            QtCore.pyqtRemoveInputHook()
+        except AttributeError:
+            pass
+
+        if QtCore.PYQT_VERSION_STR == '4.3':
+            warn('''PyQt4 version 4.3 detected.
+If you experience repeated threading warnings, please update PyQt4.
+''')
+
+        self.exec_ = hijack_qt4()
+
+        # Allows us to use both Tk and QT.
+        self.tk = get_tk()
+
+        self.IP = make_IPython(argv,
+                               user_ns=user_ns,
+                               user_global_ns=user_global_ns,
+                               debug=debug,
+                               shell_class=shell_class,
+                               on_kill=[QtGui.qApp.exit])
+
+        # HACK: slot for banner in self; it will be passed to the mainloop
+        # method only and .run() needs it.  The actual value will be set by
+        # .mainloop().
+        self._banner = None
+
+        threading.Thread.__init__(self)
+
+    def mainloop(self, sys_exit=0, banner=None):
+
+        from PyQt4 import QtCore, QtGui
+
+        self._banner = banner
+
+        if QtGui.QApplication.startingUp():
+            a = QtGui.QApplication(sys.argv)
+
+        self.timer = QtCore.QTimer()
+        QtCore.QObject.connect(self.timer,
+                               QtCore.SIGNAL('timeout()'),
+                               self.on_timer)
+
+        self.start()
+        self.timer.start(self.TIMEOUT)
+        while True:
+            if self.IP._kill: break
+            self.exec_()
+        self.join()
+
+    def on_timer(self):
+        update_tk(self.tk)
+        result = self.IP.runcode()
+        self.timer.start(self.TIMEOUT)
+        return result
+
+
+# A set of matplotlib public IPython shell classes, for single-threaded (Tk*
+# and FLTK*) and multithreaded (GTK*, WX* and Qt*) backends to use.
+def _load_pylab(user_ns):
+    """Allow users to disable pulling all of pylab into the top-level
+    namespace.
+
+    This little utility must be called AFTER the actual ipython instance is
+    running, since only then will the options file have been fully parsed."""
+    
+    ip = IPython.ipapi.get()
+    if ip.options.pylab_import_all:
+        exec "from matplotlib.pylab import *" in user_ns
+
+class IPShellMatplotlib(IPShell):
+    """Subclass IPShell with MatplotlibShell as the internal shell.
+
+    Single-threaded class, meant for the Tk* and FLTK* backends.
+
+    Having this on a separate class simplifies the external driver code."""
+    
+    def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
+        IPShell.__init__(self,argv,user_ns,user_global_ns,debug,
+                         shell_class=MatplotlibShell)
+        _load_pylab(self.IP.user_ns)
+
+class IPShellMatplotlibGTK(IPShellGTK):
+    """Subclass IPShellGTK with MatplotlibMTShell as the internal shell.
+
+    Multi-threaded class, meant for the GTK* backends."""
+    
+    def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
+        IPShellGTK.__init__(self,argv,user_ns,user_global_ns,debug,
+                            shell_class=MatplotlibMTShell)
+        _load_pylab(self.IP.user_ns)
+
+class IPShellMatplotlibWX(IPShellWX):
+    """Subclass IPShellWX with MatplotlibMTShell as the internal shell.
+
+    Multi-threaded class, meant for the WX* backends."""
+    
+    def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
+        IPShellWX.__init__(self,argv,user_ns,user_global_ns,debug,
+                           shell_class=MatplotlibMTShell)
+        _load_pylab(self.IP.user_ns)
+
+class IPShellMatplotlibQt(IPShellQt):
+    """Subclass IPShellQt with MatplotlibMTShell as the internal shell.
+
+    Multi-threaded class, meant for the Qt* backends."""
+    
+    def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
+        IPShellQt.__init__(self,argv,user_ns,user_global_ns,debug,
+                           shell_class=MatplotlibMTShell)
+        _load_pylab(self.IP.user_ns)
+
+class IPShellMatplotlibQt4(IPShellQt4):
+    """Subclass IPShellQt4 with MatplotlibMTShell as the internal shell.
+
+    Multi-threaded class, meant for the Qt4* backends."""
+
+    def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
+        IPShellQt4.__init__(self,argv,user_ns,user_global_ns,debug,
+                           shell_class=MatplotlibMTShell)
+        _load_pylab(self.IP.user_ns)
+
+#-----------------------------------------------------------------------------
+# Factory functions to actually start the proper thread-aware shell
+
+def _select_shell(argv):
+    """Select a shell from the given argv vector.
+
+    This function implements the threading selection policy, allowing runtime
+    control of the threading mode, both for general users and for matplotlib.
+
+    Return:
+      Shell class to be instantiated for runtime operation.
+    """
+    
+    global USE_TK
+
+    mpl_shell = {'gthread' : IPShellMatplotlibGTK,
+                 'wthread' : IPShellMatplotlibWX,
+                 'qthread' : IPShellMatplotlibQt,
+                 'q4thread' : IPShellMatplotlibQt4,
+                 'tkthread' : IPShellMatplotlib,  # Tk is built-in
+                 }
+
+    th_shell = {'gthread' : IPShellGTK,
+                'wthread' : IPShellWX,
+                'qthread' : IPShellQt,
+                'q4thread' : IPShellQt4,
+                'tkthread' : IPShell, # Tk is built-in
+                }
+
+    backends = {'gthread' : 'GTKAgg',
+                'wthread' : 'WXAgg',
+                'qthread' : 'QtAgg',
+                'q4thread' :'Qt4Agg',
+                'tkthread' :'TkAgg',
+                }
+
+    all_opts = set(['tk','pylab','gthread','qthread','q4thread','wthread',
+                    'tkthread'])
+    user_opts = set([s.replace('-','') for s in argv[:3]])
+    special_opts = user_opts & all_opts
+
+    if 'tk' in special_opts:
+        USE_TK = True
+        special_opts.remove('tk')
+
+    if 'pylab' in special_opts:
+
+        try:
+            import matplotlib
+        except ImportError:
+            error('matplotlib could NOT be imported!  Starting normal IPython.')
+            return IPShell
+        
+        special_opts.remove('pylab')
+        # If there's any option left, it means the user wants to force the
+        # threading backend, else it's auto-selected from the rc file
+        if special_opts:
+            th_mode = special_opts.pop()
+            matplotlib.rcParams['backend'] = backends[th_mode]
+        else:
+            backend = matplotlib.rcParams['backend']
+            if backend.startswith('GTK'):
+                th_mode = 'gthread'
+            elif backend.startswith('WX'):
+                th_mode = 'wthread'
+            elif backend.startswith('Qt4'):
+                th_mode = 'q4thread'
+            elif backend.startswith('Qt'):
+                th_mode = 'qthread'
+            else:
+                # Any other backend, use plain Tk
+                th_mode = 'tkthread'
+                
+        return mpl_shell[th_mode]
+    else:
+        # No pylab requested, just plain threads
+        try:
+            th_mode = special_opts.pop()
+        except KeyError:
+            th_mode = 'tkthread'
+        return th_shell[th_mode]
+
+
+# This is the one which should be called by external code.
+def start(user_ns = None):
+    """Return a running shell instance, dealing with threading options.
+
+    This is a factory function which will instantiate the proper IPython shell
+    based on the user's threading choice.  Such a selector is needed because
+    different GUI toolkits require different thread handling details."""
+
+    shell = _select_shell(sys.argv)
+    return shell(user_ns = user_ns)
+
+# Some aliases for backwards compatibility
+IPythonShell = IPShell
+IPythonShellEmbed = IPShellEmbed
+#************************ End of file <Shell.py> ***************************
diff --git a/IPython/UserConfig/ipy_user_conf.py b/IPython/UserConfig/ipy_user_conf.py
new file mode 100644
index 0000000..33d158b
--- /dev/null
+++ b/IPython/UserConfig/ipy_user_conf.py
@@ -0,0 +1,86 @@
+""" User configuration file for IPython
+
+This is a more flexible and safe way to configure ipython than *rc files
+(ipythonrc, ipythonrc-pysh etc.)
+
+This file is always imported on ipython startup. You can import the
+ipython extensions you need here (see IPython/Extensions directory).
+
+Feel free to edit this file to customize your ipython experience.
+
+Note that as such this file does nothing, for backwards compatibility.
+Consult e.g. file 'ipy_profile_sh.py' for an example of the things 
+you can do here.
+
+See http://ipython.scipy.org/moin/IpythonExtensionApi for detailed
+description on what you could do here.
+"""
+
+# Most of your config files and extensions will probably start with this import
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+# You probably want to uncomment this if you did %upgrade -nolegacy
+# import ipy_defaults    
+
+import os   
+
+def main():   
+
+    # uncomment if you want to get ipython -p sh behaviour
+    # without having to use command line switches  
+    # import ipy_profile_sh
+
+    # Configure your favourite editor?
+    # Good idea e.g. for %edit os.path.isfile
+
+    #import ipy_editors
+    
+    # Choose one of these:
+    
+    #ipy_editors.scite()
+    #ipy_editors.scite('c:/opt/scite/scite.exe')
+    #ipy_editors.komodo()
+    #ipy_editors.idle()
+    # ... or many others, try 'ipy_editors??' after import to see them
+    
+    # Or roll your own:
+    #ipy_editors.install_editor("c:/opt/jed +$line $file")
+    
+    
+    o = ip.options
+    # An example on how to set options
+    #o.autocall = 1
+    o.system_verbose = 0
+    
+    #import_all("os sys")
+    #execf('~/_ipython/ns.py')
+
+
+    # -- prompt
+    # A different, more compact set of prompts from the default ones, that
+    # always show your current location in the filesystem:
+
+    #o.prompt_in1 = r'\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Normal\n\C_Green|\#>'
+    #o.prompt_in2 = r'.\D: '
+    #o.prompt_out = r'[\#] '
+    
+    # Try one of these color settings if you can't read the text easily
+    # autoexec is a list of IPython commands to execute on startup
+    #o.autoexec.append('%colors LightBG')
+    #o.autoexec.append('%colors NoColor')
+    #o.autoexec.append('%colors Linux')
+    
+    
+# some config helper functions you can use 
+def import_all(modules):
+    """ Usage: import_all("os sys") """ 
+    for m in modules.split():
+        ip.ex("from %s import *" % m)
+        
+def execf(fname):
+    """ Execute a file in user namespace """
+    ip.ex('execfile("%s")' % os.path.expanduser(fname))
+
+main()
diff --git a/IPython/UserConfig/ipythonrc b/IPython/UserConfig/ipythonrc
new file mode 100644
index 0000000..1dcc441
--- /dev/null
+++ b/IPython/UserConfig/ipythonrc
@@ -0,0 +1,632 @@
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+# $Id: ipythonrc 2156 2007-03-19 02:32:19Z fperez $
+
+#***************************************************************************
+#
+# Configuration file for IPython -- ipythonrc format
+#
+# ===========================================================
+# Deprecation note: you should look into modifying ipy_user_conf.py (located 
+# in ~/.ipython or ~/_ipython, depending on your platform) instead, it's a 
+# more flexible and robust (and better supported!) configuration
+# method.
+# ===========================================================
+#
+# The format of this file is simply one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+
+# The meaning and use of each key are explained below.
+
+#---------------------------------------------------------------------------
+# Section: included files
+
+# Put one or more *config* files (with the syntax of this file) you want to
+# include. For keys with a unique value the outermost file has precedence. For
+# keys with multiple values, they all get assembled into a list which then
+# gets loaded by IPython.
+
+# In this file, all lists of things should simply be space-separated.
+
+# This allows you to build hierarchies of files which recursively load
+# lower-level services. If this is your main ~/.ipython/ipythonrc file, you
+# should only keep here basic things you always want available. Then you can
+# include it in every other special-purpose config file you create.
+include 
+
+#---------------------------------------------------------------------------
+# Section: startup setup
+
+# These are mostly things which parallel a command line option of the same
+# name.
+
+# Keys in this section should only appear once. If any key from this section
+# is encountered more than once, the last value remains, all earlier ones get
+# discarded.
+
+
+# Automatic calling of callable objects.  If set to 1 or 2, callable objects
+# are automatically called when invoked at the command line, even if you don't
+# type parentheses.  IPython adds the parentheses for you.  For example:
+
+#In [1]: str 45
+#------> str(45)
+#Out[1]: '45'
+
+# IPython reprints your line with '---->' indicating that it added
+# parentheses.  While this option is very convenient for interactive use, it
+# may occasionally cause problems with objects which have side-effects if
+# called unexpectedly.
+
+# The valid values for autocall are:
+
+# autocall 0 -> disabled (you can toggle it at runtime with the %autocall magic)
+
+# autocall 1 -> active, but do not apply if there are no arguments on the line.
+
+# In this mode, you get:
+
+#In [1]: callable
+#Out[1]: <built-in function callable>
+
+#In [2]: callable 'hello'
+#------> callable('hello')
+#Out[2]: False
+
+# 2 -> Active always.  Even if no arguments are present, the callable object
+# is called:
+
+#In [4]: callable
+#------> callable()
+
+# Note that even with autocall off, you can still use '/' at the start of a
+# line to treat the first argument on the command line as a function and add
+# parentheses to it:
+
+#In [8]: /str 43
+#------> str(43)
+#Out[8]: '43'
+
+autocall 1
+
+# Auto-edit syntax errors.  When you use the %edit magic in ipython to edit
+# source code (see the 'editor' variable below), it is possible that you save
+# a file with syntax errors in it.  If this variable is true, IPython will ask
+# you whether to re-open the editor immediately to correct such an error.
+
+autoedit_syntax 0
+
+# Auto-indent. IPython can recognize lines ending in ':' and indent the next
+# line, while also un-indenting automatically after 'raise' or 'return'.  
+
+# This feature uses the readline library, so it will honor your ~/.inputrc
+# configuration (or whatever file your INPUTRC variable points to).  Adding
+# the following lines to your .inputrc file can make indent/unindenting more
+# convenient (M-i indents, M-u unindents):
+
+#  $if Python
+#  "\M-i": "    "
+#  "\M-u": "\d\d\d\d"
+#  $endif
+
+# The feature is potentially a bit dangerous, because it can cause problems
+# with pasting of indented code (the pasted code gets re-indented on each
+# line).  But it's a huge time-saver when working interactively.  The magic
+# function %autoindent allows you to toggle it on/off at runtime.
+
+autoindent 1
+
+# Auto-magic. This gives you access to all the magic functions without having
+# to prepend them with an % sign. If you define a variable with the same name
+# as a magic function (say who=1), you will need to access the magic function
+# with % (%who in this example). However, if later you delete your variable
+# (del who), you'll recover the automagic calling form.
+
+# Considering that many magic functions provide a lot of shell-like
+# functionality, automagic gives you something close to a full Python+system
+# shell environment (and you can extend it further if you want).
+
+automagic 1
+
+# Size of the output cache. After this many entries are stored, the cache will
+# get flushed. Depending on the size of your intermediate calculations, you
+# may have memory problems if you make it too big, since keeping things in the
+# cache prevents Python from reclaiming the memory for old results. Experiment
+# with a value that works well for you.
+
+# If you choose cache_size 0 IPython will revert to python's regular >>>
+# unnumbered prompt. You will still have _, __ and ___ for your last three
+# results, but that will be it.  No dynamic _1, _2, etc. will be created. If
+# you are running on a slow machine or with very limited memory, this may
+# help.
+
+cache_size 1000
+
+# Classic mode: Setting 'classic 1' you lose many of IPython niceties,
+# but that's your choice! Classic 1 -> same as IPython -classic.
+# Note that this is _not_ the normal python interpreter, it's simply
+# IPython emulating most of the classic interpreter's behavior.
+classic 0
+
+# colors - Coloring option for prompts and traceback printouts.
+
+# Currently available schemes: NoColor, Linux, LightBG.
+
+# This option allows coloring the prompts and traceback printouts. This
+# requires a terminal which can properly handle color escape sequences. If you
+# are having problems with this, use the NoColor scheme (uses no color escapes
+# at all).
+
+# The Linux option works well in linux console type environments: dark
+# background with light fonts.
+
+# LightBG is similar to Linux but swaps dark/light colors to be more readable
+# in light background terminals.
+
+# keep uncommented only the one you want:
+colors Linux
+#colors LightBG
+#colors NoColor
+
+########################
+# Note to Windows users
+#
+# Color and readline support is avaialble to Windows users via Gary Bishop's
+# readline library.  You can find Gary's tools at
+# http://sourceforge.net/projects/uncpythontools.
+# Note that his readline module requires in turn the ctypes library, available
+# at http://starship.python.net/crew/theller/ctypes.
+########################
+
+# color_info: IPython can display information about objects via a set of
+# functions, and optionally can use colors for this, syntax highlighting
+# source code and various other elements. This information is passed through a
+# pager (it defaults to 'less' if $PAGER is not set). 
+
+# If your pager has problems, try to setting it to properly handle escapes
+# (see the less manpage for detail), or disable this option.  The magic
+# function %color_info allows you to toggle this interactively for testing.
+
+color_info 1
+
+# confirm_exit: set to 1 if you want IPython to confirm when you try to exit
+# with an EOF (Control-d in Unix, Control-Z/Enter in Windows). Note that using
+# the magic functions %Exit or %Quit you can force a direct exit, bypassing
+# any confirmation.
+
+confirm_exit 1
+
+# Use deep_reload() as a substitute for reload() by default. deep_reload() is
+# still available as dreload() and appears as a builtin.
+
+deep_reload 0
+
+# Which editor to use with the %edit command. If you leave this at 0, IPython
+# will honor your EDITOR environment variable. Since this editor is invoked on
+# the fly by ipython and is meant for editing small code snippets, you may
+# want to use a small, lightweight editor here.
+
+# For Emacs users, setting up your Emacs server properly as described in the
+# manual is a good idea. An alternative is to use jed, a very light editor
+# with much of the feel of Emacs (though not as powerful for heavy-duty work).
+
+editor 0
+
+# log 1 -> same as ipython -log. This automatically logs to ./ipython.log
+log 0
+
+# Same as ipython -Logfile YourLogfileName. 
+# Don't use with log 1 (use one or the other)
+logfile ''
+
+# banner 0 -> same as ipython -nobanner
+banner 1
+
+# messages 0 -> same as ipython -nomessages
+messages 1
+
+# Automatically call the pdb debugger after every uncaught exception. If you
+# are used to debugging using pdb, this puts you automatically inside of it
+# after any call (either in IPython or in code called by it) which triggers an
+# exception which goes uncaught.
+pdb 0
+
+# Enable the pprint module for printing. pprint tends to give a more readable
+# display (than print) for complex nested data structures.
+pprint 1
+
+# Prompt strings
+
+# Most bash-like escapes can be used to customize IPython's prompts, as well as
+# a few additional ones which are IPython-specific.  All valid prompt escapes
+# are described in detail in the Customization section of the IPython HTML/PDF
+# manual.
+
+# Use \# to represent the current prompt number, and quote them to protect
+# spaces.
+prompt_in1 'In [\#]: '
+
+# \D is replaced by as many dots as there are digits in the
+# current value of \#.
+prompt_in2 '   .\D.: '
+
+prompt_out 'Out[\#]: '
+
+# Select whether to left-pad the output prompts to match the length of the
+# input ones.  This allows you for example to use a simple '>' as an output
+# prompt, and yet have the output line up with the input.  If set to false,
+# the output prompts will be unpadded (flush left).
+prompts_pad_left 1
+
+# Pylab support: when ipython is started with the -pylab switch, by default it
+# executes 'from matplotlib.pylab import *'.  Set this variable to false if you
+# want to disable this behavior.
+
+# For details on pylab, see the matplotlib website:
+# http://matplotlib.sf.net
+pylab_import_all 1
+
+
+# quick 1 -> same as ipython -quick
+quick 0
+
+# Use the readline library (1) or not (0). Most users will want this on, but
+# if you experience strange problems with line management (mainly when using
+# IPython inside Emacs buffers) you may try disabling it. Not having it on
+# prevents you from getting command history with the arrow keys, searching and
+# name completion using TAB.
+
+readline 1
+
+# Screen Length: number of lines of your screen. This is used to control
+# printing of very long strings. Strings longer than this number of lines will
+# be paged with the less command instead of directly printed.
+
+# The default value for this is 0, which means IPython will auto-detect your
+# screen size every time it needs to print. If for some reason this isn't
+# working well (it needs curses support), specify it yourself. Otherwise don't
+# change the default.
+
+screen_length 0
+
+# Prompt separators for input and output.
+# Use \n for newline explicitly, without quotes.
+# Use 0 (like at the cmd line) to turn off a given separator.
+
+# The structure of prompt printing is:
+# (SeparateIn)Input....
+# (SeparateOut)Output...
+# (SeparateOut2),   # that is, no newline is printed after Out2
+# By choosing these you can organize your output any way you want.
+
+separate_in \n
+separate_out 0
+separate_out2 0
+
+# 'nosep 1' is a shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 0'.
+# Simply removes all input/output separators, overriding the choices above.
+nosep 0
+
+# Wildcard searches - IPython has a system for searching names using
+# shell-like wildcards; type %psearch? for details.  This variables sets
+# whether by default such searches should be case sensitive or not.  You can
+# always override the default at the system command line or the IPython
+# prompt.
+
+wildcards_case_sensitive 1
+
+# Object information: at what level of detail to display the string form of an
+# object.  If set to 0, ipython will compute the string form of any object X,
+# by calling str(X), when X? is typed.  If set to 1, str(X) will only be
+# computed when X?? is given, and if set to 2 or higher, it will never be
+# computed (there is no X??? level of detail).  This is mostly of use to
+# people who frequently manipulate objects whose string representation is
+# extremely expensive to compute.
+
+object_info_string_level 0
+
+# xmode - Exception reporting mode. 
+
+# Valid modes: Plain, Context and Verbose.
+
+# Plain: similar to python's normal traceback printing.
+
+# Context: prints 5 lines of context source code around each line in the
+# traceback.
+
+# Verbose: similar to Context, but additionally 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).
+
+#xmode Plain
+xmode Context
+#xmode Verbose
+
+# multi_line_specials: if true, allow magics, aliases and shell escapes (via
+# !cmd) to be used in multi-line input (like for loops).  For example, if you
+# have this active, the following is valid in IPython:
+#
+#In [17]: for i in range(3):
+#   ....:     mkdir $i
+#   ....:     !touch $i/hello
+#   ....:     ls -l $i
+
+multi_line_specials 1
+
+
+# System calls: When IPython makes system calls (e.g. via special syntax like
+# !cmd or !!cmd, or magics like %sc or %sx), it can print the command it is
+# executing to standard output, prefixed by a header string.
+
+system_header "IPython system call: "
+
+system_verbose 1
+
+# wxversion: request a specific wxPython version (used for -wthread)
+
+# Set this to the value of wxPython you want to use, but note that this
+# feature requires you to have the wxversion Python module to work.  If you
+# don't have the wxversion module (try 'import wxversion' at the prompt to
+# check) or simply want to leave the system to pick up the default, leave this
+# variable at 0.
+
+wxversion 0
+
+#---------------------------------------------------------------------------
+# Section: Readline configuration (readline is not available for MS-Windows)
+
+# This is done via the following options:
+
+# (i) readline_parse_and_bind: this option can appear as many times as you
+# want, each time defining a string to be executed via a
+# readline.parse_and_bind() command. The syntax for valid commands of this
+# kind can be found by reading the documentation for the GNU readline library,
+# as these commands are of the kind which readline accepts in its
+# configuration file.
+
+# The TAB key can be used to complete names at the command line in one of two
+# ways: 'complete' and 'menu-complete'. The difference is that 'complete' only
+# completes as much as possible while 'menu-complete' cycles through all
+# possible completions. Leave the one you prefer uncommented.
+
+readline_parse_and_bind tab: complete
+#readline_parse_and_bind tab: menu-complete
+
+# This binds Control-l to printing the list of all possible completions when
+# there is more than one (what 'complete' does when hitting TAB twice, or at
+# the first TAB if show-all-if-ambiguous is on)
+readline_parse_and_bind "\C-l": possible-completions
+
+# This forces readline to automatically print the above list when tab
+# completion is set to 'complete'. You can still get this list manually by
+# using the key bound to 'possible-completions' (Control-l by default) or by
+# hitting TAB twice. Turning this on makes the printing happen at the first
+# TAB.
+readline_parse_and_bind set show-all-if-ambiguous on
+
+# If you have TAB set to complete names, you can rebind any key (Control-o by
+# default) to insert a true TAB character.
+readline_parse_and_bind "\C-o": tab-insert
+
+# These commands allow you to indent/unindent easily, with the 4-space
+# convention of the Python coding standards.  Since IPython's internal
+# auto-indent system also uses 4 spaces, you should not change the number of
+# spaces in the code below.
+readline_parse_and_bind "\M-i": "    "
+readline_parse_and_bind "\M-o": "\d\d\d\d"
+readline_parse_and_bind "\M-I": "\d\d\d\d"
+
+# Bindings for incremental searches in the history. These searches use the
+# string typed so far on the command line and search anything in the previous
+# input history containing them.
+readline_parse_and_bind "\C-r": reverse-search-history
+readline_parse_and_bind "\C-s": forward-search-history
+
+# Bindings for completing the current line in the history of previous
+# commands. This allows you to recall any previous command by typing its first
+# few letters and hitting Control-p, bypassing all intermediate commands which
+# may be in the history (much faster than hitting up-arrow 50 times!)
+readline_parse_and_bind "\C-p": history-search-backward
+readline_parse_and_bind "\C-n": history-search-forward
+
+# I also like to have the same functionality on the plain arrow keys. If you'd
+# rather have the arrows use all the history (and not just match what you've
+# typed so far), comment out or delete the next two lines.
+readline_parse_and_bind "\e[A": history-search-backward
+readline_parse_and_bind "\e[B": history-search-forward
+
+# These are typically on by default under *nix, but not win32.
+readline_parse_and_bind "\C-k": kill-line
+readline_parse_and_bind "\C-u": unix-line-discard
+
+# (ii) readline_remove_delims: a string of characters to be removed from the
+# default word-delimiters list used by readline, so that completions may be
+# performed on strings which contain them.
+
+readline_remove_delims -/~
+
+# (iii) readline_merge_completions: whether to merge the result of all
+# possible completions or not.  If true, IPython will complete filenames,
+# python names and aliases and return all possible completions.  If you set it
+# to false, each completer is used at a time, and only if it doesn't return
+# any completions is the next one used.
+
+# The default order is: [python_matches, file_matches, alias_matches]
+
+readline_merge_completions 1
+
+# (iv) readline_omit__names: normally hitting <tab> after a '.' in a name
+# will complete all attributes of an object, including all the special methods
+# whose names start with single or double underscores (like __getitem__ or
+# __class__).
+
+# This variable allows you to control this completion behavior:
+
+# readline_omit__names 1 -> completion will omit showing any names starting
+# with two __, but it will still show names starting with one _.
+
+# readline_omit__names 2 -> completion will omit all names beginning with one
+# _ (which obviously means filtering out the double __ ones).
+
+# Even when this option is set, you can still see those names by explicitly
+# typing a _ after the period and hitting <tab>: 'name._<tab>' will always
+# complete attribute names starting with '_'.
+
+# This option is off by default so that new users see all attributes of any
+# objects they are dealing with.
+
+readline_omit__names 0
+
+#---------------------------------------------------------------------------
+# Section: modules to be loaded with 'import ...'
+
+# List, separated by spaces, the names of the modules you want to import
+
+# Example:
+# import_mod sys os
+# will produce internally the statements
+# import sys
+# import os
+
+# Each import is executed in its own try/except block, so if one module
+# fails to load the others will still be ok.
+
+import_mod 
+
+#---------------------------------------------------------------------------
+# Section: modules to import some functions from: 'from ... import ...'
+
+# List, one per line, the modules for which you want only to import some
+# functions. Give the module name first and then the name of functions to be
+# imported from that module.
+
+# Example:
+
+# import_some IPython.genutils timing timings
+# will produce internally the statement
+# from IPython.genutils import timing, timings
+
+# timing() and timings() are two IPython utilities for timing the execution of
+# your own functions, which you may find useful.  Just commment out the above
+# line if you want to test them.
+
+# If you have more than one modules_some line, each gets its own try/except
+# block (like modules, see above).
+
+import_some 
+
+#---------------------------------------------------------------------------
+# Section: modules to import all from : 'from ... import *'
+
+# List (same syntax as import_mod above) those modules for which you want to
+# import all functions. Remember, this is a potentially dangerous thing to do,
+# since it is very easy to overwrite names of things you need. Use with
+# caution.
+
+# Example:
+# import_all sys os
+# will produce internally the statements
+# from sys import *
+# from os import *
+
+# As before, each will be called in a separate try/except block.
+
+import_all 
+
+#---------------------------------------------------------------------------
+# Section: Python code to execute.
+
+# Put here code to be explicitly executed (keep it simple!)
+# Put one line of python code per line. All whitespace is removed (this is a
+# feature, not a bug), so don't get fancy building loops here.
+# This is just for quick convenient creation of things you want available.
+
+# Example:
+# execute x = 1
+# execute print 'hello world'; y = z = 'a'
+# will produce internally
+# x = 1
+# print 'hello world'; y = z = 'a'
+# and each *line* (not each statement, we don't do python syntax parsing) is
+# executed in its own try/except block.
+
+execute 
+
+# Note for the adventurous: you can use this to define your own names for the
+# magic functions, by playing some namespace tricks:
+
+# execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
+
+# defines %pf as a new name for %profile.
+
+#---------------------------------------------------------------------------
+# Section: Pyhton files to load and execute.
+
+# Put here the full names of files you want executed with execfile(file).  If
+# you want complicated initialization, just write whatever you want in a
+# regular python file and load it from here.
+
+# Filenames defined here (which *must* include the extension) are searched for
+# through all of sys.path. Since IPython adds your .ipython directory to
+# sys.path, they can also be placed in your .ipython dir and will be
+# found. Otherwise (if you want to execute things not in .ipyton nor in
+# sys.path) give a full path (you can use ~, it gets expanded)
+
+# Example:
+# execfile file1.py ~/file2.py
+# will generate
+# execfile('file1.py')
+# execfile('_path_to_your_home/file2.py')
+
+# As before, each file gets its own try/except block.
+
+execfile
+
+# If you are feeling adventurous, you can even add functionality to IPython
+# through here. IPython works through a global variable called __ip which
+# exists at the time when these files are read. If you know what you are doing
+# (read the source) you can add functions to __ip in files loaded here. 
+
+# The file example-magic.py contains a simple but correct example. Try it:
+
+# execfile example-magic.py
+
+# Look at the examples in IPython/iplib.py for more details on how these magic
+# functions need to process their arguments.
+
+#---------------------------------------------------------------------------
+# Section: aliases for system shell commands
+
+# Here you can define your own names for system commands. The syntax is
+# similar to that of the builtin %alias function:
+
+# alias alias_name command_string
+
+# The resulting aliases are auto-generated magic functions (hence usable as
+# %alias_name)
+
+# For example:
+
+# alias myls ls -la
+
+# will define 'myls' as an alias for executing the system command 'ls -la'.
+# This allows you to customize IPython's environment to have the same aliases
+# you are accustomed to from your own shell.
+
+# You can also define aliases with parameters using %s specifiers (one per
+# parameter):
+
+# alias parts echo first %s second %s
+
+# will give you in IPython:
+# >>> %parts A B
+# first A second B
+
+# Use one 'alias' statement per alias you wish to define.
+
+# alias 
+
+#************************* end of file <ipythonrc> ************************
diff --git a/IPython/UserConfig/ipythonrc-math b/IPython/UserConfig/ipythonrc-math
new file mode 100644
index 0000000..d68f177
--- /dev/null
+++ b/IPython/UserConfig/ipythonrc-math
@@ -0,0 +1,36 @@
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+#
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# This is an example of a 'profile' file which includes a base file and adds
+# some customizaton for a particular purpose.
+
+# If this file is found in the user's ~/.ipython directory as ipythonrc-math,
+# it can be loaded by calling passing the '-profile math' (or '-p math')
+# option to IPython.
+
+# This example is a light customization to have ipython have basic math functions
+# readily available, effectively making the python prompt a very capable scientific
+# calculator
+
+# include base config and only add some extras
+include ipythonrc
+
+# load the complex math functions but keep them in a separate namespace
+import_mod cmath
+
+# from ... import *
+# load the real math functions in the global namespace for convenience
+import_all math
+
+# from ... import ...
+import_some
+
+# code to execute
+execute print "*** math functions available globally, cmath as a module"
diff --git a/IPython/UserConfig/ipythonrc-numeric b/IPython/UserConfig/ipythonrc-numeric
new file mode 100644
index 0000000..7bfc4dd
--- /dev/null
+++ b/IPython/UserConfig/ipythonrc-numeric
@@ -0,0 +1,57 @@
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+#
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# This is an example of a 'profile' file which includes a base file and adds
+# some customizaton for a particular purpose.
+
+# If this file is found in the user's ~/.ipython directory as
+# ipythonrc-numeric, it can be loaded by calling passing the '-profile
+# numeric' (or '-p numeric') option to IPython.
+
+# A simple alias numpy -> 'ipython -p numeric' makes life very convenient.
+
+# This example is meant to load several modules to turn IPython into a very
+# capable environment for high-end numerical work, similar to IDL or MatLab
+# but with the beauty and flexibility of the Python language.
+
+# Load the user's basic configuration
+include ipythonrc
+
+# import ...
+
+# Load Numeric by itself so that 'help Numeric' works
+import_mod Numeric
+
+# from ... import *
+# GnuplotRuntime loads Gnuplot and adds enhancements for use in IPython
+import_all Numeric IPython.numutils IPython.GnuplotInteractive
+
+# a simple line at zero, often useful for an x-axis
+execute xaxis=gpfunc('0',title='',with='lines lt -1')
+
+# Below are optional things off by default. Uncomment them if desired.
+
+# MA (MaskedArray) modifies the Numeric printing mechanism so that huge arrays
+# are only summarized and not printed (which may freeze the machine for a
+# _long_ time).
+
+#import_mod MA
+
+
+# gracePlot is a Python interface to the plotting package Grace.
+# For more details go to: http://www.idyll.org/~n8gray/code/index.html
+# Uncomment lines below if you have grace and its python support code
+
+#import_mod gracePlot 
+#execute grace = gracePlot.gracePlot  # alias to make gracePlot instances
+#execute print '*** grace is an alias for gracePlot.gracePlot'
+
+# Files to execute
+execfile
diff --git a/IPython/UserConfig/ipythonrc-physics b/IPython/UserConfig/ipythonrc-physics
new file mode 100644
index 0000000..6accb9e
--- /dev/null
+++ b/IPython/UserConfig/ipythonrc-physics
@@ -0,0 +1,43 @@
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+#
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# If this file is found in the user's ~/.ipython directory as
+# ipythonrc-physics, it can be loaded by calling passing the '-profile
+# physics' (or '-p physics') option to IPython.
+
+# This profile loads modules useful for doing interactive calculations with
+# physical quantities (with units). It relies on modules from Konrad Hinsen's
+# ScientificPython (http://dirac.cnrs-orleans.fr/ScientificPython/)
+
+# First load basic user configuration
+include ipythonrc
+
+# import ...
+# Module with alternate input syntax for PhysicalQuantity objects.
+import_mod IPython.Extensions.PhysicalQInput
+
+# from ... import *
+# math CANNOT be imported after PhysicalQInteractive. It will override the
+# functions defined there.
+import_all math IPython.Extensions.PhysicalQInteractive
+
+# from ... import ...
+import_some  
+
+# code
+execute q = PhysicalQuantityInteractive
+execute g = PhysicalQuantityInteractive('9.8 m/s**2')
+ececute rad = pi/180.
+execute print '*** q is an alias for PhysicalQuantityInteractive'
+execute print '*** g = 9.8 m/s^2 has been defined'
+execute print '*** rad = pi/180  has been defined'
+
+# Files to execute
+execfile 
diff --git a/IPython/UserConfig/ipythonrc-pysh b/IPython/UserConfig/ipythonrc-pysh
new file mode 100644
index 0000000..75f4c9b
--- /dev/null
+++ b/IPython/UserConfig/ipythonrc-pysh
@@ -0,0 +1,94 @@
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments.  But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# If this file is found in the user's ~/.ipython directory as ipythonrc-pysh,
+# it can be loaded by calling passing the '-profile pysh' (or '-p pysh')
+# option to IPython.
+
+# This profile turns IPython into a lightweight system shell with python
+# syntax.
+
+# We only set a few options here, the rest is done in the companion pysh.py
+# file.  In the future _all_ of IPython's configuration will be done via
+# proper python code.
+
+############################################################################
+# First load common user configuration
+include ipythonrc
+
+############################################################################
+# Load all the actual syntax extensions for shell-like operation, which live
+# in the InterpreterExec standard extension.
+import_all IPython.Extensions.InterpreterExec
+
+############################################################################
+# PROMPTS
+#
+# Configure prompt for more shell-like usage.
+
+# Most bash-like escapes can be used to customize IPython's prompts, as well as
+# a few additional ones which are IPython-specific.  All valid prompt escapes
+# are described in detail in the Customization section of the IPython HTML/PDF
+# manual.
+
+prompt_in1 '\C_LightGreen\u@\h\C_LightBlue[\C_LightCyan\Y1\C_LightBlue]\C_Green|\#> '
+prompt_in2 '\C_Green|\C_LightGreen\D\C_Green> '
+prompt_out '<\#> '
+
+# Here's a more complex prompt, showing the hostname and more path depth (\Y3)
+#prompt_in1 '\C_LightRed\u\C_Blue@\C_Red\h\C_LightBlue[\C_LightCyan\Y3\C_LightBlue]\C_LightGreen\#> '
+
+# Select whether to left-pad the output prompts to match the length of the
+# input ones.  This allows you for example to use a simple '>' as an output
+# prompt, and yet have the output line up with the input.  If set to false,
+# the output prompts will be unpadded (flush left).
+prompts_pad_left 1
+
+
+# Remove all blank lines in between prompts, like a normal shell.
+separate_in 0
+separate_out 0
+separate_out2 0
+
+# Allow special syntax (!, magics and aliases) in multiline input
+multi_line_specials 1
+
+############################################################################
+# ALIASES
+
+# Declare some common aliases. Type alias? at an ipython prompt for details on
+# the syntax, use @unalias to delete existing aliases.
+
+# Don't go too crazy here, the file pysh.py called below runs @rehash, which
+# loads ALL of your $PATH as aliases (except for Python keywords and
+# builtins).
+
+# Some examples:
+
+# A simple alias without arguments
+#alias cl clear
+
+# An alias which expands the full line before the end of the alias.  This
+# lists only directories:
+#alias ldir pwd;ls -oF --color %l | grep /$
+
+# An alias with two positional arguments:
+#alias parts echo 'First <%s> Second <%s>'
+
+# In use these two aliases give (note that ldir is already built into IPython
+# for Unix):
+
+#fperez[IPython]16> ldir
+#/usr/local/home/fperez/ipython/ipython/IPython
+#drwxr-xr-x  2 fperez  4096 Jun 21 01:01 CVS/
+#drwxr-xr-x  3 fperez  4096 Jun 21 01:10 Extensions/
+#drwxr-xr-x  3 fperez  4096 Jun 21 01:27 UserConfig/
+
+#fperez[IPython]17> parts Hello world and goodbye
+#First <Hello> Second <world> and goodbye
diff --git a/IPython/UserConfig/ipythonrc-tutorial b/IPython/UserConfig/ipythonrc-tutorial
new file mode 100644
index 0000000..012efea
--- /dev/null
+++ b/IPython/UserConfig/ipythonrc-tutorial
@@ -0,0 +1,37 @@
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+#
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# If this file is found in the user's ~/.ipython directory as
+# ipythonrc-tutorial, it can be loaded by calling passing the '-profile
+# tutorial' (or '-p tutorial') option to IPython.
+
+# This profile loads a special input line filter to allow typing lines which
+# begin with '>>> ' or '... '. These two strings, if present at the start of
+# the input line, are stripped. This allows for direct pasting of code from
+# examples such as those available in the standard Python tutorial.
+
+# First load basic user configuration
+include ipythonrc
+
+# import ...
+# Module with alternate input syntax for pasting python input
+import_mod IPython.Extensions.InterpreterPasteInput
+
+# from ... import *
+import_all
+
+# from ... import ...
+import_some  
+
+# code
+execute
+
+# Files to execute
+execfile
diff --git a/IPython/__init__.py b/IPython/__init__.py
new file mode 100644
index 0000000..23d892e
--- /dev/null
+++ b/IPython/__init__.py
@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+"""
+IPython -- An enhanced Interactive Python
+
+One of Python's nicest features is its interactive interpreter. This allows
+very fast testing of ideas without the overhead of creating test files as is
+typical in most programming languages. However, the interpreter supplied with
+the standard Python distribution is fairly primitive (and IDLE isn't really
+much better).
+
+IPython tries to:
+
+  i - provide an efficient environment for interactive work in Python
+  programming. It tries to address what we see as shortcomings of the standard
+  Python prompt, and adds many features to make interactive work much more
+  efficient.
+
+  ii - offer a flexible framework so that it can be used as the base
+  environment for other projects and problems where Python can be the
+  underlying language. Specifically scientific environments like Mathematica,
+  IDL and Mathcad inspired its design, but similar ideas can be useful in many
+  fields. Python is a fabulous language for implementing this kind of system
+  (due to its dynamic and introspective features), and with suitable libraries
+  entire systems could be built leveraging Python's power.
+
+  iii - serve as an embeddable, ready to go interpreter for your own programs.
+
+IPython requires Python 2.3 or newer.
+
+$Id: __init__.py 2399 2007-05-26 10:23:10Z vivainio $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+# Enforce proper version requirements
+import sys
+
+if sys.version[0:3] < '2.3':
+    raise ImportError('Python Version 2.3 or above is required for IPython.')
+
+# Make it easy to import extensions - they are always directly on pythonpath.
+# Therefore, non-IPython modules can be added to Extensions directory
+import os
+sys.path.append(os.path.dirname(__file__) + "/Extensions")
+
+# Define what gets imported with a 'from IPython import *'
+__all__ = ['ipapi','generics','ipstruct','Release','Shell']
+
+# Load __all__ in IPython namespace so that a simple 'import IPython' gives
+# access to them via IPython.<name>
+glob,loc = globals(),locals()
+for name in __all__:
+    __import__(name,glob,loc,[])
+
+import Shell
+
+# Release data
+from IPython import Release # do it explicitly so pydoc can see it - pydoc bug
+__author__   = '%s <%s>\n%s <%s>\n%s <%s>' % \
+               ( Release.authors['Fernando'] + Release.authors['Janko'] + \
+                 Release.authors['Nathan'] )
+__license__  = Release.license
+__version__  = Release.version
+__revision__ = Release.revision
+
+# Namespace cleanup
+del name,glob,loc
diff --git a/IPython/background_jobs.py b/IPython/background_jobs.py
new file mode 100644
index 0000000..ed2db08
--- /dev/null
+++ b/IPython/background_jobs.py
@@ -0,0 +1,496 @@
+# -*- coding: utf-8 -*-
+"""Manage background (threaded) jobs conveniently from an interactive shell.
+
+This module provides a BackgroundJobManager class.  This is the main class
+meant for public usage, it implements an object which can create and manage
+new background jobs.
+
+It also provides the actual job classes managed by these BackgroundJobManager
+objects, see their docstrings below.
+
+
+This system 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).
+
+$Id: background_jobs.py 994 2006-01-08 08:29:44Z fperez $
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2005-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+# Code begins
+import sys
+import threading
+
+from IPython.ultraTB import AutoFormattedTB
+from IPython.genutils import warn,error
+
+class BackgroundJobManager:
+    """Class to manage a pool of backgrounded threaded jobs.
+
+    Below, we assume that 'jobs' is a BackgroundJobManager instance.
+    
+    Usage summary (see the method docstrings for details):
+
+      jobs.new(...) -> start a new job
+      
+      jobs() or jobs.status() -> print status summary of all jobs
+
+      jobs[N] -> returns job number N.
+
+      foo = jobs[N].result -> assign to variable foo the result of job N
+
+      jobs[N].traceback() -> print the traceback of dead job N
+
+      jobs.remove(N) -> remove (finished) job N
+
+      jobs.flush_finished() -> remove all finished jobs
+      
+    As a convenience feature, BackgroundJobManager instances provide the
+    utility result and traceback methods which retrieve the corresponding
+    information from the jobs list:
+
+      jobs.result(N) <--> jobs[N].result
+      jobs.traceback(N) <--> jobs[N].traceback()
+
+    While this appears minor, it allows you to use tab completion
+    interactively on the job manager instance.
+
+    In interactive mode, IPython provides the magic fuction %bg for quick
+    creation of backgrounded expression-based jobs. Type bg? for details."""
+
+    def __init__(self):
+        # Lists for job management
+        self.jobs_run  = []
+        self.jobs_comp = []
+        self.jobs_dead = []
+        # A dict of all jobs, so users can easily access any of them
+        self.jobs_all = {}
+        # For reporting
+        self._comp_report = []
+        self._dead_report = []
+        # Store status codes locally for fast lookups
+        self._s_created   = BackgroundJobBase.stat_created_c
+        self._s_running   = BackgroundJobBase.stat_running_c
+        self._s_completed = BackgroundJobBase.stat_completed_c
+        self._s_dead      = BackgroundJobBase.stat_dead_c
+
+    def new(self,func_or_exp,*args,**kwargs):
+        """Add a new background job and start it in a separate thread.
+
+        There are two types of jobs which can be created:
+
+        1. Jobs based on expressions which can be passed to an eval() call.
+        The expression must be given as a string.  For example:
+
+          job_manager.new('myfunc(x,y,z=1)'[,glob[,loc]])
+
+        The given expression is passed to eval(), along with the optional
+        global/local dicts provided.  If no dicts are given, they are
+        extracted automatically from the caller's frame.
+        
+        A Python statement is NOT a valid eval() expression.  Basically, you
+        can only use as an eval() argument something which can go on the right
+        of an '=' sign and be assigned to a variable.
+
+        For example,"print 'hello'" is not valid, but '2+3' is.
+
+        2. Jobs given a function object, optionally passing additional
+        positional arguments:
+
+          job_manager.new(myfunc,x,y)
+
+        The function is called with the given arguments.
+
+        If you need to pass keyword arguments to your function, you must
+        supply them as a dict named kw:
+
+          job_manager.new(myfunc,x,y,kw=dict(z=1))
+
+        The reason for this assymmetry is that the new() method needs to
+        maintain access to its own keywords, and this prevents name collisions
+        between arguments to new() and arguments to your own functions.
+
+        In both cases, the result is stored in the job.result field of the
+        background job object.
+
+
+        Notes and caveats:
+
+        1. All threads running share the same standard output.  Thus, if your
+        background jobs generate output, it will come out on top of whatever
+        you are currently writing.  For this reason, background jobs are best
+        used with silent functions which simply return their output.
+
+        2. Threads also all work within the same global namespace, and this
+        system does not lock interactive variables.  So if you send job to the
+        background which operates on a mutable object for a long time, and
+        start modifying that same mutable object interactively (or in another
+        backgrounded job), all sorts of bizarre behaviour will occur.
+
+        3. If a background job is spending a lot of time inside a C extension
+        module which does not release the Python Global Interpreter Lock
+        (GIL), this will block the IPython prompt.  This is simply because the
+        Python interpreter can only switch between threads at Python
+        bytecodes.  While the execution is inside C code, the interpreter must
+        simply wait unless the extension module releases the GIL.
+
+        4. There is no way, due to limitations in the Python threads library,
+        to kill a thread once it has started."""
+        
+        if callable(func_or_exp):
+            kw  = kwargs.get('kw',{})
+            job = BackgroundJobFunc(func_or_exp,*args,**kw)
+        elif isinstance(func_or_exp,basestring):
+            if not args:
+                frame = sys._getframe(1)
+                glob, loc = frame.f_globals, frame.f_locals
+            elif len(args)==1:
+                glob = loc = args[0]
+            elif len(args)==2:
+                glob,loc = args
+            else:
+                raise ValueError,\
+                      'Expression jobs take at most 2 args (globals,locals)'
+            job = BackgroundJobExpr(func_or_exp,glob,loc)
+        else:
+            raise
+        jkeys = self.jobs_all.keys()
+        if jkeys:
+            job.num = max(jkeys)+1
+        else:
+            job.num = 0
+        self.jobs_run.append(job)
+        self.jobs_all[job.num] = job
+        print 'Starting job # %s in a separate thread.' % job.num
+        job.start()
+        return job
+
+    def __getitem__(self,key):
+        return self.jobs_all[key]
+
+    def __call__(self):
+        """An alias to self.status(),
+
+        This allows you to simply call a job manager instance much like the
+        Unix jobs shell command."""
+
+        return self.status()
+
+    def _update_status(self):
+        """Update the status of the job lists.
+
+        This method moves finished jobs to one of two lists:
+          - self.jobs_comp: jobs which completed successfully
+          - self.jobs_dead: jobs which finished but died.
+
+        It also copies those jobs to corresponding _report lists.  These lists
+        are used to report jobs completed/dead since the last update, and are
+        then cleared by the reporting function after each call."""
+        
+        run,comp,dead = self._s_running,self._s_completed,self._s_dead
+        jobs_run = self.jobs_run
+        for num in range(len(jobs_run)):
+            job  = jobs_run[num]
+            stat = job.stat_code
+            if stat == run:
+                continue
+            elif stat == comp:
+                self.jobs_comp.append(job)
+                self._comp_report.append(job)
+                jobs_run[num] = False
+            elif stat == dead:
+                self.jobs_dead.append(job)
+                self._dead_report.append(job)
+                jobs_run[num] = False
+        self.jobs_run = filter(None,self.jobs_run)
+
+    def _group_report(self,group,name):
+        """Report summary for a given job group.
+
+        Return True if the group had any elements."""
+
+        if group:
+            print '%s jobs:' % name
+            for job in group:
+                print '%s : %s' % (job.num,job)
+            print
+            return True
+
+    def _group_flush(self,group,name):
+        """Flush a given job group
+
+        Return True if the group had any elements."""
+
+        njobs = len(group)
+        if njobs:
+            plural = {1:''}.setdefault(njobs,'s')
+            print 'Flushing %s %s job%s.' % (njobs,name,plural)
+            group[:] = []
+            return True
+        
+    def _status_new(self):
+        """Print the status of newly finished jobs.
+
+        Return True if any new jobs are reported.
+
+        This call resets its own state every time, so it only reports jobs
+        which have finished since the last time it was called."""
+
+        self._update_status()
+        new_comp = self._group_report(self._comp_report,'Completed')
+        new_dead = self._group_report(self._dead_report,
+                                      'Dead, call job.traceback() for details')
+        self._comp_report[:] = []
+        self._dead_report[:] = []
+        return new_comp or new_dead
+                
+    def status(self,verbose=0):
+        """Print a status of all jobs currently being managed."""
+
+        self._update_status()
+        self._group_report(self.jobs_run,'Running')
+        self._group_report(self.jobs_comp,'Completed')
+        self._group_report(self.jobs_dead,'Dead')
+        # Also flush the report queues
+        self._comp_report[:] = []
+        self._dead_report[:] = []
+
+    def remove(self,num):
+        """Remove a finished (completed or dead) job."""
+
+        try:
+            job = self.jobs_all[num]
+        except KeyError:
+            error('Job #%s not found' % num)
+        else:
+            stat_code = job.stat_code
+            if stat_code == self._s_running:
+                error('Job #%s is still running, it can not be removed.' % num)
+                return
+            elif stat_code == self._s_completed:
+                self.jobs_comp.remove(job)
+            elif stat_code == self._s_dead:
+                self.jobs_dead.remove(job)
+
+    def flush_finished(self):
+        """Flush all jobs finished (completed and dead) from lists.
+
+        Running jobs are never flushed.
+
+        It first calls _status_new(), to update info. If any jobs have
+        completed since the last _status_new() call, the flush operation
+        aborts."""
+
+        if self._status_new():
+            error('New jobs completed since last '\
+                  '_status_new(), aborting flush.')
+            return
+
+        # Remove the finished jobs from the master dict
+        jobs_all = self.jobs_all
+        for job in self.jobs_comp+self.jobs_dead:
+            del(jobs_all[job.num])
+
+        # Now flush these lists completely
+        fl_comp = self._group_flush(self.jobs_comp,'Completed')
+        fl_dead = self._group_flush(self.jobs_dead,'Dead')
+        if not (fl_comp or fl_dead):
+            print 'No jobs to flush.'
+
+    def result(self,num):
+        """result(N) -> return the result of job N."""
+        try:
+            return self.jobs_all[num].result
+        except KeyError:
+            error('Job #%s not found' % num)
+
+    def traceback(self,num):
+        try:
+            self.jobs_all[num].traceback()
+        except KeyError:
+            error('Job #%s not found' % num)
+
+
+class BackgroundJobBase(threading.Thread):
+    """Base class to build BackgroundJob classes.
+
+    The derived classes must implement:
+
+    - Their own __init__, since the one here raises NotImplementedError.  The
+    derived constructor must call self._init() at the end, to provide common
+    initialization.
+
+    - A strform attribute used in calls to __str__.
+
+    - A call() method, which will make the actual execution call and must
+    return a value to be held in the 'result' field of the job object."""
+
+    # Class constants for status, in string and as numerical codes (when
+    # updating jobs lists, we don't want to do string comparisons).  This will
+    # be done at every user prompt, so it has to be as fast as possible
+    stat_created   = 'Created'; stat_created_c = 0
+    stat_running   = 'Running'; stat_running_c = 1
+    stat_completed = 'Completed'; stat_completed_c = 2
+    stat_dead      = 'Dead (Exception), call job.traceback() for details'
+    stat_dead_c = -1
+
+    def __init__(self):
+        raise NotImplementedError, \
+              "This class can not be instantiated directly."
+
+    def _init(self):
+        """Common initialization for all BackgroundJob objects"""
+        
+        for attr in ['call','strform']:
+            assert hasattr(self,attr), "Missing attribute <%s>" % attr
+        
+        # The num tag can be set by an external job manager
+        self.num = None
+      
+        self.status    = BackgroundJobBase.stat_created
+        self.stat_code = BackgroundJobBase.stat_created_c
+        self.finished  = False
+        self.result    = '<BackgroundJob has not completed>'
+        # reuse the ipython traceback handler if we can get to it, otherwise
+        # make a new one
+        try:
+            self._make_tb = __IPYTHON__.InteractiveTB.text
+        except:
+            self._make_tb = AutoFormattedTB(mode = 'Context',
+                                           color_scheme='NoColor',
+                                           tb_offset = 1).text
+        # Hold a formatted traceback if one is generated.
+        self._tb = None
+        
+        threading.Thread.__init__(self)
+
+    def __str__(self):
+        return self.strform
+
+    def __repr__(self):
+        return '<BackgroundJob: %s>' % self.strform
+
+    def traceback(self):
+        print self._tb
+        
+    def run(self):
+        try:
+            self.status    = BackgroundJobBase.stat_running
+            self.stat_code = BackgroundJobBase.stat_running_c
+            self.result    = self.call()
+        except:
+            self.status    = BackgroundJobBase.stat_dead
+            self.stat_code = BackgroundJobBase.stat_dead_c
+            self.finished  = None
+            self.result    = ('<BackgroundJob died, call job.traceback() for details>')
+            self._tb       = self._make_tb()
+        else:
+            self.status    = BackgroundJobBase.stat_completed
+            self.stat_code = BackgroundJobBase.stat_completed_c
+            self.finished  = True
+
+class BackgroundJobExpr(BackgroundJobBase):
+    """Evaluate an expression as a background job (uses a separate thread)."""
+
+    def __init__(self,expression,glob=None,loc=None):
+        """Create a new job from a string which can be fed to eval().
+
+        global/locals dicts can be provided, which will be passed to the eval
+        call."""
+
+        # fail immediately if the given expression can't be compiled
+        self.code = compile(expression,'<BackgroundJob compilation>','eval')
+                
+        if glob is None:
+            glob = {}
+        if loc is None:
+            loc = {}
+            
+        self.expression = self.strform = expression
+        self.glob = glob
+        self.loc = loc
+        self._init()
+        
+    def call(self):
+        return eval(self.code,self.glob,self.loc)
+
+class BackgroundJobFunc(BackgroundJobBase):
+    """Run a function call as a background job (uses a separate thread)."""
+
+    def __init__(self,func,*args,**kwargs):
+        """Create a new job from a callable object.
+
+        Any positional arguments and keyword args given to this constructor
+        after the initial callable are passed directly to it."""
+
+        assert callable(func),'first argument must be callable'
+        
+        if args is None:
+            args = []
+        if kwargs is None:
+            kwargs = {}
+        
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        # The string form will only include the function passed, because
+        # generating string representations of the arguments is a potentially
+        # _very_ expensive operation (e.g. with large arrays).
+        self.strform = str(func)
+        self._init()
+
+    def call(self):
+        return self.func(*self.args,**self.kwargs)
+
+
+if __name__=='__main__':
+
+    import time
+
+    def sleepfunc(interval=2,*a,**kw):
+        args = dict(interval=interval,
+                    args=a,
+                    kwargs=kw)
+        time.sleep(interval)
+        return args
+
+    def diefunc(interval=2,*a,**kw):
+        time.sleep(interval)
+        die
+
+    def printfunc(interval=1,reps=5):
+        for n in range(reps):
+            time.sleep(interval)
+            print 'In the background...'
+
+    jobs = BackgroundJobManager()
+    # first job will have # 0
+    jobs.new(sleepfunc,4)
+    jobs.new(sleepfunc,kw={'reps':2})
+    # This makes a job which will die
+    jobs.new(diefunc,1)
+    jobs.new('printfunc(1,3)')
+
+    # after a while, you can get the traceback of a dead job.  Run the line
+    # below again interactively until it prints a traceback (check the status
+    # of the job):
+    print jobs[1].status
+    jobs[1].traceback()
+    
+    # Run this line again until the printed result changes
+    print "The result of job #0 is:",jobs[0].result
diff --git a/IPython/completer.py b/IPython/completer.py
new file mode 100644
index 0000000..8d8ec63
--- /dev/null
+++ b/IPython/completer.py
@@ -0,0 +1,644 @@
+"""Word completion for IPython.
+
+This module is a fork of the rlcompleter module in the Python standard
+library.  The original enhancements made to rlcompleter have been sent
+upstream and were accepted as of Python 2.3, but we need a lot more
+functionality specific to IPython, so this module will continue to live as an
+IPython-specific utility.
+
+---------------------------------------------------------------------------
+Original rlcompleter documentation:
+
+This requires the latest extension to the readline module (the
+completes keywords, built-ins and globals in __main__; when completing
+NAME.NAME..., it evaluates (!) the expression up to the last dot and
+completes its attributes.
+
+It's very cool to do "import string" type "string.", hit the
+completion key (twice), and see the list of names defined by the
+string module!
+
+Tip: to use the tab key as the completion key, call
+
+    readline.parse_and_bind("tab: complete")
+
+Notes:
+
+- Exceptions raised by the completer function are *ignored* (and
+generally cause the completion to fail).  This is a feature -- since
+readline sets the tty device in raw (or cbreak) mode, printing a
+traceback wouldn't work well without some complicated hoopla to save,
+reset and restore the tty state.
+
+- The evaluation of the NAME.NAME... form may cause arbitrary
+application defined code to be executed if an object with a
+__getattr__ hook is found.  Since it is the responsibility of the
+application (or the user) to enable this feature, I consider this an
+acceptable risk.  More complicated expressions (e.g. function calls or
+indexing operations) are *not* evaluated.
+
+- GNU readline is also used by the built-in functions input() and
+raw_input(), and thus these also benefit/suffer from the completer
+features.  Clearly an interactive application can benefit by
+specifying its own completer function and using raw_input() for all
+its input.
+
+- When the original stdin is not a tty device, GNU readline is never
+used, and this module (and the readline module) are silently inactive.
+
+"""
+
+#*****************************************************************************
+#
+# Since this file is essentially a minimally modified copy of the rlcompleter
+# 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) 2001-2006 Fernando Perez. <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#
+#*****************************************************************************
+
+import __builtin__
+import __main__
+import glob
+import keyword
+import os
+import re
+import shlex
+import sys
+import IPython.rlineimpl as readline    
+import itertools
+from IPython.ipstruct import Struct
+from IPython import ipapi
+from IPython import generics
+import types
+
+# Python 2.4 offers sets as a builtin
+try:
+    set()
+except NameError:
+    from sets import Set as set
+
+from IPython.genutils import debugx, dir2
+
+__all__ = ['Completer','IPCompleter']
+
+class Completer:
+    def __init__(self,namespace=None,global_namespace=None):
+        """Create a new completer for the command line.
+
+        Completer([namespace,global_namespace]) -> completer instance.
+
+        If unspecified, the default namespace where completions are performed
+        is __main__ (technically, __main__.__dict__). Namespaces should be
+        given as dictionaries.
+
+        An optional second namespace can be given.  This allows the completer
+        to handle cases where both the local and global scopes need to be
+        distinguished.
+
+        Completer instances should be used as the completion mechanism of
+        readline via the set_completer() call:
+
+        readline.set_completer(Completer(my_namespace).complete)
+        """
+
+        # 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 (namespace,global_namespace):
+            if ns is not None and type(ns) != types.DictType:
+                raise TypeError,'namespace must be a dictionary'
+
+        # Don't bind to namespace quite yet, but flag whether the user wants a
+        # specific namespace or to use __main__.__dict__. This will allow us
+        # to bind to __main__.__dict__ at completion time, not now.
+        if namespace is None:
+            self.use_main_ns = 1
+        else:
+            self.use_main_ns = 0
+            self.namespace = namespace
+
+        # The global namespace, if given, can be bound directly
+        if global_namespace is None:
+            self.global_namespace = {}
+        else:
+            self.global_namespace = global_namespace
+
+    def complete(self, text, state):
+        """Return the next possible completion for 'text'.
+
+        This is called successively with state == 0, 1, 2, ... until it
+        returns None.  The completion should begin with 'text'.
+
+        """
+        if self.use_main_ns:
+            self.namespace = __main__.__dict__
+            
+        if state == 0:
+            if "." in text:
+                self.matches = self.attr_matches(text)
+            else:
+                self.matches = self.global_matches(text)
+        try:
+            return self.matches[state]
+        except IndexError:
+            return None
+
+    def global_matches(self, text):
+        """Compute matches when text is a simple name.
+
+        Return a list of all keywords, built-in functions and names currently
+        defined in self.namespace or self.global_namespace that match.
+
+        """
+        matches = []
+        match_append = matches.append
+        n = len(text)
+        for lst in [keyword.kwlist,
+                    __builtin__.__dict__.keys(),
+                    self.namespace.keys(),
+                    self.global_namespace.keys()]:
+            for word in lst:
+                if word[:n] == text and word != "__builtins__":
+                    match_append(word)
+        return matches
+
+    def attr_matches(self, text):
+        """Compute matches when text contains a dot.
+
+        Assuming the text is of the form NAME.NAME....[NAME], and is
+        evaluatable in self.namespace or self.global_namespace, it will be
+        evaluated and its attributes (as revealed by dir()) are used as
+        possible completions.  (For class instances, class members are are
+        also considered.)
+
+        WARNING: this can still invoke arbitrary C code, if an object
+        with a __getattr__ hook is evaluated.
+
+        """
+        import re
+
+        # Another option, seems to work great. Catches things like ''.<tab>
+        m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
+
+        if not m:
+            return []
+        
+        expr, attr = m.group(1, 3)
+        try:
+            obj = eval(expr, self.namespace)
+        except:
+            try:
+                obj = eval(expr, self.global_namespace)
+            except:
+                return []
+
+        words = dir2(obj)
+        
+        try:
+            words = generics.complete_object(obj, words)
+        except ipapi.TryNext:
+            pass
+        # Build match list to return
+        n = len(attr)
+        res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
+        return res
+
+class IPCompleter(Completer):
+    """Extension of the completer class with IPython-specific features"""
+
+    def __init__(self,shell,namespace=None,global_namespace=None,
+                 omit__names=0,alias_table=None):
+        """IPCompleter() -> completer
+
+        Return a completer object suitable for use by the readline library
+        via readline.set_completer().
+
+        Inputs:
+
+        - shell: a pointer to the ipython shell itself.  This is needed
+        because this completer knows about magic functions, and those can
+        only be accessed via the ipython instance.
+
+        - namespace: an optional dict where completions are performed.
+
+        - global_namespace: secondary optional dict for completions, to
+        handle cases (such as IPython embedded inside functions) where
+        both Python scopes are visible.
+
+        - The optional omit__names parameter sets the completer to omit the
+        'magic' names (__magicname__) for python objects unless the text
+        to be completed explicitly starts with one or more underscores.
+
+        - If alias_table is supplied, it should be a dictionary of aliases
+        to complete. """
+
+        Completer.__init__(self,namespace,global_namespace)
+        self.magic_prefix = shell.name+'.magic_'
+        self.magic_escape = shell.ESC_MAGIC
+        self.readline = readline
+        delims = self.readline.get_completer_delims()
+        delims = delims.replace(self.magic_escape,'')
+        self.readline.set_completer_delims(delims)
+        self.get_line_buffer = self.readline.get_line_buffer
+        self.get_endidx = self.readline.get_endidx
+        self.omit__names = omit__names
+        self.merge_completions = shell.rc.readline_merge_completions        
+        if alias_table is None:
+            alias_table = {}
+        self.alias_table = alias_table
+        # Regexp to split filenames with spaces in them
+        self.space_name_re = re.compile(r'([^\\] )')
+        # Hold a local ref. to glob.glob for speed
+        self.glob = glob.glob
+
+        # Determine if we are running on 'dumb' terminals, like (X)Emacs
+        # buffers, to avoid completion problems.
+        term = os.environ.get('TERM','xterm')
+        self.dumb_terminal = term in ['dumb','emacs']
+        
+        # Special handling of backslashes needed in win32 platforms
+        if sys.platform == "win32":
+            self.clean_glob = self._clean_glob_win32
+        else:
+            self.clean_glob = self._clean_glob
+        self.matchers = [self.python_matches,
+                         self.file_matches,
+                         self.alias_matches,
+                         self.python_func_kw_matches]
+
+    
+    # Code contributed by Alex Schmolck, for ipython/emacs integration
+    def all_completions(self, text):
+        """Return all possible completions for the benefit of emacs."""
+
+        completions = []
+        comp_append = completions.append
+        try:
+            for i in xrange(sys.maxint):
+                res = self.complete(text, i)
+
+                if not res: break
+
+                comp_append(res)
+        #XXX workaround for ``notDefined.<tab>``
+        except NameError:
+            pass
+        return completions
+    # /end Alex Schmolck code.
+
+    def _clean_glob(self,text):
+        return self.glob("%s*" % text)
+
+    def _clean_glob_win32(self,text):
+        return [f.replace("\\","/")
+                for f in self.glob("%s*" % text)]            
+
+    def file_matches(self, text):
+        """Match filenames, expanding ~USER type strings.
+
+        Most of the seemingly convoluted logic in this completer is an
+        attempt to handle filenames with spaces in them.  And yet it's not
+        quite perfect, because Python's readline doesn't expose all of the
+        GNU readline details needed for this to be done correctly.
+
+        For a filename with a space in it, the printed completions will be
+        only the parts after what's already been typed (instead of the
+        full completions, as is normally done).  I don't think with the
+        current (as of Python 2.3) Python readline it's possible to do
+        better."""
+
+        #print 'Completer->file_matches: <%s>' % text # dbg
+
+        # chars that require escaping with backslash - i.e. chars
+        # that readline treats incorrectly as delimiters, but we
+        # don't want to treat as delimiters in filename matching
+        # when escaped with backslash
+
+        protectables = ' ()[]{}'
+
+        if text.startswith('!'):
+            text = text[1:]
+            text_prefix = '!'
+        else:
+            text_prefix = ''
+            
+        def protect_filename(s):
+            return "".join([(ch in protectables and '\\' + ch or ch)
+                            for ch in s])
+
+        def single_dir_expand(matches):
+            "Recursively expand match lists containing a single dir."
+            
+            if len(matches) == 1 and os.path.isdir(matches[0]):
+                # Takes care of links to directories also.  Use '/'
+                # explicitly, even under Windows, so that name completions
+                # don't end up escaped.
+                d = matches[0]
+                if d[-1] in ['/','\\']:
+                    d = d[:-1]
+
+                subdirs = os.listdir(d)
+                if subdirs:
+                    matches = [ (d + '/' + p) for p in subdirs]
+                    return single_dir_expand(matches)
+                else:
+                    return matches
+            else:
+                return matches
+        
+        lbuf = self.lbuf
+        open_quotes = 0  # track strings with open quotes
+        try:
+            lsplit = shlex.split(lbuf)[-1]
+        except ValueError:
+            # typically an unmatched ", or backslash without escaped char.
+            if lbuf.count('"')==1:
+                open_quotes = 1
+                lsplit = lbuf.split('"')[-1]
+            elif lbuf.count("'")==1:
+                open_quotes = 1
+                lsplit = lbuf.split("'")[-1]
+            else:
+                return []
+        except IndexError:
+            # tab pressed on empty line
+            lsplit = ""
+
+        if lsplit != protect_filename(lsplit):
+            # if protectables are found, do matching on the whole escaped
+            # name
+            has_protectables = 1
+            text0,text = text,lsplit
+        else:
+            has_protectables = 0
+            text = os.path.expanduser(text)
+
+        if text == "":
+            return [text_prefix + protect_filename(f) for f in self.glob("*")]
+
+        m0 = self.clean_glob(text.replace('\\',''))
+        if has_protectables:
+            # If we had protectables, we need to revert our changes to the
+            # beginning of filename so that we don't double-write the part
+            # of the filename we have so far
+            len_lsplit = len(lsplit)
+            matches = [text_prefix + text0 + 
+                       protect_filename(f[len_lsplit:]) for f in m0]
+        else:
+            if open_quotes:
+                # if we have a string with an open quote, we don't need to
+                # protect the names at all (and we _shouldn't_, as it
+                # would cause bugs when the filesystem call is made).
+                matches = m0
+            else:
+                matches = [text_prefix + 
+                           protect_filename(f) for f in m0]
+
+        #print 'mm',matches  # dbg
+        return single_dir_expand(matches)
+
+    def alias_matches(self, text):
+        """Match internal system aliases"""        
+        #print 'Completer->alias_matches:',text,'lb',self.lbuf # dbg
+        
+        # if we are not in the first 'item', alias matching 
+        # doesn't make sense - unless we are starting with 'sudo' command.
+        if ' ' in self.lbuf.lstrip() and not self.lbuf.lstrip().startswith('sudo'):
+            return []
+        text = os.path.expanduser(text)
+        aliases =  self.alias_table.keys()
+        if text == "":
+            return aliases
+        else:
+            return [alias for alias in aliases if alias.startswith(text)]
+
+    def python_matches(self,text):
+        """Match attributes or global python names"""
+
+        #print 'Completer->python_matches, txt=<%s>' % text # dbg
+        if "." in text:
+            try:
+                matches = self.attr_matches(text)
+                if text.endswith('.') and self.omit__names:
+                    if self.omit__names == 1:
+                        # true if txt is _not_ a __ name, false otherwise:
+                        no__name = (lambda txt:
+                                    re.match(r'.*\.__.*?__',txt) is None)
+                    else:
+                        # true if txt is _not_ a _ name, false otherwise:
+                        no__name = (lambda txt:
+                                    re.match(r'.*\._.*?',txt) is None)
+                    matches = filter(no__name, matches)
+            except NameError:
+                # catches <undefined attributes>.<tab>
+                matches = []
+        else:
+            matches = self.global_matches(text)
+            # this is so completion finds magics when automagic is on:
+            if (matches == [] and 
+                 not text.startswith(os.sep) and
+                 not ' ' in self.lbuf):
+                matches = self.attr_matches(self.magic_prefix+text)
+        return matches
+
+    def _default_arguments(self, obj):
+        """Return the list of default arguments of obj if it is callable,
+        or empty list otherwise."""
+
+        if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
+            # for classes, check for __init__,__new__
+            if inspect.isclass(obj):
+                obj = (getattr(obj,'__init__',None) or
+                       getattr(obj,'__new__',None))
+            # for all others, check if they are __call__able
+            elif hasattr(obj, '__call__'):
+                obj = obj.__call__
+            # XXX: is there a way to handle the builtins ?
+        try:
+            args,_,_1,defaults = inspect.getargspec(obj)
+            if defaults:
+                return args[-len(defaults):]
+        except TypeError: pass
+        return []
+
+    def python_func_kw_matches(self,text):
+        """Match named parameters (kwargs) of the last open function"""
+
+        if "." in text: # a parameter cannot be dotted
+            return []
+        try: regexp = self.__funcParamsRegex
+        except AttributeError:
+            regexp = self.__funcParamsRegex = re.compile(r'''
+                '.*?' |    # single quoted strings or
+                ".*?" |    # double quoted strings or
+                \w+   |    # identifier
+                \S         # other characters
+                ''', re.VERBOSE | re.DOTALL)
+        # 1. find the nearest identifier that comes before an unclosed
+        # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
+        tokens = regexp.findall(self.get_line_buffer())
+        tokens.reverse()
+        iterTokens = iter(tokens); openPar = 0
+        for token in iterTokens:
+            if token == ')':
+                openPar -= 1
+            elif token == '(':
+                openPar += 1
+                if openPar > 0:
+                    # found the last unclosed parenthesis
+                    break
+        else:
+            return []
+        # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
+        ids = []
+        isId = re.compile(r'\w+$').match
+        while True:
+            try:
+                ids.append(iterTokens.next())
+                if not isId(ids[-1]):
+                    ids.pop(); break
+                if not iterTokens.next() == '.':
+                    break
+            except StopIteration:
+                break
+        # lookup the candidate callable matches either using global_matches
+        # or attr_matches for dotted names
+        if len(ids) == 1:
+            callableMatches = self.global_matches(ids[0])
+        else:
+            callableMatches = self.attr_matches('.'.join(ids[::-1]))
+        argMatches = []
+        for callableMatch in callableMatches:
+            try: namedArgs = self._default_arguments(eval(callableMatch,
+                                                         self.namespace))
+            except: continue
+            for namedArg in namedArgs:
+                if namedArg.startswith(text):
+                    argMatches.append("%s=" %namedArg)
+        return argMatches
+
+    def dispatch_custom_completer(self,text):
+        #print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
+        line = self.full_lbuf        
+        if not line.strip():
+            return None
+
+        event = Struct()
+        event.line = line
+        event.symbol = text
+        cmd = line.split(None,1)[0]
+        event.command = cmd
+        #print "\ncustom:{%s]\n" % event # dbg
+        
+        # for foo etc, try also to find completer for %foo
+        if not cmd.startswith(self.magic_escape):
+            try_magic = self.custom_completers.s_matches(
+              self.magic_escape + cmd)            
+        else:
+            try_magic = []
+        
+        
+        for c in itertools.chain(
+                                 self.custom_completers.s_matches(cmd),
+                                 try_magic,
+                                 self.custom_completers.flat_matches(self.lbuf)):
+            #print "try",c # dbg
+            try:
+                res = c(event)
+                # first, try case sensitive match
+                withcase = [r for r in res if r.startswith(text)]
+                if withcase:
+                    return withcase
+                # if none, then case insensitive ones are ok too
+                return [r for r in res if r.lower().startswith(text.lower())]
+            except ipapi.TryNext:
+                pass
+            
+        return None
+               
+    def complete(self, text, state,line_buffer=None):
+        """Return the next possible completion for 'text'.
+
+        This is called successively with state == 0, 1, 2, ... until it
+        returns None.  The completion should begin with 'text'.
+
+        :Keywords:
+        - line_buffer: string
+        If not given, the completer attempts to obtain the current line buffer
+        via readline.  This keyword allows clients which are requesting for
+        text completions in non-readline contexts to inform the completer of
+        the entire text.
+        """
+
+        #print '\n*** COMPLETE: <%s> (%s)' % (text,state)  # dbg
+
+        # if there is only a tab on a line with only whitespace, instead
+        # of the mostly useless 'do you want to see all million
+        # completions' message, just do the right thing and give the user
+        # his tab!  Incidentally, this enables pasting of tabbed text from
+        # an editor (as long as autoindent is off).
+
+        # It should be noted that at least pyreadline still shows
+        # file completions - is there a way around it?
+        
+        # don't apply this on 'dumb' terminals, such as emacs buffers, so we
+        # don't interfere with their own tab-completion mechanism.
+        if line_buffer is None:
+            self.full_lbuf = self.get_line_buffer()
+        else:
+            self.full_lbuf = line_buffer
+            
+        if not (self.dumb_terminal or self.full_lbuf.strip()):
+            self.readline.insert_text('\t')
+            return None
+        
+        magic_escape = self.magic_escape
+        magic_prefix = self.magic_prefix
+
+        self.lbuf = self.full_lbuf[:self.get_endidx()]
+
+        try:
+            if text.startswith(magic_escape):
+                text = text.replace(magic_escape,magic_prefix)
+            elif text.startswith('~'):
+                text = os.path.expanduser(text)
+            if state == 0:
+                custom_res = self.dispatch_custom_completer(text)
+                if custom_res is not None:
+                    # did custom completers produce something?
+                    self.matches = custom_res
+                else:
+                    # Extend the list of completions with the results of each
+                    # matcher, so we return results to the user from all
+                    # namespaces.
+                    if self.merge_completions:
+                        self.matches = []
+                        for matcher in self.matchers:
+                            self.matches.extend(matcher(text))
+                    else:
+                        for matcher in self.matchers:
+                            self.matches = matcher(text)
+                            if self.matches:
+                                break
+                    def uniq(alist):
+                        set = {}
+                        return [set.setdefault(e,e) for e in alist if e not in set]
+                    self.matches = uniq(self.matches)                
+            try:
+                ret = self.matches[state].replace(magic_prefix,magic_escape)                
+                return ret
+            except IndexError:
+                return None
+        except:
+            #from IPython.ultraTB import AutoFormattedTB; # dbg
+            #tb=AutoFormattedTB('Verbose');tb() #dbg
+            
+            # If completion fails, don't annoy the user.
+            return None
diff --git a/IPython/deep_reload.py b/IPython/deep_reload.py
new file mode 100644
index 0000000..0a50301
--- /dev/null
+++ b/IPython/deep_reload.py
@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*-
+"""
+A module to change reload() so that it acts recursively.
+To enable it type:
+    >>> import __builtin__, deep_reload
+    >>> __builtin__.reload = deep_reload.reload
+You can then disable it with:
+    >>> __builtin__.reload = deep_reload.original_reload
+    
+Alternatively, you can add a dreload builtin alongside normal reload with:
+    >>> __builtin__.dreload = deep_reload.reload
+    
+This code is almost entirely based on knee.py from the standard library.
+
+$Id: deep_reload.py 958 2005-12-27 23:17:51Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001 Nathaniel Gray <n8gray@caltech.edu>
+#
+#  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 # do it explicitly so pydoc can see it - pydoc bug
+__author__  = '%s <%s>' %  Release.authors['Nathan']
+__license__ = Release.license
+__version__ = "0.5"
+__date__    = "21 August 2001"
+
+import __builtin__
+import imp
+import sys
+
+# Replacement for __import__()
+def deep_import_hook(name, globals=None, locals=None, fromlist=None):
+    parent = determine_parent(globals)
+    q, tail = find_head_package(parent, name)
+    m = load_tail(q, tail)
+    if not fromlist:
+        return q
+    if hasattr(m, "__path__"):
+        ensure_fromlist(m, fromlist)
+    return m
+
+def determine_parent(globals):
+    if not globals or  not globals.has_key("__name__"):
+        return None
+    pname = globals['__name__']
+    if globals.has_key("__path__"):
+        parent = sys.modules[pname]
+        assert globals is parent.__dict__
+        return parent
+    if '.' in pname:
+        i = pname.rfind('.')
+        pname = pname[:i]
+        parent = sys.modules[pname]
+        assert parent.__name__ == pname
+        return parent
+    return None
+
+def find_head_package(parent, name):
+    # Import the first
+    if '.' in name:
+        # 'some.nested.package' -> head = 'some', tail = 'nested.package'
+        i = name.find('.')
+        head = name[:i]
+        tail = name[i+1:]
+    else:
+        # 'packagename' -> head = 'packagename', tail = ''
+        head = name
+        tail = ""
+    if parent:
+        # If this is a subpackage then qname = parent's name + head
+        qname = "%s.%s" % (parent.__name__, head)
+    else:
+        qname = head
+    q = import_module(head, qname, parent)
+    if q: return q, tail
+    if parent:
+        qname = head
+        parent = None
+        q = import_module(head, qname, parent)
+        if q: return q, tail
+    raise ImportError, "No module named " + qname
+
+def load_tail(q, tail):
+    m = q
+    while tail:
+        i = tail.find('.')
+        if i < 0: i = len(tail)
+        head, tail = tail[:i], tail[i+1:]
+
+        # fperez: fix dotted.name reloading failures by changing:
+        #mname = "%s.%s" % (m.__name__, head)
+        # to:
+        mname = m.__name__
+        # This needs more testing!!! (I don't understand this module too well)
+        
+        #print '** head,tail=|%s|->|%s|, mname=|%s|' % (head,tail,mname)  # dbg
+        m = import_module(head, mname, m)
+        if not m:
+            raise ImportError, "No module named " + mname
+    return m
+
+def ensure_fromlist(m, fromlist, recursive=0):
+    for sub in fromlist:
+        if sub == "*":
+            if not recursive:
+                try:
+                    all = m.__all__
+                except AttributeError:
+                    pass
+                else:
+                    ensure_fromlist(m, all, 1)
+            continue
+        if sub != "*" and not hasattr(m, sub):
+            subname = "%s.%s" % (m.__name__, sub)
+            submod = import_module(sub, subname, m)
+            if not submod:
+                raise ImportError, "No module named " + subname
+
+# Need to keep track of what we've already reloaded to prevent cyclic evil
+found_now = {}
+
+def import_module(partname, fqname, parent):
+    global found_now
+    if found_now.has_key(fqname):
+        try:
+            return sys.modules[fqname]    
+        except KeyError:
+            pass
+    
+    print 'Reloading', fqname #, sys.excepthook is sys.__excepthook__, \
+            #sys.displayhook is sys.__displayhook__
+    
+    found_now[fqname] = 1
+    try:
+        fp, pathname, stuff = imp.find_module(partname,
+                                              parent and parent.__path__)
+    except ImportError:
+        return None
+        
+    try:
+        m = imp.load_module(fqname, fp, pathname, stuff)
+    finally:
+        if fp: fp.close()
+        
+    if parent:
+        setattr(parent, partname, m)
+
+    return m
+
+def deep_reload_hook(module):
+    name = module.__name__
+    if '.' not in name:
+        return import_module(name, name, None)
+    i = name.rfind('.')
+    pname = name[:i]
+    parent = sys.modules[pname]
+    return import_module(name[i+1:], name, parent)
+
+# Save the original hooks
+original_reload = __builtin__.reload
+
+# Replacement for reload()
+def reload(module, exclude=['sys', '__builtin__', '__main__']):
+    """Recursively reload all modules used in the given module.  Optionally
+    takes a list of modules to exclude from reloading.  The default exclude
+    list contains sys, __main__, and __builtin__, to prevent, e.g., resetting 
+    display, exception, and io hooks.
+    """
+    global found_now
+    for i in exclude:
+        found_now[i] = 1
+    original_import = __builtin__.__import__
+    __builtin__.__import__ = deep_import_hook    
+    try:
+        ret = deep_reload_hook(module)
+    finally:
+        __builtin__.__import__ = original_import
+        found_now = {}
+    return ret
+
+# Uncomment the following to automatically activate deep reloading whenever
+# this module is imported
+#__builtin__.reload = reload
diff --git a/IPython/demo.py b/IPython/demo.py
new file mode 100644
index 0000000..0734868
--- /dev/null
+++ b/IPython/demo.py
@@ -0,0 +1,526 @@
+"""Module for interactive demos using IPython.
+
+This module implements a few classes for running Python scripts interactively
+in IPython for demonstrations.  With very simple markup (a few tags in
+comments), you can control points where the script stops executing and returns
+control to IPython.
+
+
+Provided classes
+================
+
+The classes are (see their docstrings for further details):
+
+ - Demo: pure python demos
+
+ - IPythonDemo: demos with input to be processed by IPython as if it had been
+ typed interactively (so magics work, as well as any other special syntax you
+ may have added via input prefilters).
+
+ - LineDemo: single-line version of the Demo class.  These demos are executed
+ one line at a time, and require no markup.
+
+ - IPythonLineDemo: IPython version of the LineDemo class (the demo is
+ executed a line at a time, but processed via IPython).
+
+ - ClearMixin: mixin to make Demo classes with less visual clutter.  It
+   declares an empty marquee and a pre_cmd that clears the screen before each
+   block (see Subclassing below).
+
+ - ClearDemo, ClearIPDemo: mixin-enabled versions of the Demo and IPythonDemo
+   classes.
+
+
+Subclassing
+===========
+
+The classes here all include a few methods meant to make customization by
+subclassing more convenient.  Their docstrings below have some more details:
+
+  - marquee(): generates a marquee to provide visible on-screen markers at each
+    block start and end.
+
+  - pre_cmd(): run right before the execution of each block.
+
+  - post_cmd(): run right after the execution of each block.  If the block
+    raises an exception, this is NOT called.
+    
+
+Operation
+=========
+
+The file is run in its own empty namespace (though you can pass it a string of
+arguments as if in a command line environment, and it will see those as
+sys.argv).  But at each stop, the global IPython namespace is updated with the
+current internal demo namespace, so you can work interactively with the data
+accumulated so far.
+
+By default, each block of code is printed (with syntax highlighting) before
+executing it and you have to confirm execution.  This is intended to show the
+code to an audience first so you can discuss it, and only proceed with
+execution once you agree.  There are a few tags which allow you to modify this
+behavior.
+
+The supported tags are:
+
+# <demo> stop
+
+  Defines block boundaries, the points where IPython stops execution of the
+  file and returns to the interactive prompt.
+
+  You can optionally mark the stop tag with extra dashes before and after the
+  word 'stop', to help visually distinguish the blocks in a text editor:
+
+  # <demo> --- stop ---
+  
+
+# <demo> silent
+
+  Make a block execute silently (and hence automatically).  Typically used in
+  cases where you have some boilerplate or initialization code which you need
+  executed but do not want to be seen in the demo.
+  
+# <demo> auto
+
+  Make a block execute automatically, but still being printed.  Useful for
+  simple code which does not warrant discussion, since it avoids the extra
+  manual confirmation.
+
+# <demo> auto_all
+
+  This tag can _only_ be in the first block, and if given it overrides the
+  individual auto tags to make the whole demo fully automatic (no block asks
+  for confirmation).  It can also be given at creation time (or the attribute
+  set later) to override what's in the file.
+
+While _any_ python file can be run as a Demo instance, if there are no stop
+tags the whole file will run in a single block (no different that calling
+first %pycat and then %run).  The minimal markup to make this useful is to
+place a set of stop tags; the other tags are only there to let you fine-tune
+the execution.
+
+This is probably best explained with the simple example file below.  You can
+copy this into a file named ex_demo.py, and try running it via:
+
+from IPython.demo import Demo
+d = Demo('ex_demo.py')
+d()  <--- Call the d object (omit the parens if you have autocall set to 2).
+
+Each time you call the demo object, it runs the next block.  The demo object
+has a few useful methods for navigation, like again(), edit(), jump(), seek()
+and back().  It can be reset for a new run via reset() or reloaded from disk
+(in case you've edited the source) via reload().  See their docstrings below.
+
+
+Example
+=======
+
+The following is a very simple example of a valid demo file.
+
+#################### EXAMPLE DEMO <ex_demo.py> ###############################
+'''A simple interactive demo to illustrate the use of IPython's Demo class.'''
+
+print 'Hello, welcome to an interactive IPython demo.'
+
+# The mark below defines a block boundary, which is a point where IPython will
+# stop execution and return to the interactive prompt. The dashes are actually
+# optional and used only as a visual aid to clearly separate blocks while
+editing the demo code.
+# <demo> stop
+
+x = 1
+y = 2
+
+# <demo> stop
+
+# the mark below makes this block as silent
+# <demo> silent
+
+print 'This is a silent block, which gets executed but not printed.'
+
+# <demo> stop
+# <demo> auto
+print 'This is an automatic block.'
+print 'It is executed without asking for confirmation, but printed.'
+z = x+y
+
+print 'z=',x
+
+# <demo> stop
+# This is just another normal block.
+print 'z is now:', z
+
+print 'bye!'
+################### END EXAMPLE DEMO <ex_demo.py> ############################
+"""
+
+#*****************************************************************************
+#     Copyright (C) 2005-2006 Fernando Perez. <Fernando.Perez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#
+#*****************************************************************************
+
+import exceptions
+import os
+import re
+import shlex
+import sys
+
+from IPython.PyColorize import Parser
+from IPython.genutils import marquee, file_read, file_readlines
+
+__all__ = ['Demo','IPythonDemo','LineDemo','IPythonLineDemo','DemoError']
+
+class DemoError(exceptions.Exception): pass
+
+def re_mark(mark):
+    return re.compile(r'^\s*#\s+<demo>\s+%s\s*$' % mark,re.MULTILINE)
+
+class Demo(object):
+
+    re_stop     = re_mark('-?\s?stop\s?-?')
+    re_silent   = re_mark('silent')
+    re_auto     = re_mark('auto')
+    re_auto_all = re_mark('auto_all')
+
+    def __init__(self,fname,arg_str='',auto_all=None):
+        """Make a new demo object.  To run the demo, simply call the object.
+
+        See the module docstring for full details and an example (you can use
+        IPython.Demo? in IPython to see it).
+
+        Inputs:
+        
+          - fname = filename.
+
+        Optional inputs:
+
+          - arg_str(''): a string of arguments, internally converted to a list
+          just like sys.argv, so the demo script can see a similar
+          environment.
+
+          - auto_all(None): global flag to run all blocks automatically without
+          confirmation.  This attribute overrides the block-level tags and
+          applies to the whole demo.  It is an attribute of the object, and
+          can be changed at runtime simply by reassigning it to a boolean
+          value.
+          """
+        
+        self.fname    = fname
+        self.sys_argv = [fname] + shlex.split(arg_str)
+        self.auto_all = auto_all
+        
+        # get a few things from ipython.  While it's a bit ugly design-wise,
+        # it ensures that things like color scheme and the like are always in
+        # sync with the ipython mode being used.  This class is only meant to
+        # be used inside ipython anyways,  so it's OK.
+        self.ip_ns       = __IPYTHON__.user_ns
+        self.ip_colorize = __IPYTHON__.pycolorize
+        self.ip_showtb   = __IPYTHON__.showtraceback
+        self.ip_runlines = __IPYTHON__.runlines
+        self.shell       = __IPYTHON__
+
+        # load user data and initialize data structures
+        self.reload()
+
+    def reload(self):
+        """Reload source from disk and initialize state."""
+        # read data and parse into blocks
+        self.src     = file_read(self.fname)
+        src_b        = [b.strip() for b in self.re_stop.split(self.src) if b]
+        self._silent = [bool(self.re_silent.findall(b)) for b in src_b]
+        self._auto   = [bool(self.re_auto.findall(b)) for b in src_b]
+
+        # if auto_all is not given (def. None), we read it from the file
+        if self.auto_all is None:
+            self.auto_all = bool(self.re_auto_all.findall(src_b[0]))
+        else:
+            self.auto_all = bool(self.auto_all)
+
+        # Clean the sources from all markup so it doesn't get displayed when
+        # running the demo
+        src_blocks = []
+        auto_strip = lambda s: self.re_auto.sub('',s)
+        for i,b in enumerate(src_b):
+            if self._auto[i]:
+                src_blocks.append(auto_strip(b))
+            else:
+                src_blocks.append(b)
+        # remove the auto_all marker
+        src_blocks[0] = self.re_auto_all.sub('',src_blocks[0])
+
+        self.nblocks = len(src_blocks)
+        self.src_blocks = src_blocks
+
+        # also build syntax-highlighted source
+        self.src_blocks_colored = map(self.ip_colorize,self.src_blocks)
+
+        # ensure clean namespace and seek offset
+        self.reset()
+
+    def reset(self):
+        """Reset the namespace and seek pointer to restart the demo"""
+        self.user_ns     = {}
+        self.finished    = False
+        self.block_index = 0
+
+    def _validate_index(self,index):
+        if index<0 or index>=self.nblocks:
+            raise ValueError('invalid block index %s' % index)
+
+    def _get_index(self,index):
+        """Get the current block index, validating and checking status.
+
+        Returns None if the demo is finished"""
+        
+        if index is None:
+            if self.finished:
+                print 'Demo finished.  Use reset() if you want to rerun it.'
+                return None
+            index = self.block_index
+        else:
+            self._validate_index(index)
+        return index
+
+    def seek(self,index):
+        """Move the current seek pointer to the given block.
+
+        You can use negative indices to seek from the end, with identical
+        semantics to those of Python lists."""
+        if index<0:
+            index = self.nblocks + index
+        self._validate_index(index)
+        self.block_index = index
+        self.finished = False
+
+    def back(self,num=1):
+        """Move the seek pointer back num blocks (default is 1)."""
+        self.seek(self.block_index-num)
+
+    def jump(self,num=1):
+        """Jump a given number of blocks relative to the current one.
+
+        The offset can be positive or negative, defaults to 1."""
+        self.seek(self.block_index+num)
+
+    def again(self):
+        """Move the seek pointer back one block and re-execute."""
+        self.back(1)
+        self()
+
+    def edit(self,index=None):
+        """Edit a block.
+
+        If no number is given, use the last block executed.
+
+        This edits the in-memory copy of the demo, it does NOT modify the
+        original source file.  If you want to do that, simply open the file in
+        an editor and use reload() when you make changes to the file.  This
+        method is meant to let you change a block during a demonstration for
+        explanatory purposes, without damaging your original script."""
+
+        index = self._get_index(index)
+        if index is None:
+            return
+        # decrease the index by one (unless we're at the very beginning), so
+        # that the default demo.edit() call opens up the sblock we've last run
+        if index>0:
+            index -= 1
+            
+        filename = self.shell.mktempfile(self.src_blocks[index])
+        self.shell.hooks.editor(filename,1)
+        new_block = file_read(filename)
+        # update the source and colored block
+        self.src_blocks[index] = new_block
+        self.src_blocks_colored[index] = self.ip_colorize(new_block)
+        self.block_index = index
+        # call to run with the newly edited index
+        self()
+        
+    def show(self,index=None):
+        """Show a single block on screen"""
+
+        index = self._get_index(index)
+        if index is None:
+            return
+
+        print self.marquee('<%s> block # %s (%s remaining)' %
+                           (self.fname,index,self.nblocks-index-1))
+        sys.stdout.write(self.src_blocks_colored[index])
+        sys.stdout.flush()
+
+    def show_all(self):
+        """Show entire demo on screen, block by block"""
+
+        fname = self.fname
+        nblocks = self.nblocks
+        silent = self._silent
+        marquee = self.marquee
+        for index,block in enumerate(self.src_blocks_colored):
+            if silent[index]:
+                print marquee('<%s> SILENT block # %s (%s remaining)' %
+                              (fname,index,nblocks-index-1))
+            else:
+                print marquee('<%s> block # %s (%s remaining)' %
+                              (fname,index,nblocks-index-1))
+            print block,
+        sys.stdout.flush()
+
+    def runlines(self,source):
+        """Execute a string with one or more lines of code"""
+
+        exec source in self.user_ns
+        
+    def __call__(self,index=None):
+        """run a block of the demo.
+
+        If index is given, it should be an integer >=1 and <= nblocks.  This
+        means that the calling convention is one off from typical Python
+        lists.  The reason for the inconsistency is that the demo always
+        prints 'Block n/N, and N is the total, so it would be very odd to use
+        zero-indexing here."""
+
+        index = self._get_index(index)
+        if index is None:
+            return
+        try:
+            marquee = self.marquee
+            next_block = self.src_blocks[index]
+            self.block_index += 1
+            if self._silent[index]:
+                print marquee('Executing silent block # %s (%s remaining)' %
+                              (index,self.nblocks-index-1))
+            else:
+                self.pre_cmd()
+                self.show(index)
+                if self.auto_all or self._auto[index]:
+                    print marquee('output:')
+                else:
+                    print marquee('Press <q> to quit, <Enter> to execute...'),
+                    ans = raw_input().strip()
+                    if ans:
+                        print marquee('Block NOT executed')
+                        return
+            try:
+                save_argv = sys.argv
+                sys.argv = self.sys_argv
+                self.runlines(next_block)
+                self.post_cmd()
+            finally:
+                sys.argv = save_argv
+            
+        except:
+            self.ip_showtb(filename=self.fname)
+        else:
+            self.ip_ns.update(self.user_ns)
+
+        if self.block_index == self.nblocks:
+            mq1 = self.marquee('END OF DEMO')
+            if mq1:
+                # avoid spurious prints if empty marquees are used
+                print
+                print mq1
+                print self.marquee('Use reset() if you want to rerun it.')
+            self.finished = True
+
+    # These methods are meant to be overridden by subclasses who may wish to
+    # customize the behavior of of their demos.
+    def marquee(self,txt='',width=78,mark='*'):
+        """Return the input string centered in a 'marquee'."""
+        return marquee(txt,width,mark)
+
+    def pre_cmd(self):
+        """Method called before executing each block."""
+        pass
+
+    def post_cmd(self):
+        """Method called after executing each block."""
+        pass
+
+
+class IPythonDemo(Demo):
+    """Class for interactive demos with IPython's input processing applied.
+
+    This subclasses Demo, but instead of executing each block by the Python
+    interpreter (via exec), it actually calls IPython on it, so that any input
+    filters which may be in place are applied to the input block.
+
+    If you have an interactive environment which exposes special input
+    processing, you can use this class instead to write demo scripts which
+    operate exactly as if you had typed them interactively.  The default Demo
+    class requires the input to be valid, pure Python code.
+    """
+
+    def runlines(self,source):
+        """Execute a string with one or more lines of code"""
+
+        self.shell.runlines(source)
+        
+class LineDemo(Demo):
+    """Demo where each line is executed as a separate block.
+
+    The input script should be valid Python code.
+
+    This class doesn't require any markup at all, and it's meant for simple
+    scripts (with no nesting or any kind of indentation) which consist of
+    multiple lines of input to be executed, one at a time, as if they had been
+    typed in the interactive prompt."""
+    
+    def reload(self):
+        """Reload source from disk and initialize state."""
+        # read data and parse into blocks
+        src_b           = [l for l in file_readlines(self.fname) if l.strip()]
+        nblocks         = len(src_b)
+        self.src        = os.linesep.join(file_readlines(self.fname))
+        self._silent    = [False]*nblocks
+        self._auto      = [True]*nblocks
+        self.auto_all   = True
+        self.nblocks    = nblocks
+        self.src_blocks = src_b
+
+        # also build syntax-highlighted source
+        self.src_blocks_colored = map(self.ip_colorize,self.src_blocks)
+
+        # ensure clean namespace and seek offset
+        self.reset()
+
+
+class IPythonLineDemo(IPythonDemo,LineDemo):
+    """Variant of the LineDemo class whose input is processed by IPython."""
+    pass
+
+
+class ClearMixin(object):
+    """Use this mixin to make Demo classes with less visual clutter.
+
+    Demos using this mixin will clear the screen before every block and use
+    blank marquees.
+
+    Note that in order for the methods defined here to actually override those
+    of the classes it's mixed with, it must go /first/ in the inheritance
+    tree.  For example:
+
+        class ClearIPDemo(ClearMixin,IPythonDemo): pass
+
+    will provide an IPythonDemo class with the mixin's features.
+    """
+    
+    def marquee(self,txt='',width=78,mark='*'):
+        """Blank marquee that returns '' no matter what the input."""
+        return ''
+
+    def pre_cmd(self):
+        """Method called before executing each block.
+
+        This one simply clears the screen."""
+        os.system('clear')
+
+
+class ClearDemo(ClearMixin,Demo):
+    pass
+
+
+class ClearIPDemo(ClearMixin,IPythonDemo):
+    pass
diff --git a/IPython/dtutils.py b/IPython/dtutils.py
new file mode 100644
index 0000000..37e7aa2
--- /dev/null
+++ b/IPython/dtutils.py
@@ -0,0 +1,137 @@
+"""Doctest-related utilities for IPython.
+
+For most common uses, all you should need to run is::
+
+  from IPython.dtutils import idoctest
+
+See the idoctest docstring below for usage details.
+"""
+
+import doctest
+import sys
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+def rundoctest(text,ns=None,eraise=False):
+    """Run a the input source as a doctest, in the caller's namespace.
+
+    :Parameters:
+      text : str
+        Source to execute.
+
+    :Keywords:
+      ns : dict (None)
+        Namespace where the code should be executed.  If not given, the
+        caller's locals and globals are used.
+      eraise : bool (False)
+        If true, immediately raise any exceptions instead of reporting them at
+        the end.  This allows you to then do interactive debugging via
+        IPython's facilities (use %debug after the fact, or with %pdb for
+        automatic activation).
+    """
+
+    name = 'interactive doctest'
+    filename = '<IPython console>'
+
+    if eraise:
+        runner = doctest.DebugRunner()
+    else:
+        runner = doctest.DocTestRunner()
+        
+    parser = doctest.DocTestParser()
+    if ns is None:
+        f = sys._getframe(1)
+        ns = f.f_globals.copy()
+        ns.update(f.f_locals)
+        
+    test = parser.get_doctest(text,ns,name,filename,0)
+    runner.run(test)
+    runner.summarize(True)
+
+       
+def idoctest(ns=None,eraise=False):
+    """Interactively prompt for input and run it as a doctest.
+
+    To finish entering input, enter two blank lines or Ctrl-D (EOF).  If you
+    use Ctrl-C, the example is aborted and all input discarded.
+
+    :Keywords:
+      ns : dict (None)
+        Namespace where the code should be executed.  If not given, the IPython
+        interactive namespace is used.
+      eraise : bool (False)
+        If true, immediately raise any exceptions instead of reporting them at
+        the end.  This allows you to then do interactive debugging via
+        IPython's facilities (use %debug after the fact, or with %pdb for
+        automatic activation).
+      end_mark : str ('--')
+        String to explicitly indicate the end of input.
+
+    """
+    
+    inlines = []
+    empty_lines = 0  # count consecutive empty lines
+    run_test = True
+
+    if ns is None:
+        ns = ip.user_ns
+
+    ip.IP.savehist()
+    try:
+        while True:
+            line = raw_input()
+            if not line or line.isspace():
+                empty_lines += 1
+            else:
+                empty_lines = 0
+
+            if empty_lines>=2:
+                break
+
+            inlines.append(line)
+    except EOFError:
+        pass
+    except KeyboardInterrupt:
+        print "KeyboardInterrupt - Discarding input."
+        run_test = False
+    
+    ip.IP.reloadhist()
+
+    if run_test:
+        # Extra blank line at the end to ensure that the final docstring has a
+        # closing newline
+        inlines.append('')
+        rundoctest('\n'.join(inlines),ns,eraise)
+
+
+# For debugging of this module itself.
+if __name__ == "__main__":
+    t = """
+    >>> for i in range(10):
+    ...     print i,
+    ...
+    0 1 2 3 4 5 6 7 8 9
+    """
+
+    t2 = """
+        A simple example::
+
+          >>> for i in range(10):
+          ...     print i,
+          ...
+          0 1 2 3 4 5 6 7 8 9
+
+        Some more details::
+
+          >>> print "hello"
+          hello
+    """
+
+    t3 = """
+        A failing example::
+
+          >>> x=1
+          >>> x+1
+          3
+    """
diff --git a/IPython/excolors.py b/IPython/excolors.py
new file mode 100644
index 0000000..068f2b6
--- /dev/null
+++ b/IPython/excolors.py
@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+"""
+Color schemes for exception handling code in IPython.
+
+$Id: Prompts.py 638 2005-07-18 03:01:41Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2005-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+__version__ = Release.version
+
+#****************************************************************************
+# Required modules
+from IPython.ColorANSI import ColorSchemeTable, TermColors, ColorScheme
+
+ExceptionColors = ColorSchemeTable()
+
+# Populate it with color schemes
+C = TermColors # shorthand and local lookup
+ExceptionColors.add_scheme(ColorScheme(
+    'NoColor',
+    # The color to be used for the top line
+    topline = C.NoColor,
+
+    # The colors to be used in the traceback
+    filename = C.NoColor,
+    lineno = C.NoColor,
+    name = C.NoColor,
+    vName = C.NoColor,
+    val = C.NoColor,
+    em = C.NoColor,
+    
+    # Emphasized colors for the last frame of the traceback
+    normalEm = C.NoColor,
+    filenameEm = C.NoColor,
+    linenoEm = C.NoColor,
+    nameEm = C.NoColor,
+    valEm = C.NoColor,
+    
+    # Colors for printing the exception
+    excName = C.NoColor,
+    line = C.NoColor,
+    caret = C.NoColor,
+    Normal = C.NoColor
+    ))
+
+# make some schemes as instances so we can copy them for modification easily
+ExceptionColors.add_scheme(ColorScheme(
+    'Linux',
+    # The color to be used for the top line
+    topline = C.LightRed,
+
+    # The colors to be used in the traceback
+    filename = C.Green,
+    lineno = C.Green,
+    name = C.Purple,
+    vName = C.Cyan,
+    val = C.Green,
+    em = C.LightCyan,
+
+    # Emphasized colors for the last frame of the traceback
+    normalEm = C.LightCyan,
+    filenameEm = C.LightGreen,
+    linenoEm = C.LightGreen,
+    nameEm = C.LightPurple,
+    valEm = C.LightBlue,
+
+    # Colors for printing the exception
+    excName = C.LightRed,
+    line = C.Yellow,
+    caret = C.White,
+    Normal = C.Normal
+    ))
+
+# For light backgrounds, swap dark/light colors
+ExceptionColors.add_scheme(ColorScheme(
+    'LightBG',
+    # The color to be used for the top line
+    topline = C.Red,
+    
+    # The colors to be used in the traceback
+    filename = C.LightGreen,
+    lineno = C.LightGreen,
+    name = C.LightPurple,
+    vName = C.Cyan,
+    val = C.LightGreen,
+    em = C.Cyan,
+
+    # Emphasized colors for the last frame of the traceback
+    normalEm = C.Cyan,
+    filenameEm = C.Green,
+    linenoEm = C.Green,
+    nameEm = C.Purple,
+    valEm = C.Blue,
+
+    # Colors for printing the exception
+    excName = C.Red,
+    #line = C.Brown,  # brown often is displayed as yellow
+    line = C.Red,
+    caret = C.Normal,
+    Normal = C.Normal
+    ))
diff --git a/IPython/external/__init__.py b/IPython/external/__init__.py
new file mode 100644
index 0000000..3104c19
--- /dev/null
+++ b/IPython/external/__init__.py
@@ -0,0 +1,5 @@
+"""
+This package contains all third-party modules bundled with IPython.
+"""
+
+__all__ = ["simplegeneric"]
diff --git a/IPython/external/mglob.py b/IPython/external/mglob.py
new file mode 100644
index 0000000..37d6a6c
--- /dev/null
+++ b/IPython/external/mglob.py
@@ -0,0 +1,203 @@
+#!/usr/bin/env python
+
+r""" mglob - enhanced file list expansion module
+
+Use as stand-alone utility (for xargs, `backticks` etc.), 
+or a globbing library for own python programs. Globbing the sys.argv is something 
+that almost every Windows script has to perform manually, and this module is here
+to help with that task. Also Unix users will benefit from enhanced modes 
+such as recursion, exclusion, directory omission...
+
+Unlike glob.glob, directories are not included in the glob unless specified 
+with 'dir:'
+
+'expand' is the function to use in python programs. Typical use
+to expand argv (esp. in windows)::
+
+    try:
+        import mglob 
+        files = mglob.expand(sys.argv[1:])
+    except ImportError:
+        print "mglob not found; try 'easy_install mglob' for extra features"
+        files = sys.argv[1:] 
+
+Note that for unix, shell expands *normal* wildcards (*.cpp, etc.) in argv.
+Therefore, you might want to use quotes with normal wildcards to prevent this 
+expansion, in order for mglob to see the wildcards and get the wanted behaviour.
+Not quoting the wildcards is harmless and typically has equivalent results, though.
+
+Author: Ville Vainio <vivainio@gmail.com>
+License: MIT Open Source license
+
+"""
+
+#Assigned in variable for "usage" printing convenience"
+
+globsyntax = """\
+This program allows specifying filenames with "mglob" mechanism.
+Supported syntax in globs (wilcard matching patterns)::
+
+ *.cpp ?ellowo*                
+     - obvious. Differs from normal glob in that dirs are not included.
+       Unix users might want to write this as: "*.cpp" "?ellowo*"
+ rec:/usr/share=*.txt,*.doc    
+     - get all *.txt and *.doc under /usr/share, 
+       recursively
+ rec:/usr/share
+     - All files under /usr/share, recursively
+ rec:*.py
+     - All .py files under current working dir, recursively
+ foo                           
+     - File or dir foo
+ !*.bak readme*                   
+     - readme*, exclude files ending with .bak
+ !.svn/ !.hg/ !*_Data/ rec:.
+     - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
+       Trailing / is the key, \ does not work!
+ dir:foo                       
+     - the directory foo if it exists (not files in foo)
+ dir:*                         
+     - all directories in current folder
+ foo.py bar.* !h* rec:*.py
+     - Obvious. !h* exclusion only applies for rec:*.py.
+       foo.py is *not* included twice.
+ @filelist.txt
+     - All files listed in 'filelist.txt' file, on separate lines.
+ """
+
+
+__version__ = "0.2"
+
+
+import os,glob,fnmatch,sys
+from sets import Set as set
+
+                
+def expand(flist,exp_dirs = False):
+    """ Expand the glob(s) in flist.
+    
+    flist may be either a whitespace-separated list of globs/files
+    or an array of globs/files.
+    
+    if exp_dirs is true, directory names in glob are expanded to the files
+    contained in them - otherwise, directory names are returned as is.
+    
+    """
+    if isinstance(flist, basestring):
+        flist = flist.split()
+    done_set = set()
+    denied_set = set()
+
+    def recfind(p, pats = ["*"]):
+        denied_dirs = ["*" + d+"*" for d in denied_set if d.endswith("/")]
+        #print "de", denied_dirs
+        for (dp,dnames,fnames) in os.walk(p):
+            # see if we should ignore the whole directory
+            dp_norm = dp.replace("\\","/") + "/"
+            deny = False
+            #print "dp",dp
+            for deny_pat in denied_dirs:
+                if fnmatch.fnmatch( dp_norm, deny_pat):
+                    deny = True
+                    break
+            if deny:
+                continue
+
+                    
+            for f in fnames:
+                matched = False
+                for p in pats:
+                    if fnmatch.fnmatch(f,p):
+                        matched = True
+                        break
+                if matched:
+                    yield os.path.join(dp,f)            
+
+    def once_filter(seq):
+        for it in seq:
+            p = os.path.abspath(it)
+            if p in done_set:
+                continue
+            done_set.add(p)
+            deny = False
+            for deny_pat in denied_set:
+                if fnmatch.fnmatch(os.path.basename(p), deny_pat):
+                    deny = True
+                    break
+            if not deny:
+                yield it
+        return
+            
+    res = []
+
+    for ent in flist:
+        ent = os.path.expanduser(os.path.expandvars(ent))
+        if ent.lower().startswith('rec:'):
+            fields = ent[4:].split('=')            
+            if len(fields) == 2:
+                pth, patlist = fields
+            elif len(fields) == 1:
+                if os.path.isdir(fields[0]):
+                    # single arg is dir
+                    pth, patlist = fields[0], '*'
+                else: 
+                    # single arg is pattern
+                    pth, patlist = '.', fields[0]
+                    
+            elif len(fields) == 0:
+                pth, pathlist = '.','*'
+                
+            pats = patlist.split(',')
+            res.extend(once_filter(recfind(pth, pats)))
+        # filelist
+        elif ent.startswith('@') and os.path.isfile(ent[1:]):
+            res.extend(once_filter(open(ent[1:]).read().splitlines()))
+        # exclusion
+        elif ent.startswith('!'):
+            denied_set.add(ent[1:])
+        # glob only dirs
+        elif ent.lower().startswith('dir:'):
+            res.extend(once_filter(filter(os.path.isdir,glob.glob(ent[4:]))))
+            
+        # get all files in the specified dir
+        elif os.path.isdir(ent) and exp_dirs:
+            res.extend(once_filter(filter(os.path.isfile,glob.glob(ent + os.sep+"*"))))
+            
+        # glob only files
+
+        elif '*' in ent or '?' in ent:
+            res.extend(once_filter(filter(os.path.isfile,glob.glob(ent))))
+
+        else:
+            res.extend(once_filter([ent]))
+    return res
+            
+            
+def test():
+    assert (
+        expand("*.py ~/.ipython/*.py rec:/usr/share/doc-base") == 
+        expand( ['*.py', '~/.ipython/*.py', 'rec:/usr/share/doc-base'] ) 
+        )
+    
+def main():
+    if len(sys.argv) < 2:
+        print globsyntax
+        return
+    
+    print "\n".join(expand(sys.argv[1:])),
+
+def mglob_f(self, arg):
+    from IPython.genutils import SList
+    if arg.strip():
+        return SList(expand(arg))
+    print "Please specify pattern!"
+    print globsyntax
+
+def init_ipython(ip):
+    """ register %mglob for IPython """
+    mglob_f.__doc__ = globsyntax
+    ip.expose_magic("mglob",mglob_f)  
+    
+# test()
+if __name__ == "__main__":
+    main()
diff --git a/IPython/external/path.py b/IPython/external/path.py
new file mode 100644
index 0000000..038d7ce
--- /dev/null
+++ b/IPython/external/path.py
@@ -0,0 +1,970 @@
+""" path.py - An object representing a path to a file or directory.
+
+Example:
+
+from IPython.external.path import path
+d = path('/home/guido/bin')
+for f in d.files('*.py'):
+    f.chmod(0755)
+
+This module requires Python 2.2 or later.
+
+
+URL:     http://www.jorendorff.com/articles/python/path
+Author:  Jason Orendorff <jason.orendorff\x40gmail\x2ecom> (and others - see the url!)
+Date:    9 Mar 2007
+"""
+
+
+# TODO
+#   - Tree-walking functions don't avoid symlink loops.  Matt Harrison
+#     sent me a patch for this.
+#   - Bug in write_text().  It doesn't support Universal newline mode.
+#   - Better error message in listdir() when self isn't a
+#     directory. (On Windows, the error message really sucks.)
+#   - Make sure everything has a good docstring.
+#   - Add methods for regex find and replace.
+#   - guess_content_type() method?
+#   - Perhaps support arguments to touch().
+
+from __future__ import generators
+
+import sys, warnings, os, fnmatch, glob, shutil, codecs, md5
+
+__version__ = '2.2'
+__all__ = ['path']
+
+# Platform-specific support for path.owner
+if os.name == 'nt':
+    try:
+        import win32security
+    except ImportError:
+        win32security = None
+else:
+    try:
+        import pwd
+    except ImportError:
+        pwd = None
+
+# Pre-2.3 support.  Are unicode filenames supported?
+_base = str
+_getcwd = os.getcwd
+try:
+    if os.path.supports_unicode_filenames:
+        _base = unicode
+        _getcwd = os.getcwdu
+except AttributeError:
+    pass
+
+# Pre-2.3 workaround for booleans
+try:
+    True, False
+except NameError:
+    True, False = 1, 0
+
+# Pre-2.3 workaround for basestring.
+try:
+    basestring
+except NameError:
+    basestring = (str, unicode)
+
+# Universal newline support
+_textmode = 'r'
+if hasattr(file, 'newlines'):
+    _textmode = 'U'
+
+
+class TreeWalkWarning(Warning):
+    pass
+
+class path(_base):
+    """ Represents a filesystem path.
+
+    For documentation on individual methods, consult their
+    counterparts in os.path.
+    """
+
+    # --- Special Python methods.
+
+    def __repr__(self):
+        return 'path(%s)' % _base.__repr__(self)
+
+    # Adding a path and a string yields a path.
+    def __add__(self, more):
+        try:
+            resultStr = _base.__add__(self, more)
+        except TypeError:  #Python bug
+            resultStr = NotImplemented
+        if resultStr is NotImplemented:
+            return resultStr
+        return self.__class__(resultStr)
+
+    def __radd__(self, other):
+        if isinstance(other, basestring):
+            return self.__class__(other.__add__(self))
+        else:
+            return NotImplemented
+
+    # The / operator joins paths.
+    def __div__(self, rel):
+        """ fp.__div__(rel) == fp / rel == fp.joinpath(rel)
+
+        Join two path components, adding a separator character if
+        needed.
+        """
+        return self.__class__(os.path.join(self, rel))
+
+    # Make the / operator work even when true division is enabled.
+    __truediv__ = __div__
+
+    def getcwd(cls):
+        """ Return the current working directory as a path object. """
+        return cls(_getcwd())
+    getcwd = classmethod(getcwd)
+
+
+    # --- Operations on path strings.
+
+    isabs = os.path.isabs
+    def abspath(self):       return self.__class__(os.path.abspath(self))
+    def normcase(self):      return self.__class__(os.path.normcase(self))
+    def normpath(self):      return self.__class__(os.path.normpath(self))
+    def realpath(self):      return self.__class__(os.path.realpath(self))
+    def expanduser(self):    return self.__class__(os.path.expanduser(self))
+    def expandvars(self):    return self.__class__(os.path.expandvars(self))
+    def dirname(self):       return self.__class__(os.path.dirname(self))
+    basename = os.path.basename
+
+    def expand(self):
+        """ Clean up a filename by calling expandvars(),
+        expanduser(), and normpath() on it.
+
+        This is commonly everything needed to clean up a filename
+        read from a configuration file, for example.
+        """
+        return self.expandvars().expanduser().normpath()
+
+    def _get_namebase(self):
+        base, ext = os.path.splitext(self.name)
+        return base
+
+    def _get_ext(self):
+        f, ext = os.path.splitext(_base(self))
+        return ext
+
+    def _get_drive(self):
+        drive, r = os.path.splitdrive(self)
+        return self.__class__(drive)
+
+    parent = property(
+        dirname, None, None,
+        """ This path's parent directory, as a new path object.
+
+        For example, path('/usr/local/lib/libpython.so').parent == path('/usr/local/lib')
+        """)
+
+    name = property(
+        basename, None, None,
+        """ The name of this file or directory without the full path.
+
+        For example, path('/usr/local/lib/libpython.so').name == 'libpython.so'
+        """)
+
+    namebase = property(
+        _get_namebase, None, None,
+        """ The same as path.name, but with one file extension stripped off.
+
+        For example, path('/home/guido/python.tar.gz').name     == 'python.tar.gz',
+        but          path('/home/guido/python.tar.gz').namebase == 'python.tar'
+        """)
+
+    ext = property(
+        _get_ext, None, None,
+        """ The file extension, for example '.py'. """)
+
+    drive = property(
+        _get_drive, None, None,
+        """ The drive specifier, for example 'C:'.
+        This is always empty on systems that don't use drive specifiers.
+        """)
+
+    def splitpath(self):
+        """ p.splitpath() -> Return (p.parent, p.name). """
+        parent, child = os.path.split(self)
+        return self.__class__(parent), child
+
+    def splitdrive(self):
+        """ p.splitdrive() -> Return (p.drive, <the rest of p>).
+
+        Split the drive specifier from this path.  If there is
+        no drive specifier, p.drive is empty, so the return value
+        is simply (path(''), p).  This is always the case on Unix.
+        """
+        drive, rel = os.path.splitdrive(self)
+        return self.__class__(drive), rel
+
+    def splitext(self):
+        """ p.splitext() -> Return (p.stripext(), p.ext).
+
+        Split the filename extension from this path and return
+        the two parts.  Either part may be empty.
+
+        The extension is everything from '.' to the end of the
+        last path segment.  This has the property that if
+        (a, b) == p.splitext(), then a + b == p.
+        """
+        filename, ext = os.path.splitext(self)
+        return self.__class__(filename), ext
+
+    def stripext(self):
+        """ p.stripext() -> Remove one file extension from the path.
+
+        For example, path('/home/guido/python.tar.gz').stripext()
+        returns path('/home/guido/python.tar').
+        """
+        return self.splitext()[0]
+
+    if hasattr(os.path, 'splitunc'):
+        def splitunc(self):
+            unc, rest = os.path.splitunc(self)
+            return self.__class__(unc), rest
+
+        def _get_uncshare(self):
+            unc, r = os.path.splitunc(self)
+            return self.__class__(unc)
+
+        uncshare = property(
+            _get_uncshare, None, None,
+            """ The UNC mount point for this path.
+            This is empty for paths on local drives. """)
+
+    def joinpath(self, *args):
+        """ Join two or more path components, adding a separator
+        character (os.sep) if needed.  Returns a new path
+        object.
+        """
+        return self.__class__(os.path.join(self, *args))
+
+    def splitall(self):
+        r""" Return a list of the path components in this path.
+
+        The first item in the list will be a path.  Its value will be
+        either os.curdir, os.pardir, empty, or the root directory of
+        this path (for example, '/' or 'C:\\').  The other items in
+        the list will be strings.
+
+        path.path.joinpath(*result) will yield the original path.
+        """
+        parts = []
+        loc = self
+        while loc != os.curdir and loc != os.pardir:
+            prev = loc
+            loc, child = prev.splitpath()
+            if loc == prev:
+                break
+            parts.append(child)
+        parts.append(loc)
+        parts.reverse()
+        return parts
+
+    def relpath(self):
+        """ Return this path as a relative path,
+        based from the current working directory.
+        """
+        cwd = self.__class__(os.getcwd())
+        return cwd.relpathto(self)
+
+    def relpathto(self, dest):
+        """ Return a relative path from self to dest.
+
+        If there is no relative path from self to dest, for example if
+        they reside on different drives in Windows, then this returns
+        dest.abspath().
+        """
+        origin = self.abspath()
+        dest = self.__class__(dest).abspath()
+
+        orig_list = origin.normcase().splitall()
+        # Don't normcase dest!  We want to preserve the case.
+        dest_list = dest.splitall()
+
+        if orig_list[0] != os.path.normcase(dest_list[0]):
+            # Can't get here from there.
+            return dest
+
+        # Find the location where the two paths start to differ.
+        i = 0
+        for start_seg, dest_seg in zip(orig_list, dest_list):
+            if start_seg != os.path.normcase(dest_seg):
+                break
+            i += 1
+
+        # Now i is the point where the two paths diverge.
+        # Need a certain number of "os.pardir"s to work up
+        # from the origin to the point of divergence.
+        segments = [os.pardir] * (len(orig_list) - i)
+        # Need to add the diverging part of dest_list.
+        segments += dest_list[i:]
+        if len(segments) == 0:
+            # If they happen to be identical, use os.curdir.
+            relpath = os.curdir
+        else:
+            relpath = os.path.join(*segments)
+        return self.__class__(relpath)
+
+    # --- Listing, searching, walking, and matching
+
+    def listdir(self, pattern=None):
+        """ D.listdir() -> List of items in this directory.
+
+        Use D.files() or D.dirs() instead if you want a listing
+        of just files or just subdirectories.
+
+        The elements of the list are path objects.
+
+        With the optional 'pattern' argument, this only lists
+        items whose names match the given pattern.
+        """
+        names = os.listdir(self)
+        if pattern is not None:
+            names = fnmatch.filter(names, pattern)
+        return [self / child for child in names]
+
+    def dirs(self, pattern=None):
+        """ D.dirs() -> List of this directory's subdirectories.
+
+        The elements of the list are path objects.
+        This does not walk recursively into subdirectories
+        (but see path.walkdirs).
+
+        With the optional 'pattern' argument, this only lists
+        directories whose names match the given pattern.  For
+        example, d.dirs('build-*').
+        """
+        return [p for p in self.listdir(pattern) if p.isdir()]
+
+    def files(self, pattern=None):
+        """ D.files() -> List of the files in this directory.
+
+        The elements of the list are path objects.
+        This does not walk into subdirectories (see path.walkfiles).
+
+        With the optional 'pattern' argument, this only lists files
+        whose names match the given pattern.  For example,
+        d.files('*.pyc').
+        """
+        
+        return [p for p in self.listdir(pattern) if p.isfile()]
+
+    def walk(self, pattern=None, errors='strict'):
+        """ D.walk() -> iterator over files and subdirs, recursively.
+
+        The iterator yields path objects naming each child item of
+        this directory and its descendants.  This requires that
+        D.isdir().
+
+        This performs a depth-first traversal of the directory tree.
+        Each directory is returned just before all its children.
+
+        The errors= keyword argument controls behavior when an
+        error occurs.  The default is 'strict', which causes an
+        exception.  The other allowed values are 'warn', which
+        reports the error via warnings.warn(), and 'ignore'.
+        """
+        if errors not in ('strict', 'warn', 'ignore'):
+            raise ValueError("invalid errors parameter")
+
+        try:
+            childList = self.listdir()
+        except Exception:
+            if errors == 'ignore':
+                return
+            elif errors == 'warn':
+                warnings.warn(
+                    "Unable to list directory '%s': %s"
+                    % (self, sys.exc_info()[1]),
+                    TreeWalkWarning)
+                return
+            else:
+                raise
+
+        for child in childList:
+            if pattern is None or child.fnmatch(pattern):
+                yield child
+            try:
+                isdir = child.isdir()
+            except Exception:
+                if errors == 'ignore':
+                    isdir = False
+                elif errors == 'warn':
+                    warnings.warn(
+                        "Unable to access '%s': %s"
+                        % (child, sys.exc_info()[1]),
+                        TreeWalkWarning)
+                    isdir = False
+                else:
+                    raise
+
+            if isdir:
+                for item in child.walk(pattern, errors):
+                    yield item
+
+    def walkdirs(self, pattern=None, errors='strict'):
+        """ D.walkdirs() -> iterator over subdirs, recursively.
+
+        With the optional 'pattern' argument, this yields only
+        directories whose names match the given pattern.  For
+        example, mydir.walkdirs('*test') yields only directories
+        with names ending in 'test'.
+
+        The errors= keyword argument controls behavior when an
+        error occurs.  The default is 'strict', which causes an
+        exception.  The other allowed values are 'warn', which
+        reports the error via warnings.warn(), and 'ignore'.
+        """
+        if errors not in ('strict', 'warn', 'ignore'):
+            raise ValueError("invalid errors parameter")
+
+        try:
+            dirs = self.dirs()
+        except Exception:
+            if errors == 'ignore':
+                return
+            elif errors == 'warn':
+                warnings.warn(
+                    "Unable to list directory '%s': %s"
+                    % (self, sys.exc_info()[1]),
+                    TreeWalkWarning)
+                return
+            else:
+                raise
+
+        for child in dirs:
+            if pattern is None or child.fnmatch(pattern):
+                yield child
+            for subsubdir in child.walkdirs(pattern, errors):
+                yield subsubdir
+
+    def walkfiles(self, pattern=None, errors='strict'):
+        """ D.walkfiles() -> iterator over files in D, recursively.
+
+        The optional argument, pattern, limits the results to files
+        with names that match the pattern.  For example,
+        mydir.walkfiles('*.tmp') yields only files with the .tmp
+        extension.
+        """
+        if errors not in ('strict', 'warn', 'ignore'):
+            raise ValueError("invalid errors parameter")
+
+        try:
+            childList = self.listdir()
+        except Exception:
+            if errors == 'ignore':
+                return
+            elif errors == 'warn':
+                warnings.warn(
+                    "Unable to list directory '%s': %s"
+                    % (self, sys.exc_info()[1]),
+                    TreeWalkWarning)
+                return
+            else:
+                raise
+
+        for child in childList:
+            try:
+                isfile = child.isfile()
+                isdir = not isfile and child.isdir()
+            except:
+                if errors == 'ignore':
+                    continue
+                elif errors == 'warn':
+                    warnings.warn(
+                        "Unable to access '%s': %s"
+                        % (self, sys.exc_info()[1]),
+                        TreeWalkWarning)
+                    continue
+                else:
+                    raise
+
+            if isfile:
+                if pattern is None or child.fnmatch(pattern):
+                    yield child
+            elif isdir:
+                for f in child.walkfiles(pattern, errors):
+                    yield f
+
+    def fnmatch(self, pattern):
+        """ Return True if self.name matches the given pattern.
+
+        pattern - A filename pattern with wildcards,
+            for example '*.py'.
+        """
+        return fnmatch.fnmatch(self.name, pattern)
+
+    def glob(self, pattern):
+        """ Return a list of path objects that match the pattern.
+
+        pattern - a path relative to this directory, with wildcards.
+
+        For example, path('/users').glob('*/bin/*') returns a list
+        of all the files users have in their bin directories.
+        """
+        cls = self.__class__
+        return [cls(s) for s in glob.glob(_base(self / pattern))]
+
+
+    # --- Reading or writing an entire file at once.
+
+    def open(self, mode='r'):
+        """ Open this file.  Return a file object. """
+        return file(self, mode)
+
+    def bytes(self):
+        """ Open this file, read all bytes, return them as a string. """
+        f = self.open('rb')
+        try:
+            return f.read()
+        finally:
+            f.close()
+
+    def write_bytes(self, bytes, append=False):
+        """ Open this file and write the given bytes to it.
+
+        Default behavior is to overwrite any existing file.
+        Call p.write_bytes(bytes, append=True) to append instead.
+        """
+        if append:
+            mode = 'ab'
+        else:
+            mode = 'wb'
+        f = self.open(mode)
+        try:
+            f.write(bytes)
+        finally:
+            f.close()
+
+    def text(self, encoding=None, errors='strict'):
+        r""" Open this file, read it in, return the content as a string.
+
+        This uses 'U' mode in Python 2.3 and later, so '\r\n' and '\r'
+        are automatically translated to '\n'.
+
+        Optional arguments:
+
+        encoding - The Unicode encoding (or character set) of
+            the file.  If present, the content of the file is
+            decoded and returned as a unicode object; otherwise
+            it is returned as an 8-bit str.
+        errors - How to handle Unicode errors; see help(str.decode)
+            for the options.  Default is 'strict'.
+        """
+        if encoding is None:
+            # 8-bit
+            f = self.open(_textmode)
+            try:
+                return f.read()
+            finally:
+                f.close()
+        else:
+            # Unicode
+            f = codecs.open(self, 'r', encoding, errors)
+            # (Note - Can't use 'U' mode here, since codecs.open
+            # doesn't support 'U' mode, even in Python 2.3.)
+            try:
+                t = f.read()
+            finally:
+                f.close()
+            return (t.replace(u'\r\n', u'\n')
+                     .replace(u'\r\x85', u'\n')
+                     .replace(u'\r', u'\n')
+                     .replace(u'\x85', u'\n')
+                     .replace(u'\u2028', u'\n'))
+
+    def write_text(self, text, encoding=None, errors='strict', linesep=os.linesep, append=False):
+        r""" Write the given text to this file.
+
+        The default behavior is to overwrite any existing file;
+        to append instead, use the 'append=True' keyword argument.
+
+        There are two differences between path.write_text() and
+        path.write_bytes(): newline handling and Unicode handling.
+        See below.
+
+        Parameters:
+
+          - text - str/unicode - The text to be written.
+
+          - encoding - str - The Unicode encoding that will be used.
+            This is ignored if 'text' isn't a Unicode string.
+
+          - errors - str - How to handle Unicode encoding errors.
+            Default is 'strict'.  See help(unicode.encode) for the
+            options.  This is ignored if 'text' isn't a Unicode
+            string.
+
+          - linesep - keyword argument - str/unicode - The sequence of
+            characters to be used to mark end-of-line.  The default is
+            os.linesep.  You can also specify None; this means to
+            leave all newlines as they are in 'text'.
+
+          - append - keyword argument - bool - Specifies what to do if
+            the file already exists (True: append to the end of it;
+            False: overwrite it.)  The default is False.
+
+
+        --- Newline handling.
+
+        write_text() converts all standard end-of-line sequences
+        ('\n', '\r', and '\r\n') to your platform's default end-of-line
+        sequence (see os.linesep; on Windows, for example, the
+        end-of-line marker is '\r\n').
+
+        If you don't like your platform's default, you can override it
+        using the 'linesep=' keyword argument.  If you specifically want
+        write_text() to preserve the newlines as-is, use 'linesep=None'.
+
+        This applies to Unicode text the same as to 8-bit text, except
+        there are three additional standard Unicode end-of-line sequences:
+        u'\x85', u'\r\x85', and u'\u2028'.
+
+        (This is slightly different from when you open a file for
+        writing with fopen(filename, "w") in C or file(filename, 'w')
+        in Python.)
+
+
+        --- Unicode
+
+        If 'text' isn't Unicode, then apart from newline handling, the
+        bytes are written verbatim to the file.  The 'encoding' and
+        'errors' arguments are not used and must be omitted.
+
+        If 'text' is Unicode, it is first converted to bytes using the
+        specified 'encoding' (or the default encoding if 'encoding'
+        isn't specified).  The 'errors' argument applies only to this
+        conversion.
+
+        """
+        if isinstance(text, unicode):
+            if linesep is not None:
+                # Convert all standard end-of-line sequences to
+                # ordinary newline characters.
+                text = (text.replace(u'\r\n', u'\n')
+                            .replace(u'\r\x85', u'\n')
+                            .replace(u'\r', u'\n')
+                            .replace(u'\x85', u'\n')
+                            .replace(u'\u2028', u'\n'))
+                text = text.replace(u'\n', linesep)
+            if encoding is None:
+                encoding = sys.getdefaultencoding()
+            bytes = text.encode(encoding, errors)
+        else:
+            # It is an error to specify an encoding if 'text' is
+            # an 8-bit string.
+            assert encoding is None
+
+            if linesep is not None:
+                text = (text.replace('\r\n', '\n')
+                            .replace('\r', '\n'))
+                bytes = text.replace('\n', linesep)
+
+        self.write_bytes(bytes, append)
+
+    def lines(self, encoding=None, errors='strict', retain=True):
+        r""" Open this file, read all lines, return them in a list.
+
+        Optional arguments:
+            encoding - The Unicode encoding (or character set) of
+                the file.  The default is None, meaning the content
+                of the file is read as 8-bit characters and returned
+                as a list of (non-Unicode) str objects.
+            errors - How to handle Unicode errors; see help(str.decode)
+                for the options.  Default is 'strict'
+            retain - If true, retain newline characters; but all newline
+                character combinations ('\r', '\n', '\r\n') are
+                translated to '\n'.  If false, newline characters are
+                stripped off.  Default is True.
+
+        This uses 'U' mode in Python 2.3 and later.
+        """
+        if encoding is None and retain:
+            f = self.open(_textmode)
+            try:
+                return f.readlines()
+            finally:
+                f.close()
+        else:
+            return self.text(encoding, errors).splitlines(retain)
+
+    def write_lines(self, lines, encoding=None, errors='strict',
+                    linesep=os.linesep, append=False):
+        r""" Write the given lines of text to this file.
+
+        By default this overwrites any existing file at this path.
+
+        This puts a platform-specific newline sequence on every line.
+        See 'linesep' below.
+
+        lines - A list of strings.
+
+        encoding - A Unicode encoding to use.  This applies only if
+            'lines' contains any Unicode strings.
+
+        errors - How to handle errors in Unicode encoding.  This
+            also applies only to Unicode strings.
+
+        linesep - The desired line-ending.  This line-ending is
+            applied to every line.  If a line already has any
+            standard line ending ('\r', '\n', '\r\n', u'\x85',
+            u'\r\x85', u'\u2028'), that will be stripped off and
+            this will be used instead.  The default is os.linesep,
+            which is platform-dependent ('\r\n' on Windows, '\n' on
+            Unix, etc.)  Specify None to write the lines as-is,
+            like file.writelines().
+
+        Use the keyword argument append=True to append lines to the
+        file.  The default is to overwrite the file.  Warning:
+        When you use this with Unicode data, if the encoding of the
+        existing data in the file is different from the encoding
+        you specify with the encoding= parameter, the result is
+        mixed-encoding data, which can really confuse someone trying
+        to read the file later.
+        """
+        if append:
+            mode = 'ab'
+        else:
+            mode = 'wb'
+        f = self.open(mode)
+        try:
+            for line in lines:
+                isUnicode = isinstance(line, unicode)
+                if linesep is not None:
+                    # Strip off any existing line-end and add the
+                    # specified linesep string.
+                    if isUnicode:
+                        if line[-2:] in (u'\r\n', u'\x0d\x85'):
+                            line = line[:-2]
+                        elif line[-1:] in (u'\r', u'\n',
+                                           u'\x85', u'\u2028'):
+                            line = line[:-1]
+                    else:
+                        if line[-2:] == '\r\n':
+                            line = line[:-2]
+                        elif line[-1:] in ('\r', '\n'):
+                            line = line[:-1]
+                    line += linesep
+                if isUnicode:
+                    if encoding is None:
+                        encoding = sys.getdefaultencoding()
+                    line = line.encode(encoding, errors)
+                f.write(line)
+        finally:
+            f.close()
+
+    def read_md5(self):
+        """ Calculate the md5 hash for this file.
+
+        This reads through the entire file.
+        """
+        f = self.open('rb')
+        try:
+            m = md5.new()
+            while True:
+                d = f.read(8192)
+                if not d:
+                    break
+                m.update(d)
+        finally:
+            f.close()
+        return m.digest()
+
+    # --- Methods for querying the filesystem.
+
+    exists = os.path.exists
+    isdir = os.path.isdir
+    isfile = os.path.isfile
+    islink = os.path.islink
+    ismount = os.path.ismount
+
+    if hasattr(os.path, 'samefile'):
+        samefile = os.path.samefile
+
+    getatime = os.path.getatime
+    atime = property(
+        getatime, None, None,
+        """ Last access time of the file. """)
+
+    getmtime = os.path.getmtime
+    mtime = property(
+        getmtime, None, None,
+        """ Last-modified time of the file. """)
+
+    if hasattr(os.path, 'getctime'):
+        getctime = os.path.getctime
+        ctime = property(
+            getctime, None, None,
+            """ Creation time of the file. """)
+
+    getsize = os.path.getsize
+    size = property(
+        getsize, None, None,
+        """ Size of the file, in bytes. """)
+
+    if hasattr(os, 'access'):
+        def access(self, mode):
+            """ Return true if current user has access to this path.
+
+            mode - One of the constants os.F_OK, os.R_OK, os.W_OK, os.X_OK
+            """
+            return os.access(self, mode)
+
+    def stat(self):
+        """ Perform a stat() system call on this path. """
+        return os.stat(self)
+
+    def lstat(self):
+        """ Like path.stat(), but do not follow symbolic links. """
+        return os.lstat(self)
+
+    def get_owner(self):
+        r""" Return the name of the owner of this file or directory.
+
+        This follows symbolic links.
+
+        On Windows, this returns a name of the form ur'DOMAIN\User Name'.
+        On Windows, a group can own a file or directory.
+        """
+        if os.name == 'nt':
+            if win32security is None:
+                raise Exception("path.owner requires win32all to be installed")
+            desc = win32security.GetFileSecurity(
+                self, win32security.OWNER_SECURITY_INFORMATION)
+            sid = desc.GetSecurityDescriptorOwner()
+            account, domain, typecode = win32security.LookupAccountSid(None, sid)
+            return domain + u'\\' + account
+        else:
+            if pwd is None:
+                raise NotImplementedError("path.owner is not implemented on this platform.")
+            st = self.stat()
+            return pwd.getpwuid(st.st_uid).pw_name
+
+    owner = property(
+        get_owner, None, None,
+        """ Name of the owner of this file or directory. """)
+
+    if hasattr(os, 'statvfs'):
+        def statvfs(self):
+            """ Perform a statvfs() system call on this path. """
+            return os.statvfs(self)
+
+    if hasattr(os, 'pathconf'):
+        def pathconf(self, name):
+            return os.pathconf(self, name)
+
+
+    # --- Modifying operations on files and directories
+
+    def utime(self, times):
+        """ Set the access and modified times of this file. """
+        os.utime(self, times)
+
+    def chmod(self, mode):
+        os.chmod(self, mode)
+
+    if hasattr(os, 'chown'):
+        def chown(self, uid, gid):
+            os.chown(self, uid, gid)
+
+    def rename(self, new):
+        os.rename(self, new)
+
+    def renames(self, new):
+        os.renames(self, new)
+
+
+    # --- Create/delete operations on directories
+
+    def mkdir(self, mode=0777):
+        os.mkdir(self, mode)
+
+    def makedirs(self, mode=0777):
+        os.makedirs(self, mode)
+
+    def rmdir(self):
+        os.rmdir(self)
+
+    def removedirs(self):
+        os.removedirs(self)
+
+
+    # --- Modifying operations on files
+
+    def touch(self):
+        """ Set the access/modified times of this file to the current time.
+        Create the file if it does not exist.
+        """
+        fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0666)
+        os.close(fd)
+        os.utime(self, None)
+
+    def remove(self):
+        os.remove(self)
+
+    def unlink(self):
+        os.unlink(self)
+
+
+    # --- Links
+
+    if hasattr(os, 'link'):
+        def link(self, newpath):
+            """ Create a hard link at 'newpath', pointing to this file. """
+            os.link(self, newpath)
+
+    if hasattr(os, 'symlink'):
+        def symlink(self, newlink):
+            """ Create a symbolic link at 'newlink', pointing here. """
+            os.symlink(self, newlink)
+
+    if hasattr(os, 'readlink'):
+        def readlink(self):
+            """ Return the path to which this symbolic link points.
+
+            The result may be an absolute or a relative path.
+            """
+            return self.__class__(os.readlink(self))
+
+        def readlinkabs(self):
+            """ Return the path to which this symbolic link points.
+
+            The result is always an absolute path.
+            """
+            p = self.readlink()
+            if p.isabs():
+                return p
+            else:
+                return (self.parent / p).abspath()
+
+
+    # --- High-level functions from shutil
+
+    copyfile = shutil.copyfile
+    copymode = shutil.copymode
+    copystat = shutil.copystat
+    copy = shutil.copy
+    copy2 = shutil.copy2
+    copytree = shutil.copytree
+    if hasattr(shutil, 'move'):
+        move = shutil.move
+    rmtree = shutil.rmtree
+
+
+    # --- Special stuff from os
+
+    if hasattr(os, 'chroot'):
+        def chroot(self):
+            os.chroot(self)
+
+    if hasattr(os, 'startfile'):
+        def startfile(self):
+            os.startfile(self)
+
diff --git a/IPython/external/simplegeneric.py b/IPython/external/simplegeneric.py
new file mode 100644
index 0000000..556d6f2
--- /dev/null
+++ b/IPython/external/simplegeneric.py
@@ -0,0 +1,139 @@
+#Name: simplegeneric
+#Version: 0.6
+#Summary: Simple generic functions (similar to Python's own len(), pickle.dump(), etc.)
+#Home-page: http://cheeseshop.python.org/pypi/simplegeneric
+#Author: Phillip J. Eby
+#Author-email: peak@eby-sarna.com
+#License: PSF or ZPL
+
+# This is version 0.6 of Philip J. Eby's simplegeneric module
+# (http://cheeseshop.python.org/pypi/simplegeneric) patched to work
+# with Python 2.3 (which doesn't support assigning to __name__)
+
+__all__ = ["generic"]
+
+
+from types import ClassType, InstanceType
+classtypes = type, ClassType
+
+def generic(func):
+    """Create a simple generic function"""
+
+    _sentinel = object()
+
+    def _by_class(*args, **kw):
+        cls = args[0].__class__
+        for t in type(cls.__name__, (cls,object), {}).__mro__:
+            f = _gbt(t, _sentinel)
+            if f is not _sentinel:
+                return f(*args, **kw)
+        else:
+            return func(*args, **kw)
+
+    _by_type = {object: func, InstanceType: _by_class}
+    _gbt = _by_type.get
+
+    def when_type(t):
+        """Decorator to add a method that will be called for type `t`"""
+        if not isinstance(t, classtypes):
+            raise TypeError(
+                "%r is not a type or class" % (t,)
+            )
+        def decorate(f):
+            if _by_type.setdefault(t,f) is not f:
+                raise TypeError(
+                    "%r already has method for type %r" % (func, t)
+                )
+            return f
+        return decorate
+
+
+
+
+
+
+    _by_object = {}
+    _gbo = _by_object.get
+
+    def when_object(o):
+        """Decorator to add a method that will be called for object `o`"""
+        def decorate(f):
+            if _by_object.setdefault(id(o), (o,f))[1] is not f:
+                raise TypeError(
+                    "%r already has method for object %r" % (func, o)
+                )
+            return f
+        return decorate
+
+
+    def dispatch(*args, **kw):
+        f = _gbo(id(args[0]), _sentinel)
+        if f is _sentinel:
+            for t in type(args[0]).__mro__:
+                f = _gbt(t, _sentinel)
+                if f is not _sentinel:
+                    return f(*args, **kw)
+            else:
+                return func(*args, **kw)
+        else:
+            return f[1](*args, **kw)
+
+    try:
+        dispatch.__name__       = func.__name__
+    except TypeError:
+        pass
+    dispatch.__dict__       = func.__dict__.copy()
+    dispatch.__doc__        = func.__doc__
+    dispatch.__module__     = func.__module__
+
+    dispatch.when_type = when_type
+    dispatch.when_object = when_object
+    dispatch.default = func
+    dispatch.has_object = lambda o: id(o) in _by_object
+    dispatch.has_type   = lambda t: t in _by_type
+    return dispatch
+
+
+
+
+def test_suite():
+    import doctest
+    return doctest.DocFileSuite(
+        'README.txt',
+        optionflags=doctest.ELLIPSIS|doctest.REPORT_ONLY_FIRST_FAILURE,
+    )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/IPython/generics.py b/IPython/generics.py
new file mode 100644
index 0000000..37acadc
--- /dev/null
+++ b/IPython/generics.py
@@ -0,0 +1,55 @@
+from IPython.ipapi import TryNext
+from IPython.external.simplegeneric import generic
+
+''' 'Generic' functions for extending IPython
+
+See http://cheeseshop.python.org/pypi/simplegeneric
+
+Here's an example from genutils.py:
+
+    def print_lsstring(arg):
+        """ Prettier (non-repr-like) and more informative printer for LSString """
+        print "LSString (.p, .n, .l, .s available). Value:"
+        print arg
+        
+    print_lsstring = result_display.when_type(LSString)(print_lsstring)
+
+(Yes, the nasty syntax is for python 2.3 compatibility. Your own extensions
+can use the niftier decorator syntax)
+
+'''
+
+def result_display(result):
+    """ print the result of computation """
+    raise TryNext
+
+result_display = generic(result_display)
+
+def inspect_object(obj):
+    """ Called when you do obj? """
+    raise TryNext
+inspect_object = generic(inspect_object)
+
+def complete_object(obj, prev_completions):
+    """ Custom completer dispatching for python objects
+    
+    obj is the object itself.
+    prev_completions is the list of attributes discovered so far.
+    
+    This should return the list of attributes in obj. If you only wish to
+    add to the attributes already discovered normally, return
+    own_attrs + prev_completions.
+    """
+  
+    raise TryNext
+complete_object = generic(complete_object)
+
+#import os
+#def my_demo_complete_object(obj, prev_completions):
+#    """ Demo completer that adds 'foobar' to the completions suggested
+#    for any object that has attribute (path), e.g. 'os'"""
+#    if hasattr(obj,'path'):
+#        return prev_completions + ['foobar']
+#    raise TryNext
+#
+#my_demo_complete_object = complete_object.when_type(type(os))(my_demo_complete_object)
diff --git a/IPython/genutils.py b/IPython/genutils.py
new file mode 100644
index 0000000..f52636f
--- /dev/null
+++ b/IPython/genutils.py
@@ -0,0 +1,2008 @@
+# -*- coding: utf-8 -*-
+"""
+General purpose utilities.
+
+This is a grab-bag of stuff I find useful in most programs I write. Some of
+these things are also convenient when working at the command line.
+
+$Id: genutils.py 2998 2008-01-31 10:06:04Z vivainio $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+#****************************************************************************
+# required modules from the Python standard library
+import __main__
+import commands
+import doctest
+import os
+import re
+import shlex
+import shutil
+import sys
+import tempfile
+import time
+import types
+import warnings
+
+# Other IPython utilities
+import IPython
+from IPython.Itpl import Itpl,itpl,printpl
+from IPython import DPyGetOpt, platutils
+from IPython.generics import result_display
+import IPython.ipapi
+from IPython.external.path import path
+if os.name == "nt":
+    from IPython.winconsole import get_console_size
+
+try:
+    set
+except:
+    from sets import Set as set
+
+
+#****************************************************************************
+# Exceptions
+class Error(Exception):
+    """Base class for exceptions in this module."""
+    pass
+
+#----------------------------------------------------------------------------
+class IOStream:
+    def __init__(self,stream,fallback):
+        if not hasattr(stream,'write') or not hasattr(stream,'flush'):
+            stream = fallback
+        self.stream = stream
+        self._swrite = stream.write
+        self.flush = stream.flush
+
+    def write(self,data):
+        try:
+            self._swrite(data)
+        except:
+            try:
+                # print handles some unicode issues which may trip a plain
+                # write() call.  Attempt to emulate write() by using a
+                # trailing comma
+                print >> self.stream, data,
+            except:
+                # if we get here, something is seriously broken.
+                print >> sys.stderr, \
+                      'ERROR - failed to write data to stream:', self.stream
+
+    def close(self):
+        pass
+                
+        
+class IOTerm:
+    """ Term holds the file or file-like objects for handling I/O operations.
+
+    These are normally just sys.stdin, sys.stdout and sys.stderr but for
+    Windows they can can replaced to allow editing the strings before they are
+    displayed."""
+
+    # In the future, having IPython channel all its I/O operations through
+    # this class will make it easier to embed it into other environments which
+    # are not a normal terminal (such as a GUI-based shell)
+    def __init__(self,cin=None,cout=None,cerr=None):
+        self.cin  = IOStream(cin,sys.stdin)
+        self.cout = IOStream(cout,sys.stdout)
+        self.cerr = IOStream(cerr,sys.stderr)
+        
+# Global variable to be used for all I/O
+Term = IOTerm()
+
+import IPython.rlineimpl as readline
+# Remake Term to use the readline i/o facilities
+if sys.platform == 'win32' and readline.have_readline:
+    
+    Term = IOTerm(cout=readline._outputfile,cerr=readline._outputfile)
+    
+
+#****************************************************************************
+# Generic warning/error printer, used by everything else
+def warn(msg,level=2,exit_val=1):
+    """Standard warning printer. Gives formatting consistency.
+
+    Output is sent to Term.cerr (sys.stderr by default).
+    
+    Options:
+    
+    -level(2): allows finer control:
+      0 -> Do nothing, dummy function.
+      1 -> Print message.
+      2 -> Print 'WARNING:' + message. (Default level).
+      3 -> Print 'ERROR:' + message.
+      4 -> Print 'FATAL ERROR:' + message and trigger a sys.exit(exit_val).
+
+    -exit_val (1): exit value returned by sys.exit() for a level 4
+    warning. Ignored for all other levels."""
+    
+    if level>0:
+        header = ['','','WARNING: ','ERROR: ','FATAL ERROR: ']
+        print >> Term.cerr, '%s%s' % (header[level],msg)
+        if level == 4:
+            print >> Term.cerr,'Exiting.\n'
+            sys.exit(exit_val)
+
+def info(msg):
+    """Equivalent to warn(msg,level=1)."""
+
+    warn(msg,level=1)
+
+def error(msg):
+    """Equivalent to warn(msg,level=3)."""
+
+    warn(msg,level=3)
+
+def fatal(msg,exit_val=1):
+    """Equivalent to warn(msg,exit_val=exit_val,level=4)."""
+
+    warn(msg,exit_val=exit_val,level=4)
+
+#---------------------------------------------------------------------------
+# Debugging routines
+# 
+def debugx(expr,pre_msg=''):
+    """Print the value of an expression from the caller's frame.
+    
+    Takes an expression, evaluates it in the caller's frame and prints both
+    the given expression and the resulting value (as well as a debug mark
+    indicating the name of the calling function.  The input must be of a form
+    suitable for eval().
+
+    An optional message can be passed, which will be prepended to the printed
+    expr->value pair."""
+    
+    cf = sys._getframe(1)
+    print '[DBG:%s] %s%s -> %r' % (cf.f_code.co_name,pre_msg,expr,
+                                   eval(expr,cf.f_globals,cf.f_locals))
+
+# deactivate it by uncommenting the following line, which makes it a no-op
+#def debugx(expr,pre_msg=''): pass
+
+#----------------------------------------------------------------------------
+StringTypes = types.StringTypes
+
+# Basic timing functionality
+
+# If possible (Unix), use the resource module instead of time.clock()
+try:
+    import resource
+    def clocku():
+        """clocku() -> floating point number
+
+        Return the *USER* CPU time in seconds since the start of the process.
+        This is done via a call to resource.getrusage, so it avoids the
+        wraparound problems in time.clock()."""
+        
+        return resource.getrusage(resource.RUSAGE_SELF)[0]
+    
+    def clocks():
+        """clocks() -> floating point number
+
+        Return the *SYSTEM* CPU time in seconds since the start of the process.
+        This is done via a call to resource.getrusage, so it avoids the
+        wraparound problems in time.clock()."""
+        
+        return resource.getrusage(resource.RUSAGE_SELF)[1]
+    
+    def clock():
+        """clock() -> floating point number
+
+        Return the *TOTAL USER+SYSTEM* CPU time in seconds since the start of
+        the process.  This is done via a call to resource.getrusage, so it
+        avoids the wraparound problems in time.clock()."""
+
+        u,s = resource.getrusage(resource.RUSAGE_SELF)[:2] 
+        return u+s
+    
+    def clock2():
+        """clock2() -> (t_user,t_system)
+
+        Similar to clock(), but return a tuple of user/system times."""
+        return resource.getrusage(resource.RUSAGE_SELF)[:2]
+
+except ImportError:
+    # There is no distinction of user/system time under windows, so we just use
+    # time.clock() for everything...
+    clocku = clocks = clock = time.clock
+    def clock2():
+        """Under windows, system CPU time can't be measured.
+
+        This just returns clock() and zero."""
+        return time.clock(),0.0
+
+def timings_out(reps,func,*args,**kw):
+    """timings_out(reps,func,*args,**kw) -> (t_total,t_per_call,output)
+
+    Execute a function reps times, return a tuple with the elapsed total
+    CPU time in seconds, the time per call and the function's output.
+
+    Under Unix, the return value is the sum of user+system time consumed by
+    the process, computed via the resource module.  This prevents problems
+    related to the wraparound effect which the time.clock() function has.
+    
+    Under Windows the return value is in wall clock seconds. See the
+    documentation for the time module for more details."""
+
+    reps = int(reps)
+    assert reps >=1, 'reps must be >= 1'
+    if reps==1:
+        start = clock()
+        out = func(*args,**kw)
+        tot_time = clock()-start
+    else:
+        rng = xrange(reps-1) # the last time is executed separately to store output
+        start = clock()
+        for dummy in rng: func(*args,**kw)
+        out = func(*args,**kw)  # one last time
+        tot_time = clock()-start
+    av_time = tot_time / reps
+    return tot_time,av_time,out
+
+def timings(reps,func,*args,**kw):
+    """timings(reps,func,*args,**kw) -> (t_total,t_per_call)
+
+    Execute a function reps times, return a tuple with the elapsed total CPU
+    time in seconds and the time per call. These are just the first two values
+    in timings_out()."""
+
+    return timings_out(reps,func,*args,**kw)[0:2]
+
+def timing(func,*args,**kw):
+    """timing(func,*args,**kw) -> t_total
+
+    Execute a function once, return the elapsed total CPU time in
+    seconds. This is just the first value in timings_out()."""
+
+    return timings_out(1,func,*args,**kw)[0]
+
+#****************************************************************************
+# file and system
+
+def arg_split(s,posix=False):
+    """Split a command line's arguments in a shell-like manner.
+
+    This is a modified version of the standard library's shlex.split()
+    function, but with a default of posix=False for splitting, so that quotes
+    in inputs are respected."""
+
+    # XXX - there may be unicode-related problems here!!!  I'm not sure that
+    # shlex is truly unicode-safe, so it might be necessary to do
+    #
+    # s = s.encode(sys.stdin.encoding)
+    #
+    # first, to ensure that shlex gets a normal string.  Input from anyone who
+    # knows more about unicode and shlex than I would be good to have here...
+    lex = shlex.shlex(s, posix=posix)
+    lex.whitespace_split = True
+    return list(lex)
+
+def system(cmd,verbose=0,debug=0,header=''):
+    """Execute a system command, return its exit status.
+
+    Options:
+
+    - verbose (0): print the command to be executed.
+    
+    - debug (0): only print, do not actually execute.
+
+    - header (''): Header to print on screen prior to the executed command (it
+    is only prepended to the command, no newlines are added).
+
+    Note: a stateful version of this function is available through the
+    SystemExec class."""
+
+    stat = 0
+    if verbose or debug: print header+cmd
+    sys.stdout.flush()
+    if not debug: stat = os.system(cmd)
+    return stat
+
+def abbrev_cwd():
+    """ Return abbreviated version of cwd, e.g. d:mydir """
+    cwd = os.getcwd().replace('\\','/')
+    drivepart = ''
+    tail = cwd
+    if sys.platform == 'win32':
+        if len(cwd) < 4:
+            return cwd
+        drivepart,tail = os.path.splitdrive(cwd)
+    
+
+    parts = tail.split('/')    
+    if len(parts) > 2:
+        tail = '/'.join(parts[-2:])
+        
+    return (drivepart + (
+        cwd == '/' and '/' or tail))
+    
+
+# This function is used by ipython in a lot of places to make system calls.
+# We need it to be slightly different under win32, due to the vagaries of
+# 'network shares'.  A win32 override is below.
+
+def shell(cmd,verbose=0,debug=0,header=''):
+    """Execute a command in the system shell, always return None.
+
+    Options:
+
+    - verbose (0): print the command to be executed.
+    
+    - debug (0): only print, do not actually execute.
+
+    - header (''): Header to print on screen prior to the executed command (it
+    is only prepended to the command, no newlines are added).
+
+    Note: this is similar to genutils.system(), but it returns None so it can
+    be conveniently used in interactive loops without getting the return value
+    (typically 0) printed many times."""
+
+    stat = 0
+    if verbose or debug: print header+cmd
+    # flush stdout so we don't mangle python's buffering
+    sys.stdout.flush()
+    
+    if not debug:
+        platutils.set_term_title("IPy " + cmd)
+        os.system(cmd)
+        platutils.set_term_title("IPy " + abbrev_cwd())
+
+# override shell() for win32 to deal with network shares
+if os.name in ('nt','dos'):
+
+    shell_ori = shell
+
+    def shell(cmd,verbose=0,debug=0,header=''):
+        if os.getcwd().startswith(r"\\"):
+            path = os.getcwd()
+            # change to c drive (cannot be on UNC-share when issuing os.system,
+            # as cmd.exe cannot handle UNC addresses)
+            os.chdir("c:")
+            # issue pushd to the UNC-share and then run the command
+            try:
+                shell_ori('"pushd %s&&"'%path+cmd,verbose,debug,header)
+            finally:
+                os.chdir(path)
+        else:
+            shell_ori(cmd,verbose,debug,header)
+
+    shell.__doc__ = shell_ori.__doc__
+
+def getoutput(cmd,verbose=0,debug=0,header='',split=0):
+    """Dummy substitute for perl's backquotes.
+
+    Executes a command and returns the output.
+
+    Accepts the same arguments as system(), plus:
+
+    - split(0): if true, the output is returned as a list split on newlines.
+
+    Note: a stateful version of this function is available through the
+    SystemExec class.
+    
+    This is pretty much deprecated and rarely used, 
+    genutils.getoutputerror may be what you need.
+    
+    """
+
+    if verbose or debug: print header+cmd
+    if not debug:
+        output = os.popen(cmd).read()
+        # stipping last \n is here for backwards compat.
+        if output.endswith('\n'):
+            output = output[:-1]
+        if split:
+            return output.split('\n')
+        else:
+            return output
+
+def getoutputerror(cmd,verbose=0,debug=0,header='',split=0):
+    """Return (standard output,standard error) of executing cmd in a shell.
+
+    Accepts the same arguments as system(), plus:
+
+    - split(0): if true, each of stdout/err is returned as a list split on
+    newlines.
+
+    Note: a stateful version of this function is available through the
+    SystemExec class."""
+
+    if verbose or debug: print header+cmd
+    if not cmd:
+        if split:
+            return [],[]
+        else:
+            return '',''
+    if not debug:
+        pin,pout,perr = os.popen3(cmd)
+        tout = pout.read().rstrip()
+        terr = perr.read().rstrip()
+        pin.close()
+        pout.close()
+        perr.close()
+        if split:
+            return tout.split('\n'),terr.split('\n')
+        else:
+            return tout,terr
+
+# for compatibility with older naming conventions
+xsys = system
+bq = getoutput
+
+class SystemExec:
+    """Access the system and getoutput functions through a stateful interface.
+
+    Note: here we refer to the system and getoutput functions from this
+    library, not the ones from the standard python library.
+    
+    This class offers the system and getoutput functions as methods, but the
+    verbose, debug and header parameters can be set for the instance (at
+    creation time or later) so that they don't need to be specified on each
+    call.
+
+    For efficiency reasons, there's no way to override the parameters on a
+    per-call basis other than by setting instance attributes. If you need
+    local overrides, it's best to directly call system() or getoutput().
+
+    The following names are provided as alternate options:
+     - xsys: alias to system
+     - bq: alias to getoutput
+
+    An instance can then be created as:
+     >>> sysexec = SystemExec(verbose=1,debug=0,header='Calling: ')
+
+    And used as:
+     >>> sysexec.xsys('pwd')
+     >>> dirlist = sysexec.bq('ls -l')
+    """
+    
+    def __init__(self,verbose=0,debug=0,header='',split=0):
+        """Specify the instance's values for verbose, debug and header."""
+        setattr_list(self,'verbose debug header split')
+
+    def system(self,cmd):
+        """Stateful interface to system(), with the same keyword parameters."""
+
+        system(cmd,self.verbose,self.debug,self.header)
+
+    def shell(self,cmd):
+        """Stateful interface to shell(), with the same keyword parameters."""
+
+        shell(cmd,self.verbose,self.debug,self.header)
+
+    xsys = system  # alias
+
+    def getoutput(self,cmd):
+        """Stateful interface to getoutput()."""
+
+        return getoutput(cmd,self.verbose,self.debug,self.header,self.split)
+
+    def getoutputerror(self,cmd):
+        """Stateful interface to getoutputerror()."""
+
+        return getoutputerror(cmd,self.verbose,self.debug,self.header,self.split)
+
+    bq = getoutput  # alias
+
+#-----------------------------------------------------------------------------
+def mutex_opts(dict,ex_op):
+    """Check for presence of mutually exclusive keys in a dict.
+
+    Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...]"""
+    for op1,op2 in ex_op:
+        if op1 in dict and op2 in dict:
+            raise ValueError,'\n*** ERROR in Arguments *** '\
+                  'Options '+op1+' and '+op2+' are mutually exclusive.'
+
+#-----------------------------------------------------------------------------
+def get_py_filename(name):
+    """Return a valid python filename in the current directory.
+
+    If the given name is not a file, it adds '.py' and searches again.
+    Raises IOError with an informative message if the file isn't found."""
+
+    name = os.path.expanduser(name)
+    if not os.path.isfile(name) and not name.endswith('.py'):
+        name += '.py'
+    if os.path.isfile(name):
+        return name
+    else:
+        raise IOError,'File `%s` not found.' % name
+
+#-----------------------------------------------------------------------------
+def filefind(fname,alt_dirs = None):
+    """Return the given filename either in the current directory, if it
+    exists, or in a specified list of directories.
+
+    ~ expansion is done on all file and directory names.
+
+    Upon an unsuccessful search, raise an IOError exception."""
+
+    if alt_dirs is None:
+        try:
+            alt_dirs = get_home_dir()
+        except HomeDirError:
+            alt_dirs = os.getcwd()
+    search = [fname] + list_strings(alt_dirs)
+    search = map(os.path.expanduser,search)
+    #print 'search list for',fname,'list:',search  # dbg
+    fname = search[0]
+    if os.path.isfile(fname):
+        return fname
+    for direc in search[1:]:
+        testname = os.path.join(direc,fname)
+        #print 'testname',testname  # dbg
+        if os.path.isfile(testname):
+            return testname
+    raise IOError,'File' + `fname` + \
+          ' not found in current or supplied directories:' + `alt_dirs`
+
+#----------------------------------------------------------------------------
+def file_read(filename):
+    """Read a file and close it.  Returns the file source."""
+    fobj = open(filename,'r');
+    source = fobj.read();
+    fobj.close()
+    return source
+
+def file_readlines(filename):
+    """Read a file and close it.  Returns the file source using readlines()."""
+    fobj = open(filename,'r');
+    lines = fobj.readlines();
+    fobj.close()
+    return lines
+
+#----------------------------------------------------------------------------
+def target_outdated(target,deps):
+    """Determine whether a target is out of date.
+
+    target_outdated(target,deps) -> 1/0
+
+    deps: list of filenames which MUST exist.
+    target: single filename which may or may not exist.
+
+    If target doesn't exist or is older than any file listed in deps, return
+    true, otherwise return false.
+    """
+    try:
+        target_time = os.path.getmtime(target)
+    except os.error:
+        return 1
+    for dep in deps:
+        dep_time = os.path.getmtime(dep)
+        if dep_time > target_time:
+            #print "For target",target,"Dep failed:",dep # dbg
+            #print "times (dep,tar):",dep_time,target_time # dbg
+            return 1
+    return 0
+
+#-----------------------------------------------------------------------------
+def target_update(target,deps,cmd):
+    """Update a target with a given command given a list of dependencies.
+
+    target_update(target,deps,cmd) -> runs cmd if target is outdated.
+
+    This is just a wrapper around target_outdated() which calls the given
+    command if target is outdated."""
+
+    if target_outdated(target,deps):
+        xsys(cmd)
+
+#----------------------------------------------------------------------------
+def unquote_ends(istr):
+    """Remove a single pair of quotes from the endpoints of a string."""
+
+    if not istr:
+        return istr
+    if (istr[0]=="'" and istr[-1]=="'") or \
+       (istr[0]=='"' and istr[-1]=='"'):
+        return istr[1:-1]
+    else:
+        return istr
+
+#----------------------------------------------------------------------------
+def process_cmdline(argv,names=[],defaults={},usage=''):
+    """ Process command-line options and arguments.
+
+    Arguments:
+
+    - argv: list of arguments, typically sys.argv.
+    
+    - names: list of option names. See DPyGetOpt docs for details on options
+    syntax.
+
+    - defaults: dict of default values.
+
+    - usage: optional usage notice to print if a wrong argument is passed.
+
+    Return a dict of options and a list of free arguments."""
+
+    getopt = DPyGetOpt.DPyGetOpt()
+    getopt.setIgnoreCase(0)
+    getopt.parseConfiguration(names)
+
+    try:
+        getopt.processArguments(argv)
+    except DPyGetOpt.ArgumentError, exc:
+        print usage
+        warn('"%s"' % exc,level=4)
+
+    defaults.update(getopt.optionValues)
+    args = getopt.freeValues
+    
+    return defaults,args
+
+#----------------------------------------------------------------------------
+def optstr2types(ostr):
+    """Convert a string of option names to a dict of type mappings.
+
+    optstr2types(str) -> {None:'string_opts',int:'int_opts',float:'float_opts'}
+
+    This is used to get the types of all the options in a string formatted
+    with the conventions of DPyGetOpt. The 'type' None is used for options
+    which are strings (they need no further conversion). This function's main
+    use is to get a typemap for use with read_dict().
+    """
+
+    typeconv = {None:'',int:'',float:''}
+    typemap = {'s':None,'i':int,'f':float}
+    opt_re = re.compile(r'([\w]*)([^:=]*:?=?)([sif]?)')
+
+    for w in ostr.split():
+        oname,alias,otype = opt_re.match(w).groups()
+        if otype == '' or alias == '!':   # simple switches are integers too
+            otype = 'i'
+        typeconv[typemap[otype]] += oname + ' '
+    return typeconv
+
+#----------------------------------------------------------------------------
+def read_dict(filename,type_conv=None,**opt):
+
+    """Read a dictionary of key=value pairs from an input file, optionally
+    performing conversions on the resulting values.
+
+    read_dict(filename,type_conv,**opt) -> dict
+
+    Only one value per line is accepted, the format should be
+     # optional comments are ignored
+     key value\n
+
+    Args:
+
+      - type_conv: A dictionary specifying which keys need to be converted to
+      which types. By default all keys are read as strings. This dictionary
+      should have as its keys valid conversion functions for strings
+      (int,long,float,complex, or your own).  The value for each key
+      (converter) should be a whitespace separated string containing the names
+      of all the entries in the file to be converted using that function. For
+      keys to be left alone, use None as the conversion function (only needed
+      with purge=1, see below).
+
+      - opt: dictionary with extra options as below (default in parens)
+
+        purge(0): if set to 1, all keys *not* listed in type_conv are purged out
+        of the dictionary to be returned. If purge is going to be used, the
+        set of keys to be left as strings also has to be explicitly specified
+        using the (non-existent) conversion function None.
+
+        fs(None): field separator. This is the key/value separator to be used
+        when parsing the file. The None default means any whitespace [behavior
+        of string.split()].
+
+        strip(0): if 1, strip string values of leading/trailinig whitespace.
+
+        warn(1): warning level if requested keys are not found in file.
+          - 0: silently ignore.
+          - 1: inform but proceed.
+          - 2: raise KeyError exception.
+
+        no_empty(0): if 1, remove keys with whitespace strings as a value.
+
+        unique([]): list of keys (or space separated string) which can't be
+        repeated. If one such key is found in the file, each new instance
+        overwrites the previous one. For keys not listed here, the behavior is
+        to make a list of all appearances.
+
+    Example:
+    If the input file test.ini has:
+      i 3
+      x 4.5
+      y 5.5
+      s hi ho
+    Then:
+
+    >>> type_conv={int:'i',float:'x',None:'s'}
+    >>> read_dict('test.ini')
+    {'i': '3', 's': 'hi ho', 'x': '4.5', 'y': '5.5'}
+    >>> read_dict('test.ini',type_conv)
+    {'i': 3, 's': 'hi ho', 'x': 4.5, 'y': '5.5'}
+    >>> read_dict('test.ini',type_conv,purge=1)
+    {'i': 3, 's': 'hi ho', 'x': 4.5}
+    """
+
+    # starting config
+    opt.setdefault('purge',0)
+    opt.setdefault('fs',None)  # field sep defaults to any whitespace
+    opt.setdefault('strip',0)
+    opt.setdefault('warn',1)
+    opt.setdefault('no_empty',0)
+    opt.setdefault('unique','')
+    if type(opt['unique']) in StringTypes:
+        unique_keys = qw(opt['unique'])
+    elif type(opt['unique']) in (types.TupleType,types.ListType):
+        unique_keys = opt['unique']
+    else:
+        raise ValueError, 'Unique keys must be given as a string, List or Tuple'
+
+    dict = {}
+    # first read in table of values as strings
+    file = open(filename,'r')
+    for line in file.readlines():
+        line = line.strip()
+        if len(line) and line[0]=='#': continue
+        if len(line)>0:
+            lsplit = line.split(opt['fs'],1)
+            try:
+                key,val = lsplit
+            except ValueError:
+                key,val = lsplit[0],''
+            key = key.strip()
+            if opt['strip']: val = val.strip()
+            if val == "''" or val == '""': val = ''
+            if opt['no_empty'] and (val=='' or val.isspace()):
+                continue
+            # if a key is found more than once in the file, build a list
+            # unless it's in the 'unique' list. In that case, last found in file
+            # takes precedence. User beware.
+            try:
+                if dict[key] and key in unique_keys:
+                    dict[key] = val
+                elif type(dict[key]) is types.ListType:
+                    dict[key].append(val)
+                else:
+                    dict[key] = [dict[key],val]
+            except KeyError:
+                dict[key] = val
+    # purge if requested
+    if opt['purge']:
+        accepted_keys = qwflat(type_conv.values())
+        for key in dict.keys():
+            if key in accepted_keys: continue
+            del(dict[key])
+    # now convert if requested
+    if type_conv==None: return dict
+    conversions = type_conv.keys()
+    try: conversions.remove(None)
+    except: pass
+    for convert in conversions:
+        for val in qw(type_conv[convert]):
+            try:
+                dict[val] = convert(dict[val])
+            except KeyError,e:
+                if opt['warn'] == 0:
+                    pass
+                elif opt['warn'] == 1:
+                    print >>sys.stderr, 'Warning: key',val,\
+                          'not found in file',filename
+                elif opt['warn'] == 2:
+                    raise KeyError,e
+                else:
+                    raise ValueError,'Warning level must be 0,1 or 2'
+
+    return dict
+
+#----------------------------------------------------------------------------
+def flag_calls(func):
+    """Wrap a function to detect and flag when it gets called.
+
+    This is a decorator which takes a function and wraps it in a function with
+    a 'called' attribute. wrapper.called is initialized to False.
+
+    The wrapper.called attribute is set to False right before each call to the
+    wrapped function, so if the call fails it remains False.  After the call
+    completes, wrapper.called is set to True and the output is returned.
+
+    Testing for truth in wrapper.called allows you to determine if a call to
+    func() was attempted and succeeded."""
+    
+    def wrapper(*args,**kw):
+        wrapper.called = False
+        out = func(*args,**kw)
+        wrapper.called = True
+        return out
+
+    wrapper.called = False
+    wrapper.__doc__ = func.__doc__
+    return wrapper
+
+#----------------------------------------------------------------------------
+def dhook_wrap(func,*a,**k):
+    """Wrap a function call in a sys.displayhook controller.
+
+    Returns a wrapper around func which calls func, with all its arguments and
+    keywords unmodified, using the default sys.displayhook.  Since IPython
+    modifies sys.displayhook, it breaks the behavior of certain systems that
+    rely on the default behavior, notably doctest.
+    """
+
+    def f(*a,**k):
+    
+        dhook_s = sys.displayhook
+        sys.displayhook = sys.__displayhook__
+        try:
+            out = func(*a,**k)
+        finally:
+            sys.displayhook = dhook_s
+
+        return out
+
+    f.__doc__ = func.__doc__
+    return f
+
+#----------------------------------------------------------------------------
+def doctest_reload():
+    """Properly reload doctest to reuse it interactively.
+
+    This routine:
+
+      - reloads doctest
+      
+      - resets its global 'master' attribute to None, so that multiple uses of
+      the module interactively don't produce cumulative reports.
+    
+      - Monkeypatches its core test runner method to protect it from IPython's
+      modified displayhook.  Doctest expects the default displayhook behavior
+      deep down, so our modification breaks it completely.  For this reason, a
+      hard monkeypatch seems like a reasonable solution rather than asking
+      users to manually use a different doctest runner when under IPython."""
+
+    import doctest
+    reload(doctest)
+    doctest.master=None
+
+    try:
+        doctest.DocTestRunner
+    except AttributeError:
+        # This is only for python 2.3 compatibility, remove once we move to
+        # 2.4 only.
+        pass
+    else:
+        doctest.DocTestRunner.run = dhook_wrap(doctest.DocTestRunner.run)
+
+#----------------------------------------------------------------------------
+class HomeDirError(Error):
+    pass
+
+def get_home_dir():
+    """Return the closest possible equivalent to a 'home' directory.
+
+    We first try $HOME.  Absent that, on NT it's $HOMEDRIVE\$HOMEPATH.
+
+    Currently only Posix and NT are implemented, a HomeDirError exception is
+    raised for all other OSes. """
+
+    isdir = os.path.isdir
+    env = os.environ
+    
+    # first, check py2exe distribution root directory for _ipython.
+    # This overrides all. Normally does not exist.
+    
+    if '\\library.zip\\' in IPython.__file__.lower():
+        root, rest = IPython.__file__.lower().split('library.zip')
+        if isdir(root + '_ipython'):
+            os.environ["IPYKITROOT"] = root.rstrip('\\')
+            return root
+    
+    try:
+        homedir = env['HOME']
+        if not isdir(homedir):
+            # in case a user stuck some string which does NOT resolve to a
+            # valid path, it's as good as if we hadn't foud it
+            raise KeyError
+        return homedir
+    except KeyError:
+        if os.name == 'posix':
+            raise HomeDirError,'undefined $HOME, IPython can not proceed.'
+        elif os.name == 'nt':
+            # For some strange reason, win9x returns 'nt' for os.name.
+            try:
+                homedir = os.path.join(env['HOMEDRIVE'],env['HOMEPATH'])
+                if not isdir(homedir):
+                    homedir = os.path.join(env['USERPROFILE'])
+                    if not isdir(homedir):
+                        raise HomeDirError
+                return homedir
+            except:
+                try:
+                    # Use the registry to get the 'My Documents' folder.
+                    import _winreg as wreg
+                    key = wreg.OpenKey(wreg.HKEY_CURRENT_USER,
+                                       "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
+                    homedir = wreg.QueryValueEx(key,'Personal')[0]
+                    key.Close()
+                    if not isdir(homedir):
+                        e = ('Invalid "Personal" folder registry key '
+                             'typically "My Documents".\n'
+                             'Value: %s\n'
+                             'This is not a valid directory on your system.' %
+                             homedir)
+                        raise HomeDirError(e)
+                    return homedir
+                except HomeDirError:
+                    raise
+                except:
+                    return 'C:\\'
+        elif os.name == 'dos':
+            # Desperate, may do absurd things in classic MacOS. May work under DOS.
+            return 'C:\\'
+        else:
+            raise HomeDirError,'support for your operating system not implemented.'
+
+#****************************************************************************
+# strings and text
+
+class LSString(str):
+    """String derivative with a special access attributes.
+
+    These are normal strings, but with the special attributes:
+
+        .l (or .list) : value as list (split on newlines).
+        .n (or .nlstr): original value (the string itself).
+        .s (or .spstr): value as whitespace-separated string.
+        .p (or .paths): list of path objects
+        
+    Any values which require transformations are computed only once and
+    cached.
+
+    Such strings are very useful to efficiently interact with the shell, which
+    typically only understands whitespace-separated options for commands."""
+
+    def get_list(self):
+        try:
+            return self.__list
+        except AttributeError:
+            self.__list = self.split('\n')
+            return self.__list
+
+    l = list = property(get_list)
+
+    def get_spstr(self):
+        try:
+            return self.__spstr
+        except AttributeError:
+            self.__spstr = self.replace('\n',' ')
+            return self.__spstr
+
+    s = spstr = property(get_spstr)
+
+    def get_nlstr(self):
+        return self
+
+    n = nlstr = property(get_nlstr)
+
+    def get_paths(self):
+        try:
+            return self.__paths
+        except AttributeError:
+            self.__paths = [path(p) for p in self.split('\n') if os.path.exists(p)]
+            return self.__paths
+    
+    p = paths = property(get_paths)
+
+def print_lsstring(arg):
+    """ Prettier (non-repr-like) and more informative printer for LSString """
+    print "LSString (.p, .n, .l, .s available). Value:"
+    print arg
+    
+print_lsstring = result_display.when_type(LSString)(print_lsstring)
+
+#----------------------------------------------------------------------------
+class SList(list):
+    """List derivative with a special access attributes.
+
+    These are normal lists, but with the special attributes:
+
+        .l (or .list) : value as list (the list itself).
+        .n (or .nlstr): value as a string, joined on newlines.
+        .s (or .spstr): value as a string, joined on spaces.
+        .p (or .paths): list of path objects
+        
+    Any values which require transformations are computed only once and
+    cached."""
+
+    def get_list(self):
+        return self
+
+    l = list = property(get_list)
+
+    def get_spstr(self):
+        try:
+            return self.__spstr
+        except AttributeError:
+            self.__spstr = ' '.join(self)
+            return self.__spstr
+
+    s = spstr = property(get_spstr)
+
+    def get_nlstr(self):
+        try:
+            return self.__nlstr
+        except AttributeError:
+            self.__nlstr = '\n'.join(self)
+            return self.__nlstr
+
+    n = nlstr = property(get_nlstr)
+    
+    def get_paths(self):
+        try:
+            return self.__paths
+        except AttributeError:
+            self.__paths = [path(p) for p in self if os.path.exists(p)]
+            return self.__paths
+    
+    p = paths = property(get_paths)
+
+    def grep(self, pattern, prune = False):
+        """ Return all strings matching 'pattern' (a regex or callable) 
+        
+        This is case-insensitive. If prune is true, return all items
+        NOT matching the pattern.
+        
+        Examples::
+        
+            a.grep( lambda x: x.startswith('C') )
+            a.grep('Cha.*log', prune=1)
+        """
+        if isinstance(pattern, basestring):
+            pred = lambda x : re.search(pattern, x, re.IGNORECASE)
+        else:
+            pred = pattern
+        if not prune:
+            return SList([el for el in self if pred(el)])
+        else:
+            return SList([el for el in self if not pred(el)])
+    def fields(self, *fields):
+        """ Collect whitespace-separated fields from string list
+        
+        Allows quick awk-like usage of string lists.
+        
+        Example data (in var a, created by 'a = !ls -l')::
+            -rwxrwxrwx  1 ville None      18 Dec 14  2006 ChangeLog
+            drwxrwxrwx+ 6 ville None       0 Oct 24 18:05 IPython        
+        
+        a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
+        a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
+        (note the joining by space).
+        
+        IndexErrors are ignored.
+        
+        Without args, fields() just split()'s the strings.
+        """
+        if len(fields) == 0:
+            return [el.split() for el in self]
+        
+        res = SList()
+        for el in [f.split() for f in self]:
+            lineparts = []
+
+            for fd in fields:
+                try:
+                    lineparts.append(el[fd])
+                except IndexError:
+                    pass
+            if lineparts:
+                res.append(" ".join(lineparts))
+            
+        return res        
+                
+            
+            
+        
+
+def print_slist(arg):
+    """ Prettier (non-repr-like) and more informative printer for SList """
+    print "SList (.p, .n, .l, .s, .grep(), .fields() available). Value:"
+    nlprint(arg)
+    
+print_slist = result_display.when_type(SList)(print_slist)
+
+
+
+#----------------------------------------------------------------------------
+def esc_quotes(strng):
+    """Return the input string with single and double quotes escaped out"""
+
+    return strng.replace('"','\\"').replace("'","\\'")
+
+#----------------------------------------------------------------------------
+def make_quoted_expr(s):
+    """Return string s in appropriate quotes, using raw string if possible.
+    
+    Effectively this turns string: cd \ao\ao\
+    to: r"cd \ao\ao\_"[:-1]
+    
+    Note the use of raw string and padding at the end to allow trailing backslash.
+    
+    """
+    
+    tail = ''
+    tailpadding = ''
+    raw  = ''
+    if "\\" in s:
+        raw = 'r'
+        if s.endswith('\\'):
+            tail = '[:-1]'
+            tailpadding = '_'
+    if '"' not in s:
+        quote = '"'
+    elif "'" not in s:
+        quote = "'"
+    elif '"""' not in s and not s.endswith('"'):
+        quote = '"""'
+    elif "'''" not in s and not s.endswith("'"):
+        quote = "'''"
+    else:
+        # give up, backslash-escaped string will do
+        return '"%s"' % esc_quotes(s)
+    res = raw + quote + s + tailpadding + quote + tail
+    return res
+
+
+#----------------------------------------------------------------------------
+def raw_input_multi(header='', ps1='==> ', ps2='..> ',terminate_str = '.'):
+    """Take multiple lines of input.
+
+    A list with each line of input as a separate element is returned when a
+    termination string is entered (defaults to a single '.'). Input can also
+    terminate via EOF (^D in Unix, ^Z-RET in Windows).
+
+    Lines of input which end in \\ are joined into single entries (and a
+    secondary continuation prompt is issued as long as the user terminates
+    lines with \\). This allows entering very long strings which are still
+    meant to be treated as single entities.
+    """
+
+    try:
+        if header:
+            header += '\n'
+        lines = [raw_input(header + ps1)]
+    except EOFError:
+        return []
+    terminate = [terminate_str]
+    try:
+        while lines[-1:] != terminate:
+            new_line = raw_input(ps1)
+            while new_line.endswith('\\'):
+                new_line = new_line[:-1] + raw_input(ps2)
+            lines.append(new_line)
+                
+        return lines[:-1]  # don't return the termination command
+    except EOFError:
+        print
+        return lines
+
+#----------------------------------------------------------------------------
+def raw_input_ext(prompt='',  ps2='... '):
+    """Similar to raw_input(), but accepts extended lines if input ends with \\."""
+
+    line = raw_input(prompt)
+    while line.endswith('\\'):
+        line = line[:-1] + raw_input(ps2)
+    return line
+
+#----------------------------------------------------------------------------
+def ask_yes_no(prompt,default=None):
+    """Asks a question and returns a boolean (y/n) answer.
+
+    If default is given (one of 'y','n'), it is used if the user input is
+    empty. Otherwise the question is repeated until an answer is given.
+
+    An EOF is treated as the default answer.  If there is no default, an
+    exception is raised to prevent infinite loops.
+
+    Valid answers are: y/yes/n/no (match is not case sensitive)."""
+
+    answers = {'y':True,'n':False,'yes':True,'no':False}
+    ans = None
+    while ans not in answers.keys():
+        try:
+            ans = raw_input(prompt+' ').lower()
+            if not ans:  # response was an empty string
+                ans = default
+        except KeyboardInterrupt:
+            pass
+        except EOFError:
+            if default in answers.keys():
+                ans = default
+                print
+            else:
+                raise
+            
+    return answers[ans]
+
+#----------------------------------------------------------------------------
+def marquee(txt='',width=78,mark='*'):
+    """Return the input string centered in a 'marquee'."""
+    if not txt:
+        return (mark*width)[:width]
+    nmark = (width-len(txt)-2)/len(mark)/2
+    if nmark < 0: nmark =0
+    marks = mark*nmark
+    return '%s %s %s' % (marks,txt,marks)
+
+#----------------------------------------------------------------------------
+class EvalDict:
+    """
+    Emulate a dict which evaluates its contents in the caller's frame.
+
+    Usage:
+    >>>number = 19
+    >>>text = "python"
+    >>>print "%(text.capitalize())s %(number/9.0).1f rules!" % EvalDict()
+    """
+
+    # This version is due to sismex01@hebmex.com on c.l.py, and is basically a
+    # modified (shorter) version of:
+    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66018 by
+    # Skip Montanaro (skip@pobox.com).
+
+    def __getitem__(self, name):
+        frame = sys._getframe(1)
+        return eval(name, frame.f_globals, frame.f_locals)
+
+EvalString = EvalDict  # for backwards compatibility
+#----------------------------------------------------------------------------
+def qw(words,flat=0,sep=None,maxsplit=-1):
+    """Similar to Perl's qw() operator, but with some more options.
+
+    qw(words,flat=0,sep=' ',maxsplit=-1) -> words.split(sep,maxsplit)
+
+    words can also be a list itself, and with flat=1, the output will be
+    recursively flattened. Examples:
+
+    >>> qw('1 2')
+    ['1', '2']
+    >>> qw(['a b','1 2',['m n','p q']])
+    [['a', 'b'], ['1', '2'], [['m', 'n'], ['p', 'q']]]
+    >>> qw(['a b','1 2',['m n','p q']],flat=1)
+    ['a', 'b', '1', '2', 'm', 'n', 'p', 'q']    """
+
+    if type(words) in StringTypes:
+        return [word.strip() for word in words.split(sep,maxsplit)
+                if word and not word.isspace() ]
+    if flat:
+        return flatten(map(qw,words,[1]*len(words)))
+    return map(qw,words)
+
+#----------------------------------------------------------------------------
+def qwflat(words,sep=None,maxsplit=-1):
+    """Calls qw(words) in flat mode. It's just a convenient shorthand."""
+    return qw(words,1,sep,maxsplit)
+
+#----------------------------------------------------------------------------
+def qw_lol(indata):
+    """qw_lol('a b') -> [['a','b']],
+    otherwise it's just a call to qw().
+
+    We need this to make sure the modules_some keys *always* end up as a
+    list of lists."""
+
+    if type(indata) in StringTypes:
+        return [qw(indata)]
+    else:
+        return qw(indata)
+
+#-----------------------------------------------------------------------------
+def list_strings(arg):
+    """Always return a list of strings, given a string or list of strings
+    as input."""
+
+    if type(arg) in StringTypes: return [arg]
+    else: return arg
+
+#----------------------------------------------------------------------------
+def grep(pat,list,case=1):
+    """Simple minded grep-like function.
+    grep(pat,list) returns occurrences of pat in list, None on failure.
+
+    It only does simple string matching, with no support for regexps. Use the
+    option case=0 for case-insensitive matching."""
+
+    # This is pretty crude. At least it should implement copying only references
+    # to the original data in case it's big. Now it copies the data for output.
+    out=[]
+    if case:
+        for term in list:
+            if term.find(pat)>-1: out.append(term)
+    else:
+        lpat=pat.lower()
+        for term in list:
+            if term.lower().find(lpat)>-1: out.append(term)
+
+    if len(out): return out
+    else: return None
+
+#----------------------------------------------------------------------------
+def dgrep(pat,*opts):
+    """Return grep() on dir()+dir(__builtins__).
+
+    A very common use of grep() when working interactively."""
+
+    return grep(pat,dir(__main__)+dir(__main__.__builtins__),*opts)
+
+#----------------------------------------------------------------------------
+def idgrep(pat):
+    """Case-insensitive dgrep()"""
+
+    return dgrep(pat,0)
+
+#----------------------------------------------------------------------------
+def igrep(pat,list):
+    """Synonym for case-insensitive grep."""
+
+    return grep(pat,list,case=0)
+
+#----------------------------------------------------------------------------
+def indent(str,nspaces=4,ntabs=0):
+    """Indent a string a given number of spaces or tabstops.
+    
+    indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
+    """
+    if str is None:
+        return
+    ind = '\t'*ntabs+' '*nspaces
+    outstr = '%s%s' % (ind,str.replace(os.linesep,os.linesep+ind))
+    if outstr.endswith(os.linesep+ind):
+        return outstr[:-len(ind)]
+    else:
+        return outstr
+    
+#-----------------------------------------------------------------------------
+def native_line_ends(filename,backup=1):
+    """Convert (in-place) a file to line-ends native to the current OS.
+
+    If the optional backup argument is given as false, no backup of the
+    original file is left.  """
+
+    backup_suffixes = {'posix':'~','dos':'.bak','nt':'.bak','mac':'.bak'}
+
+    bak_filename = filename + backup_suffixes[os.name]
+
+    original = open(filename).read()
+    shutil.copy2(filename,bak_filename)
+    try:
+        new = open(filename,'wb')
+        new.write(os.linesep.join(original.splitlines()))
+        new.write(os.linesep) # ALWAYS put an eol at the end of the file
+        new.close()
+    except:
+        os.rename(bak_filename,filename)
+    if not backup:
+        try:
+            os.remove(bak_filename)
+        except:
+            pass
+    
+#----------------------------------------------------------------------------
+def get_pager_cmd(pager_cmd = None):
+    """Return a pager command.
+
+    Makes some attempts at finding an OS-correct one."""
+    
+    if os.name == 'posix':
+        default_pager_cmd = 'less -r'  # -r for color control sequences
+    elif os.name in ['nt','dos']:
+        default_pager_cmd = 'type'
+
+    if pager_cmd is None:
+        try:
+            pager_cmd = os.environ['PAGER']
+        except:
+            pager_cmd = default_pager_cmd
+    return pager_cmd
+
+#-----------------------------------------------------------------------------
+def get_pager_start(pager,start):
+    """Return the string for paging files with an offset.
+
+    This is the '+N' argument which less and more (under Unix) accept.
+    """
+
+    if pager in ['less','more']:
+        if start:
+            start_string = '+' + str(start)
+        else:
+            start_string = ''
+    else:
+        start_string = ''
+    return start_string
+
+#----------------------------------------------------------------------------
+# (X)emacs on W32 doesn't like to be bypassed with msvcrt.getch()
+if os.name == 'nt' and os.environ.get('TERM','dumb') != 'emacs':
+    import msvcrt
+    def page_more():
+        """ Smart pausing between pages
+
+        @return:    True if need print more lines, False if quit
+        """
+        Term.cout.write('---Return to continue, q to quit--- ')
+        ans = msvcrt.getch()
+        if ans in ("q", "Q"):
+            result = False
+        else:
+            result = True
+        Term.cout.write("\b"*37 + " "*37 + "\b"*37)
+        return result
+else:
+    def page_more():
+        ans = raw_input('---Return to continue, q to quit--- ')
+        if ans.lower().startswith('q'):
+            return False
+        else:
+            return True
+
+esc_re = re.compile(r"(\x1b[^m]+m)")
+
+def page_dumb(strng,start=0,screen_lines=25):
+    """Very dumb 'pager' in Python, for when nothing else works.
+
+    Only moves forward, same interface as page(), except for pager_cmd and
+    mode."""
+
+    out_ln  = strng.splitlines()[start:]
+    screens = chop(out_ln,screen_lines-1)
+    if len(screens) == 1:
+        print >>Term.cout, os.linesep.join(screens[0])
+    else:
+        last_escape = ""
+        for scr in screens[0:-1]:
+            hunk = os.linesep.join(scr)
+            print >>Term.cout, last_escape + hunk
+            if not page_more():
+                return
+            esc_list = esc_re.findall(hunk)
+            if len(esc_list) > 0:
+                last_escape = esc_list[-1]
+        print >>Term.cout, last_escape + os.linesep.join(screens[-1])
+
+#----------------------------------------------------------------------------
+def page(strng,start=0,screen_lines=0,pager_cmd = None):
+    """Print a string, piping through a pager after a certain length.
+
+    The screen_lines parameter specifies the number of *usable* lines of your
+    terminal screen (total lines minus lines you need to reserve to show other
+    information).
+
+    If you set screen_lines to a number <=0, page() will try to auto-determine
+    your screen size and will only use up to (screen_size+screen_lines) for
+    printing, paging after that. That is, if you want auto-detection but need
+    to reserve the bottom 3 lines of the screen, use screen_lines = -3, and for
+    auto-detection without any lines reserved simply use screen_lines = 0.
+
+    If a string won't fit in the allowed lines, it is sent through the
+    specified pager command. If none given, look for PAGER in the environment,
+    and ultimately default to less.
+
+    If no system pager works, the string is sent through a 'dumb pager'
+    written in python, very simplistic.
+    """
+    
+
+    # first, try the hook
+    ip = IPython.ipapi.get()
+    if ip:
+        try:
+            ip.IP.hooks.show_in_pager(strng)
+            return
+        except IPython.ipapi.TryNext:
+            pass
+        
+    # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
+    TERM = os.environ.get('TERM','dumb')
+    if TERM in ['dumb','emacs'] and os.name != 'nt':
+        print strng
+        return
+    # chop off the topmost part of the string we don't want to see
+    str_lines = strng.split(os.linesep)[start:]
+    str_toprint = os.linesep.join(str_lines)
+    num_newlines = len(str_lines)
+    len_str = len(str_toprint)
+    
+    # Dumb heuristics to guesstimate number of on-screen lines the string
+    # takes.  Very basic, but good enough for docstrings in reasonable
+    # terminals. If someone later feels like refining it, it's not hard.
+    numlines = max(num_newlines,int(len_str/80)+1)
+
+    if os.name == "nt":
+        screen_lines_def = get_console_size(defaulty=25)[1]
+    else:
+        screen_lines_def = 25 # default value if we can't auto-determine
+
+    # auto-determine screen size
+    if screen_lines <= 0:
+        if TERM=='xterm':
+            try:
+                import curses
+                if hasattr(curses,'initscr'):
+                    use_curses = 1
+                else:
+                    use_curses = 0
+            except ImportError:
+                use_curses = 0
+        else:
+            # curses causes problems on many terminals other than xterm.
+            use_curses = 0
+        if use_curses:
+                scr = curses.initscr()
+                screen_lines_real,screen_cols = scr.getmaxyx()
+                curses.endwin()
+                screen_lines += screen_lines_real
+                #print '***Screen size:',screen_lines_real,'lines x',\
+                #screen_cols,'columns.' # dbg
+        else:
+                screen_lines += screen_lines_def
+
+    #print 'numlines',numlines,'screenlines',screen_lines  # dbg
+    if numlines <= screen_lines :
+        #print '*** normal print'  # dbg
+        print >>Term.cout, str_toprint
+    else:
+        # Try to open pager and default to internal one if that fails.
+        # All failure modes are tagged as 'retval=1', to match the return
+        # value of a failed system command.  If any intermediate attempt
+        # sets retval to 1, at the end we resort to our own page_dumb() pager.
+        pager_cmd = get_pager_cmd(pager_cmd)
+        pager_cmd += ' ' + get_pager_start(pager_cmd,start)
+        if os.name == 'nt':
+            if pager_cmd.startswith('type'):
+                # The default WinXP 'type' command is failing on complex strings.
+                retval = 1
+            else:
+                tmpname = tempfile.mktemp('.txt')
+                tmpfile = file(tmpname,'wt')
+                tmpfile.write(strng)
+                tmpfile.close()
+                cmd = "%s < %s" % (pager_cmd,tmpname)
+                if os.system(cmd):
+                  retval = 1
+                else:
+                  retval = None
+                os.remove(tmpname)
+        else:
+            try:
+                retval = None
+                # if I use popen4, things hang. No idea why.
+                #pager,shell_out = os.popen4(pager_cmd)
+                pager = os.popen(pager_cmd,'w')
+                pager.write(strng)
+                pager.close()
+                retval = pager.close()  # success returns None
+            except IOError,msg:  # broken pipe when user quits
+                if msg.args == (32,'Broken pipe'):
+                    retval = None
+                else:
+                    retval = 1
+            except OSError:
+                # Other strange problems, sometimes seen in Win2k/cygwin
+                retval = 1
+        if retval is not None:
+            page_dumb(strng,screen_lines=screen_lines)
+
+#----------------------------------------------------------------------------
+def page_file(fname,start = 0, pager_cmd = None):
+    """Page a file, using an optional pager command and starting line.
+    """
+
+    pager_cmd = get_pager_cmd(pager_cmd)
+    pager_cmd += ' ' + get_pager_start(pager_cmd,start)
+
+    try:
+        if os.environ['TERM'] in ['emacs','dumb']:
+            raise EnvironmentError
+        xsys(pager_cmd + ' ' + fname)
+    except:
+        try:
+            if start > 0:
+                start -= 1
+            page(open(fname).read(),start)
+        except:
+            print 'Unable to show file',`fname`
+
+
+#----------------------------------------------------------------------------
+def snip_print(str,width = 75,print_full = 0,header = ''):
+    """Print a string snipping the midsection to fit in width.
+
+    print_full: mode control:
+      - 0: only snip long strings
+      - 1: send to page() directly.
+      - 2: snip long strings and ask for full length viewing with page()
+    Return 1 if snipping was necessary, 0 otherwise."""
+
+    if print_full == 1:
+        page(header+str)
+        return 0
+
+    print header,
+    if len(str) < width:
+        print str
+        snip = 0
+    else:
+        whalf = int((width -5)/2)
+        print str[:whalf] + ' <...> ' + str[-whalf:]
+        snip = 1
+    if snip and print_full == 2:
+        if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
+            page(str)
+    return snip
+
+#****************************************************************************
+# lists, dicts and structures
+
+def belong(candidates,checklist):
+    """Check whether a list of items appear in a given list of options.
+
+    Returns a list of 1 and 0, one for each candidate given."""
+
+    return [x in checklist for x in candidates]
+
+#----------------------------------------------------------------------------
+def uniq_stable(elems):
+    """uniq_stable(elems) -> list
+
+    Return from an iterable, a list of all the unique elements in the input,
+    but maintaining the order in which they first appear.
+
+    A naive solution to this problem which just makes a dictionary with the
+    elements as keys fails to respect the stability condition, since
+    dictionaries are unsorted by nature.
+
+    Note: All elements in the input must be valid dictionary keys for this
+    routine to work, as it internally uses a dictionary for efficiency
+    reasons."""
+    
+    unique = []
+    unique_dict = {}
+    for nn in elems:
+        if nn not in unique_dict:
+            unique.append(nn)
+            unique_dict[nn] = None
+    return unique
+
+#----------------------------------------------------------------------------
+class NLprinter:
+    """Print an arbitrarily nested list, indicating index numbers.
+
+    An instance of this class called nlprint is available and callable as a
+    function.
+    
+    nlprint(list,indent=' ',sep=': ') -> prints indenting each level by 'indent'
+    and using 'sep' to separate the index from the value. """
+
+    def __init__(self):
+        self.depth = 0
+    
+    def __call__(self,lst,pos='',**kw):
+        """Prints the nested list numbering levels."""
+        kw.setdefault('indent',' ')
+        kw.setdefault('sep',': ')
+        kw.setdefault('start',0)
+        kw.setdefault('stop',len(lst))
+        # we need to remove start and stop from kw so they don't propagate
+        # into a recursive call for a nested list.
+        start = kw['start']; del kw['start']
+        stop = kw['stop']; del kw['stop']
+        if self.depth == 0 and 'header' in kw.keys():
+            print kw['header']
+            
+        for idx in range(start,stop):
+            elem = lst[idx]
+            if type(elem)==type([]):
+                self.depth += 1
+                self.__call__(elem,itpl('$pos$idx,'),**kw)
+                self.depth -= 1
+            else:
+                printpl(kw['indent']*self.depth+'$pos$idx$kw["sep"]$elem')
+
+nlprint = NLprinter()
+#----------------------------------------------------------------------------
+def all_belong(candidates,checklist):
+    """Check whether a list of items ALL appear in a given list of options.
+
+    Returns a single 1 or 0 value."""
+
+    return 1-(0 in [x in checklist for x in candidates])
+
+#----------------------------------------------------------------------------
+def sort_compare(lst1,lst2,inplace = 1):
+    """Sort and compare two lists.
+
+    By default it does it in place, thus modifying the lists. Use inplace = 0
+    to avoid that (at the cost of temporary copy creation)."""
+    if not inplace:
+        lst1 = lst1[:]
+        lst2 = lst2[:]
+    lst1.sort(); lst2.sort()
+    return lst1 == lst2
+
+#----------------------------------------------------------------------------
+def mkdict(**kwargs):
+    """Return a dict from a keyword list.
+
+    It's just syntactic sugar for making ditcionary creation more convenient:
+    # the standard way
+    >>>data = { 'red' : 1, 'green' : 2, 'blue' : 3 }
+    # a cleaner way
+    >>>data = dict(red=1, green=2, blue=3)
+
+    If you need more than this, look at the Struct() class."""
+
+    return kwargs
+
+#----------------------------------------------------------------------------
+def list2dict(lst):
+    """Takes a list of (key,value) pairs and turns it into a dict."""
+
+    dic = {}
+    for k,v in lst: dic[k] = v
+    return dic
+
+#----------------------------------------------------------------------------
+def list2dict2(lst,default=''):
+    """Takes a list and turns it into a dict.
+    Much slower than list2dict, but more versatile. This version can take
+    lists with sublists of arbitrary length (including sclars)."""
+
+    dic = {}
+    for elem in lst:
+        if type(elem) in (types.ListType,types.TupleType):
+            size = len(elem)
+            if  size == 0:
+                pass
+            elif size == 1:
+                dic[elem] = default
+            else:
+                k,v = elem[0], elem[1:]
+                if len(v) == 1: v = v[0]
+                dic[k] = v
+        else:
+            dic[elem] = default
+    return dic
+
+#----------------------------------------------------------------------------
+def flatten(seq):
+    """Flatten a list of lists (NOT recursive, only works for 2d lists)."""
+
+    return [x for subseq in seq for x in subseq]
+
+#----------------------------------------------------------------------------
+def get_slice(seq,start=0,stop=None,step=1):
+    """Get a slice of a sequence with variable step. Specify start,stop,step."""
+    if stop == None:
+        stop = len(seq)
+    item = lambda i: seq[i]
+    return map(item,xrange(start,stop,step))
+
+#----------------------------------------------------------------------------
+def chop(seq,size):
+    """Chop a sequence into chunks of the given size."""
+    chunk = lambda i: seq[i:i+size]
+    return map(chunk,xrange(0,len(seq),size))
+
+#----------------------------------------------------------------------------
+# with is a keyword as of python 2.5, so this function is renamed to withobj
+# from its old 'with' name.
+def with_obj(object, **args):
+    """Set multiple attributes for an object, similar to Pascal's with.
+
+    Example:
+    with_obj(jim,
+             born = 1960,
+             haircolour = 'Brown',
+             eyecolour = 'Green')
+
+    Credit: Greg Ewing, in
+    http://mail.python.org/pipermail/python-list/2001-May/040703.html.
+
+    NOTE: up until IPython 0.7.2, this was called simply 'with', but 'with'
+    has become a keyword for Python 2.5, so we had to rename it."""
+
+    object.__dict__.update(args)
+
+#----------------------------------------------------------------------------
+def setattr_list(obj,alist,nspace = None):
+    """Set a list of attributes for an object taken from a namespace.
+
+    setattr_list(obj,alist,nspace) -> sets in obj all the attributes listed in
+    alist with their values taken from nspace, which must be a dict (something
+    like locals() will often do) If nspace isn't given, locals() of the
+    *caller* is used, so in most cases you can omit it.
+
+    Note that alist can be given as a string, which will be automatically
+    split into a list on whitespace. If given as a list, it must be a list of
+    *strings* (the variable names themselves), not of variables."""
+
+    # this grabs the local variables from the *previous* call frame -- that is
+    # the locals from the function that called setattr_list().
+    # - snipped from weave.inline()
+    if nspace is None:
+        call_frame = sys._getframe().f_back
+        nspace = call_frame.f_locals
+
+    if type(alist) in StringTypes:
+        alist = alist.split()
+    for attr in alist:
+        val = eval(attr,nspace)
+        setattr(obj,attr,val)
+
+#----------------------------------------------------------------------------
+def getattr_list(obj,alist,*args):
+    """getattr_list(obj,alist[, default]) -> attribute list.
+
+    Get a list of named attributes for an object. When a default argument is
+    given, it is returned when the attribute doesn't exist; without it, an
+    exception is raised in that case.
+
+    Note that alist can be given as a string, which will be automatically
+    split into a list on whitespace. If given as a list, it must be a list of
+    *strings* (the variable names themselves), not of variables."""
+
+    if type(alist) in StringTypes:
+        alist = alist.split()
+    if args:
+        if len(args)==1:
+            default = args[0]
+            return map(lambda attr: getattr(obj,attr,default),alist)
+        else:
+            raise ValueError,'getattr_list() takes only one optional argument'
+    else:
+        return map(lambda attr: getattr(obj,attr),alist)
+    
+#----------------------------------------------------------------------------
+def map_method(method,object_list,*argseq,**kw):
+    """map_method(method,object_list,*args,**kw) -> list
+
+    Return a list of the results of applying the methods to the items of the
+    argument sequence(s).  If more than one sequence is given, the method is
+    called with an argument list consisting of the corresponding item of each
+    sequence. All sequences must be of the same length.
+
+    Keyword arguments are passed verbatim to all objects called.
+
+    This is Python code, so it's not nearly as fast as the builtin map()."""
+
+    out_list = []
+    idx = 0
+    for object in object_list:
+        try:
+            handler = getattr(object, method)
+        except AttributeError:
+            out_list.append(None)
+        else:
+            if argseq:
+                args = map(lambda lst:lst[idx],argseq)
+                #print 'ob',object,'hand',handler,'ar',args # dbg
+                out_list.append(handler(args,**kw))
+            else:
+                out_list.append(handler(**kw))
+        idx += 1
+    return out_list
+
+#----------------------------------------------------------------------------
+def get_class_members(cls):
+    ret = dir(cls)
+    if hasattr(cls,'__bases__'):
+        for base in cls.__bases__:
+            ret.extend(get_class_members(base))
+    return ret
+
+#----------------------------------------------------------------------------
+def dir2(obj):
+    """dir2(obj) -> list of strings
+
+    Extended version of the Python builtin dir(), which does a few extra
+    checks, and supports common objects with unusual internals that confuse
+    dir(), such as Traits and PyCrust.
+
+    This version is guaranteed to return only a list of true strings, whereas
+    dir() returns anything that objects inject into themselves, even if they
+    are later not really valid for attribute access (many extension libraries
+    have such bugs).
+    """
+    
+    # Start building the attribute list via dir(), and then complete it
+    # with a few extra special-purpose calls.
+    words = dir(obj)
+
+    if hasattr(obj,'__class__'):
+        words.append('__class__')
+        words.extend(get_class_members(obj.__class__))
+    #if '__base__' in words: 1/0
+
+    # Some libraries (such as traits) may introduce duplicates, we want to
+    # track and clean this up if it happens
+    may_have_dupes = False
+
+    # this is the 'dir' function for objects with Enthought's traits
+    if hasattr(obj, 'trait_names'):
+        try:
+            words.extend(obj.trait_names())
+            may_have_dupes = True
+        except TypeError:
+            # This will happen if `obj` is a class and not an instance.
+            pass
+
+    # Support for PyCrust-style _getAttributeNames magic method.
+    if hasattr(obj, '_getAttributeNames'):
+        try:
+            words.extend(obj._getAttributeNames())
+            may_have_dupes = True
+        except TypeError:
+            # `obj` is a class and not an instance.  Ignore
+            # this error.
+            pass
+
+    if may_have_dupes:
+        # eliminate possible duplicates, as some traits may also
+        # appear as normal attributes in the dir() call.
+        words = list(set(words))
+        words.sort()
+
+    # filter out non-string attributes which may be stuffed by dir() calls
+    # and poor coding in third-party modules
+    return [w for w in words if isinstance(w, basestring)]
+
+#----------------------------------------------------------------------------
+def import_fail_info(mod_name,fns=None):
+    """Inform load failure for a module."""
+
+    if fns == None:
+        warn("Loading of %s failed.\n" % (mod_name,))
+    else:
+        warn("Loading of %s from %s failed.\n" % (fns,mod_name))
+
+#----------------------------------------------------------------------------
+# Proposed popitem() extension, written as a method
+
+
+class NotGiven: pass
+
+def popkey(dct,key,default=NotGiven):
+    """Return dct[key] and delete dct[key].
+
+    If default is given, return it if dct[key] doesn't exist, otherwise raise
+    KeyError.  """
+
+    try:
+        val = dct[key]
+    except KeyError:
+        if default is NotGiven:
+            raise
+        else:
+            return default
+    else:
+        del dct[key]
+        return val
+
+def wrap_deprecated(func, suggest = '<nothing>'):
+    def newFunc(*args, **kwargs):
+        warnings.warn("Call to deprecated function %s, use %s instead" % 
+                      ( func.__name__, suggest),
+                      category=DeprecationWarning,
+                      stacklevel = 2)
+        return func(*args, **kwargs)
+    return newFunc
+    
+#*************************** end of file <genutils.py> **********************
+
diff --git a/IPython/gui/__init__.py b/IPython/gui/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/IPython/gui/__init__.py
diff --git a/IPython/gui/wx/ThreadEx.py b/IPython/gui/wx/ThreadEx.py
new file mode 100644
index 0000000..071f50a
--- /dev/null
+++ b/IPython/gui/wx/ThreadEx.py
@@ -0,0 +1,45 @@
+import threading
+import inspect
+import ctypes
+ 
+ 
+def _async_raise(tid, exctype):
+    """raises the exception, performs cleanup if needed"""
+    if not inspect.isclass(exctype):
+        raise TypeError("Only types can be raised (not instances)")
+    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
+    if res == 0:
+        raise ValueError("invalid thread id")
+    elif res != 1:
+        # """if it returns a number greater than one, you're in trouble, 
+        # and you should call it again with exc=NULL to revert the effect"""
+        ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
+        raise SystemError("PyThreadState_SetAsyncExc failed")
+ 
+ 
+class Thread(threading.Thread):
+    def _get_my_tid(self):
+        """determines this (self's) thread id"""
+        if not self.isAlive():
+            raise threading.ThreadError("the thread is not active")
+        
+        # do we have it cached?
+        if hasattr(self, "_thread_id"):
+            return self._thread_id
+        
+        # no, look for it in the _active dict
+        for tid, tobj in threading._active.items():
+            if tobj is self:
+                self._thread_id = tid
+                return tid
+        
+        raise AssertionError("could not determine the thread's id")
+    
+    def raise_exc(self, exctype):
+        """raises the given exception type in the context of this thread"""
+        _async_raise(self._get_my_tid(), exctype)
+    
+    def kill(self):
+        """raises SystemExit in the context of the given thread, which should 
+        cause the thread to exit silently (unless caught)"""
+        self.raise_exc(SystemExit)
diff --git a/IPython/gui/wx/__init__.py b/IPython/gui/wx/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/IPython/gui/wx/__init__.py
diff --git a/IPython/gui/wx/ipython_history.py b/IPython/gui/wx/ipython_history.py
new file mode 100644
index 0000000..90d7570
--- /dev/null
+++ b/IPython/gui/wx/ipython_history.py
@@ -0,0 +1,411 @@
+#!/usr/bin/python
+# -*- coding: iso-8859-15 -*-
+import wx
+import wx.stc  as  stc
+import keyword
+
+#-----------------------------------------
+# History widget for IPython
+__version__ = 0.5
+__author__  = "Laurent Dufrechou"
+__email__   = "laurent.dufrechou _at_ gmail.com"
+__license__ = "BSD"
+#-----------------------------------------
+class IPythonHistoryPanel(wx.Panel):
+
+    def __init__(self, parent,flt_empty=True,
+                 flt_doc=True,flt_cmd=True,flt_magic=True):
+        
+        wx.Panel.__init__(self,parent,-1)
+        #text_ctrl = wx.TextCtrl(self, -1, style=wx.TE_MULTILINE)
+        text_ctrl = PythonSTC(self, -1)
+        
+        
+        st_filt = wx.StaticText(self, -1, " Filter:")
+
+        self.filter_empty = wx.CheckBox(self, -1, "Empty commands")
+        self.filter_doc   = wx.CheckBox(self, -1, "?: Doc commands")
+        self.filter_cmd   = wx.CheckBox(self, -1, "!: Sys commands")
+        self.filter_magic = wx.CheckBox(self, -1, "%: Magic keys")
+
+        self.filter_empty.SetValue(flt_empty)
+        self.filter_doc.SetValue(flt_doc)
+        self.filter_cmd.SetValue(flt_cmd)
+        self.filter_magic.SetValue(flt_magic)
+        
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        sizer.Add(text_ctrl, 1, wx.EXPAND)
+        sizer.AddMany( [(5,5),
+                        st_filt,
+                        (10,10),
+                        self.filter_empty,
+                        self.filter_doc,
+                        self.filter_cmd,
+                        self.filter_magic,
+                        (10,10),
+                        ])
+        self.SetAutoLayout(True)
+        sizer.Fit(self)
+        sizer.SetSizeHints(self)
+        self.SetSizer(sizer)
+        self.text_ctrl=text_ctrl
+        #text_ctrl.SetText(demoText + open('Main.py').read())
+        text_ctrl.EmptyUndoBuffer()
+        text_ctrl.Colourise(0, -1)
+
+        # line numbers in the margin
+        text_ctrl.SetMarginType(1, stc.STC_MARGIN_NUMBER)
+        text_ctrl.SetMarginWidth(1, 15)
+
+        
+    def write(self,history_line):
+        add = True
+        if self.filter_empty.GetValue() == True and history_line == '':
+            add = False
+        if len(history_line)>0:
+            if self.filter_doc.GetValue() == True and history_line[-1:] == '?':
+                add = False
+            if self.filter_cmd.GetValue() == True and history_line[0] == '!':
+                add = False
+            if self.filter_magic.GetValue() == True and history_line[0] == '%':
+                add = False
+	if add:
+        	self.text_ctrl.AppendText(history_line+'\n')
+
+
+#----------------------------------------------------------------------
+# Font definition for Styled Text Control
+
+if wx.Platform == '__WXMSW__':
+    faces = { 'times': 'Times New Roman',
+              'mono' : 'Courier New',
+              'helv' : 'Arial',
+              'other': 'Comic Sans MS',
+              'size' : 8,
+              'size2': 6,
+             }
+elif wx.Platform == '__WXMAC__':
+    faces = { 'times': 'Times New Roman',
+              'mono' : 'Monaco',
+              'helv' : 'Arial',
+              'other': 'Comic Sans MS',
+              'size' : 8,
+              'size2': 6,
+             }
+else:
+    faces = { 'times': 'Times',
+              'mono' : 'Courier',
+              'helv' : 'Helvetica',
+              'other': 'new century schoolbook',
+              'size' : 8,
+              'size2': 6,
+             }
+
+
+#----------------------------------------------------------------------
+
+class PythonSTC(stc.StyledTextCtrl):
+
+    fold_symbols = 3
+    
+    def __init__(self, parent, ID,
+                 pos=wx.DefaultPosition, size=wx.DefaultSize,
+                 style=0):
+        stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
+        #self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
+        #self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
+
+        self.SetLexer(stc.STC_LEX_PYTHON)
+        self.SetKeyWords(0, " ".join(keyword.kwlist))
+
+        #self.SetProperty("fold", "1")
+        #self.SetProperty("tab.timmy.whinge.level", "1")
+        #self.SetMargins(0,0)
+
+        #self.SetViewWhiteSpace(False)
+        #self.SetBufferedDraw(False)
+        #self.SetViewEOL(True)
+        self.SetEOLMode(stc.STC_EOL_CRLF)
+        #self.SetUseAntiAliasing(True)
+        
+        self.SetEdgeMode(stc.STC_EDGE_LINE)
+        self.SetEdgeColumn(80)
+        self.SetEdgeColour(wx.LIGHT_GREY)
+        self.SetLayoutCache(stc.STC_CACHE_PAGE)
+
+        # Setup a margin to hold fold markers
+        #self.SetFoldFlags(16)  ###  WHAT IS THIS VALUE?  WHAT ARE THE OTHER FLAGS?  DOES IT MATTER?
+        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)
+        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)
+        self.SetMarginSensitive(2, True)
+        self.SetMarginWidth(2, 12)
+
+        if self.fold_symbols == 0:
+            # Arrow pointing right for contracted folders, arrow pointing down for expanded
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_ARROWDOWN, "black", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_ARROW, "black", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_EMPTY, "black", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_EMPTY, "black", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_EMPTY,     "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_EMPTY,     "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_EMPTY,     "white", "black")
+            
+        elif self.fold_symbols == 1:
+            # Plus for contracted folders, minus for expanded
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_MINUS, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_PLUS,  "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_EMPTY, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_EMPTY, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_EMPTY, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_EMPTY, "white", "black")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_EMPTY, "white", "black")
+
+        elif self.fold_symbols == 2:
+            # Like a flattened tree control using circular headers and curved joins
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_CIRCLEMINUS,          "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_CIRCLEPLUS,           "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,                "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNERCURVE,         "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_CIRCLEPLUSCONNECTED,  "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_CIRCLEMINUSCONNECTED, "white", "#404040")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNERCURVE,         "white", "#404040")
+
+        elif self.fold_symbols == 3:
+            # Like a flattened tree control using square headers
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_BOXMINUS,          "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_BOXPLUS,           "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,             "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNER,           "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_BOXPLUSCONNECTED,  "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080")
+            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNER,           "white", "#808080")
+
+
+        self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)
+        self.Bind(stc.EVT_STC_MARGINCLICK, self.OnMarginClick)
+        self.Bind(wx.EVT_KEY_DOWN, self.OnKeyPressed)
+
+        # Make some styles,  The lexer defines what each style is used for, we
+        # just have to define what each style looks like.  This set is adapted from
+        # Scintilla sample property files.
+
+        # Global default styles for all languages
+        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,     "face:%(helv)s,size:%(size)d" % faces)
+        self.StyleClearAll()  # Reset all to be like the default
+
+        # Global default styles for all languages
+        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,     "face:%(helv)s,size:%(size)d" % faces)
+        self.StyleSetSpec(stc.STC_STYLE_LINENUMBER,  "back:#C0C0C0,face:%(helv)s,size:%(size2)d" % faces)
+        self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR, "face:%(other)s" % faces)
+        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  "fore:#FFFFFF,back:#0000FF,bold")
+        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold")
+
+        # Python styles
+        # Default 
+        self.StyleSetSpec(stc.STC_P_DEFAULT, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
+        # Comments
+        self.StyleSetSpec(stc.STC_P_COMMENTLINE, "fore:#007F00,face:%(other)s,size:%(size)d" % faces)
+        # Number
+        self.StyleSetSpec(stc.STC_P_NUMBER, "fore:#007F7F,size:%(size)d" % faces)
+        # String
+        self.StyleSetSpec(stc.STC_P_STRING, "fore:#7F007F,face:%(helv)s,size:%(size)d" % faces)
+        # Single quoted string
+        self.StyleSetSpec(stc.STC_P_CHARACTER, "fore:#7F007F,face:%(helv)s,size:%(size)d" % faces)
+        # Keyword
+        self.StyleSetSpec(stc.STC_P_WORD, "fore:#00007F,bold,size:%(size)d" % faces)
+        # Triple quotes
+        self.StyleSetSpec(stc.STC_P_TRIPLE, "fore:#7F0000,size:%(size)d" % faces)
+        # Triple double quotes
+        self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, "fore:#7F0000,size:%(size)d" % faces)
+        # Class name definition
+        self.StyleSetSpec(stc.STC_P_CLASSNAME, "fore:#0000FF,bold,underline,size:%(size)d" % faces)
+        # Function or method name definition
+        self.StyleSetSpec(stc.STC_P_DEFNAME, "fore:#007F7F,bold,size:%(size)d" % faces)
+        # Operators
+        self.StyleSetSpec(stc.STC_P_OPERATOR, "bold,size:%(size)d" % faces)
+        # Identifiers
+        self.StyleSetSpec(stc.STC_P_IDENTIFIER, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
+        # Comment-blocks
+        self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, "fore:#7F7F7F,size:%(size)d" % faces)
+        # End of line where string is not closed
+        self.StyleSetSpec(stc.STC_P_STRINGEOL, "fore:#000000,face:%(mono)s,back:#E0C0E0,eol,size:%(size)d" % faces)
+
+        self.SetCaretForeground("BLUE")
+
+
+        # register some images for use in the AutoComplete box.
+        #self.RegisterImage(1, images.getSmilesBitmap())
+        #self.RegisterImage(2, 
+        #    wx.ArtProvider.GetBitmap(wx.ART_NEW, size=(16,16)))
+        #self.RegisterImage(3, 
+        #    wx.ArtProvider.GetBitmap(wx.ART_COPY, size=(16,16)))
+
+
+    def OnKeyPressed(self, event):
+        if self.CallTipActive():
+            self.CallTipCancel()
+        key = event.GetKeyCode()
+
+        if key == 32 and event.ControlDown():
+            pos = self.GetCurrentPos()
+
+            # Tips
+            if event.ShiftDown():
+                self.CallTipSetBackground("yellow")
+                self.CallTipShow(pos, 'lots of of text: blah, blah, blah\n\n'
+                                 'show some suff, maybe parameters..\n\n'
+                                 'fubar(param1, param2)')
+            # Code completion
+            else:
+                #lst = []
+                #for x in range(50000):
+                #    lst.append('%05d' % x)
+                #st = " ".join(lst)
+                #print len(st)
+                #self.AutoCompShow(0, st)
+
+                kw = keyword.kwlist[:]
+                
+                kw.sort()  # Python sorts are case sensitive
+                self.AutoCompSetIgnoreCase(False)  # so this needs to match
+
+                # Images are specified with a appended "?type"
+                for i in range(len(kw)):
+                    if kw[i] in keyword.kwlist:
+                        kw[i] = kw[i]# + "?1"
+
+                self.AutoCompShow(0, " ".join(kw))
+        else:
+            event.Skip()
+
+
+    def OnUpdateUI(self, evt):
+        # check for matching braces
+        braceAtCaret = -1
+        braceOpposite = -1
+        charBefore = None
+        caretPos = self.GetCurrentPos()
+
+        if caretPos > 0:
+            charBefore = self.GetCharAt(caretPos - 1)
+            styleBefore = self.GetStyleAt(caretPos - 1)
+
+        # check before
+        if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:
+            braceAtCaret = caretPos - 1
+
+        # check after
+        if braceAtCaret < 0:
+            charAfter = self.GetCharAt(caretPos)
+            styleAfter = self.GetStyleAt(caretPos)
+
+            if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
+                braceAtCaret = caretPos
+
+        if braceAtCaret >= 0:
+            braceOpposite = self.BraceMatch(braceAtCaret)
+
+        if braceAtCaret != -1  and braceOpposite == -1:
+            self.BraceBadLight(braceAtCaret)
+        else:
+            self.BraceHighlight(braceAtCaret, braceOpposite)
+            #pt = self.PointFromPosition(braceOpposite)
+            #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))
+            #print pt
+            #self.Refresh(False)
+
+
+    def OnMarginClick(self, evt):
+        # fold and unfold as needed
+        if evt.GetMargin() == 2:
+            if evt.GetShift() and evt.GetControl():
+                self.FoldAll()
+            else:
+                lineClicked = self.LineFromPosition(evt.GetPosition())
+
+                if self.GetFoldLevel(lineClicked) & stc.STC_FOLDLEVELHEADERFLAG:
+                    if evt.GetShift():
+                        self.SetFoldExpanded(lineClicked, True)
+                        self.Expand(lineClicked, True, True, 1)
+                    elif evt.GetControl():
+                        if self.GetFoldExpanded(lineClicked):
+                            self.SetFoldExpanded(lineClicked, False)
+                            self.Expand(lineClicked, False, True, 0)
+                        else:
+                            self.SetFoldExpanded(lineClicked, True)
+                            self.Expand(lineClicked, True, True, 100)
+                    else:
+                        self.ToggleFold(lineClicked)
+
+
+    def FoldAll(self):
+        lineCount = self.GetLineCount()
+        expanding = True
+
+        # find out if we are folding or unfolding
+        for lineNum in range(lineCount):
+            if self.GetFoldLevel(lineNum) & stc.STC_FOLDLEVELHEADERFLAG:
+                expanding = not self.GetFoldExpanded(lineNum)
+                break
+
+        lineNum = 0
+
+        while lineNum < lineCount:
+            level = self.GetFoldLevel(lineNum)
+            if level & stc.STC_FOLDLEVELHEADERFLAG and \
+               (level & stc.STC_FOLDLEVELNUMBERMASK) == stc.STC_FOLDLEVELBASE:
+
+                if expanding:
+                    self.SetFoldExpanded(lineNum, True)
+                    lineNum = self.Expand(lineNum, True)
+                    lineNum = lineNum - 1
+                else:
+                    lastChild = self.GetLastChild(lineNum, -1)
+                    self.SetFoldExpanded(lineNum, False)
+
+                    if lastChild > lineNum:
+                        self.HideLines(lineNum+1, lastChild)
+
+            lineNum = lineNum + 1
+
+
+
+    def Expand(self, line, doExpand, force=False, visLevels=0, level=-1):
+        lastChild = self.GetLastChild(line, level)
+        line = line + 1
+
+        while line <= lastChild:
+            if force:
+                if visLevels > 0:
+                    self.ShowLines(line, line)
+                else:
+                    self.HideLines(line, line)
+            else:
+                if doExpand:
+                    self.ShowLines(line, line)
+
+            if level == -1:
+                level = self.GetFoldLevel(line)
+
+            if level & stc.STC_FOLDLEVELHEADERFLAG:
+                if force:
+                    if visLevels > 1:
+                        self.SetFoldExpanded(line, True)
+                    else:
+                        self.SetFoldExpanded(line, False)
+
+                    line = self.Expand(line, doExpand, force, visLevels-1)
+
+                else:
+                    if doExpand and self.GetFoldExpanded(line):
+                        line = self.Expand(line, True, force, visLevels-1)
+                    else:
+                        line = self.Expand(line, False, force, visLevels-1)
+            else:
+                line = line + 1
+
+        return line
+
+
+#----------------------------------------------------------------------
diff --git a/IPython/gui/wx/ipython_view.py b/IPython/gui/wx/ipython_view.py
new file mode 100644
index 0000000..04e8c34
--- /dev/null
+++ b/IPython/gui/wx/ipython_view.py
@@ -0,0 +1,1046 @@
+#!/usr/bin/python
+# -*- coding: iso-8859-15 -*-
+'''
+Provides IPython WX console widget.
+
+@author: Laurent Dufrechou
+laurent.dufrechou _at_ gmail.com
+This WX widget is based on the original work of Eitan Isaacson
+that provided the console for the GTK toolkit.
+
+Original work from:
+@author: Eitan Isaacson
+@organization: IBM Corporation
+@copyright: Copyright (c) 2007 IBM Corporation
+@license: BSD
+
+All rights reserved. This program and the accompanying materials are made
+available under the terms of the BSD which accompanies this distribution, and
+is available at U{http://www.opensource.org/licenses/bsd-license.php}
+'''
+
+__version__ = 0.8
+__author__  = "Laurent Dufrechou"
+__email__   = "laurent.dufrechou _at_ gmail.com"
+__license__ = "BSD"
+
+import wx
+import wx.stc  as  stc
+import wx.lib.newevent
+
+import re
+import sys
+import os
+import locale
+import time
+from ThreadEx import Thread
+from StringIO import StringIO
+
+try:
+        import IPython
+except Exception,e:
+        raise "Error importing IPython (%s)" % str(e)
+
+class IterableIPShell(Thread):
+    '''
+    Create an IPython instance inside a dedicated thread.
+    Does not start a blocking event loop, instead allow single iterations.
+    This allows embedding in any GUI without blockage.
+    The thread is a slave one, in that it doesn't interact directly with the GUI.
+    Note Thread class comes from ThreadEx that supports asynchroneous function call
+    via raise_exc()
+    '''
+
+    def __init__(self,argv=[],user_ns=None,user_global_ns=None,
+                 cin=None, cout=None, cerr=None,
+                 exit_handler=None,time_loop = 0.1):
+        '''
+        @param argv: Command line options for IPython
+        @type argv: list
+        @param user_ns: User namespace.
+        @type user_ns: dictionary
+        @param user_global_ns: User global namespace.
+        @type user_global_ns: dictionary.
+        @param cin: Console standard input.
+        @type cin: IO stream
+        @param cout: Console standard output.
+        @type cout: IO stream
+        @param cerr: Console standard error.
+        @type cerr: IO stream
+        @param exit_handler: Replacement for builtin exit() function
+        @type exit_handler: function
+        @param time_loop: Define the sleep time between two thread's loop
+        @type int
+        '''
+        Thread.__init__(self)
+
+        #first we redefine in/out/error functions of IPython 
+        if cin:
+            IPython.Shell.Term.cin = cin
+        if cout:
+            IPython.Shell.Term.cout = cout
+        if cerr:
+            IPython.Shell.Term.cerr = cerr
+        
+        # This is to get rid of the blockage that accurs during
+        # IPython.Shell.InteractiveShell.user_setup()
+        IPython.iplib.raw_input = lambda x: None
+
+        self._term = IPython.genutils.IOTerm(cin=cin, cout=cout, cerr=cerr)
+
+        excepthook = sys.excepthook
+        self._IP = IPython.Shell.make_IPython(
+                                            argv,user_ns=user_ns,
+                                            user_global_ns=user_global_ns,
+                                            embedded=True,
+                                            shell_class=IPython.Shell.InteractiveShell)
+
+        #we replace IPython default encoding by wx locale encoding
+	loc = locale.getpreferredencoding()
+	if loc:
+        	self._IP.stdin_encoding = loc
+        #we replace the ipython default pager by our pager
+        self._IP.set_hook('show_in_pager',self._pager)
+        
+        #we replace the ipython default shell command caller by our shell handler
+	self._IP.set_hook('shell_hook',self._shell)
+        
+        #we replace the ipython default input command caller by our method
+        IPython.iplib.raw_input_original = self._raw_input
+        #we replace the ipython default exit command by our method
+        self._IP.exit = self._setAskExit
+            
+        sys.excepthook = excepthook
+
+        self._iter_more = 0
+        self._history_level = 0
+        self._complete_sep =  re.compile('[\s\{\}\[\]\(\)]')
+        self._prompt = str(self._IP.outputcache.prompt1).strip()
+
+        #thread working vars
+        self._terminate = False
+        self._time_loop = time_loop
+        self._has_doc = False
+        self._do_execute = False
+        self._line_to_execute = ''
+        self._doc_text = None
+        self._ask_exit = False
+
+    #----------------------- Thread management section ----------------------    
+    def run (self):
+        """
+        Thread main loop
+        The thread will run until self._terminate will be set to True via shutdown() function
+        Command processing can be interrupted with Instance.raise_exc(KeyboardInterrupt) call in the
+        GUI thread.
+        """
+        while(not self._terminate):
+            try:
+                if self._do_execute:
+                    self._doc_text = None
+                    self._execute()
+                    self._do_execute = False
+                
+            except KeyboardInterrupt:
+                pass
+
+            time.sleep(self._time_loop)
+            
+    def shutdown(self): 
+        """
+        Shutdown the tread
+        """
+        self._terminate = True
+
+    def doExecute(self,line):
+        """
+        Tell the thread to process the 'line' command
+        """
+        self._do_execute = True
+        self._line_to_execute = line
+        
+    def isExecuteDone(self):
+        """
+        Returns the processing state
+        """
+        return not self._do_execute
+
+    #----------------------- IPython management section ----------------------    
+    def getAskExit(self):
+        '''
+        returns the _ask_exit variable that can be checked by GUI to see if
+        IPython request an exit handling
+        '''
+        return self._ask_exit
+
+    def clearAskExit(self):
+        '''
+        clear the _ask_exit var when GUI as handled the request.
+        '''
+        self._ask_exit = False
+        
+    def getDocText(self):
+        """
+        Returns the output of the processing that need to be paged (if any)
+
+        @return: The std output string.
+        @rtype: string
+        """
+        return self._doc_text
+        
+    def getBanner(self):
+        """
+        Returns the IPython banner for useful info on IPython instance
+
+        @return: The banner string.
+        @rtype: string
+        """
+        return self._IP.BANNER
+    
+    def getPromptCount(self):
+        """
+        Returns the prompt number.
+        Each time a user execute a line in the IPython shell the prompt count is increased
+
+        @return: The prompt number
+        @rtype: int
+        """
+        return self._IP.outputcache.prompt_count
+
+    def getPrompt(self):
+        """
+        Returns current prompt inside IPython instance
+        (Can be In [...]: ot ...:)
+
+        @return: The current prompt.
+        @rtype: string
+        """
+        return self._prompt
+
+    def getIndentation(self):
+        """
+        Returns the current indentation level
+        Usefull to put the caret at the good start position if we want to do autoindentation.
+
+        @return: The indentation level.
+        @rtype: int
+        """
+        return self._IP.indent_current_nsp
+        
+    def updateNamespace(self, ns_dict):
+        '''
+        Add the current dictionary to the shell namespace.
+
+        @param ns_dict: A dictionary of symbol-values.
+        @type ns_dict: dictionary
+        '''
+        self._IP.user_ns.update(ns_dict)
+
+    def complete(self, line):
+        '''
+        Returns an auto completed line and/or posibilities for completion.
+
+        @param line: Given line so far.
+        @type line: string
+
+        @return: Line completed as for as possible,
+        and possible further completions.
+        @rtype: tuple
+        '''
+        split_line = self._complete_sep.split(line)
+        possibilities = self._IP.complete(split_line[-1])
+        if possibilities:
+
+            def _commonPrefix(str1, str2):
+                '''
+                Reduction function. returns common prefix of two given strings.
+
+                @param str1: First string.
+                @type str1: string
+                @param str2: Second string
+                @type str2: string
+
+                @return: Common prefix to both strings.
+                @rtype: string
+                '''
+                for i in range(len(str1)):
+                    if not str2.startswith(str1[:i+1]):
+                        return str1[:i]
+                return str1
+            common_prefix = reduce(_commonPrefix, possibilities)
+            completed = line[:-len(split_line[-1])]+common_prefix
+        else:
+            completed = line
+        return completed, possibilities
+
+    def historyBack(self):
+        '''
+        Provides one history command back.
+
+        @return: The command string.
+        @rtype: string
+        '''
+        history = ''
+        #the below while loop is used to suppress empty history lines
+	while((history == '' or history == '\n') and self._history_level >0):
+		if self._history_level>=1:
+			self._history_level -= 1
+		history = self._getHistory()		
+        return history
+
+    def historyForward(self):
+        '''
+        Provides one history command forward.
+
+        @return: The command string.
+        @rtype: string
+        '''
+	history = ''
+	#the below while loop is used to suppress empty history lines
+	while((history == '' or history == '\n') and self._history_level <= self._getHistoryMaxIndex()):
+		if self._history_level < self._getHistoryMaxIndex():
+			self._history_level += 1
+			history = self._getHistory()
+		else:
+			if self._history_level == self._getHistoryMaxIndex():
+				history = self._getHistory()
+				self._history_level += 1
+			else:
+				history = ''
+        return history
+
+    def initHistoryIndex(self):
+        '''
+        set history to last command entered
+        '''
+        self._history_level = self._getHistoryMaxIndex()+1
+
+    #----------------------- IPython PRIVATE management section ----------------------    
+    def _setAskExit(self):
+        '''
+        set the _ask_exit variable that can be cjhecked by GUI to see if
+        IPython request an exit handling
+        '''
+        self._ask_exit = True
+        
+    def _getHistoryMaxIndex(self):
+        '''
+        returns the max length of the history buffer
+
+        @return: history length
+        @rtype: int
+        '''
+        return len(self._IP.input_hist_raw)-1
+        
+    def _getHistory(self):
+        '''
+        Get's the command string of the current history level.
+
+        @return: Historic command string.
+        @rtype: string
+        '''
+        rv = self._IP.input_hist_raw[self._history_level].strip('\n')
+        return rv
+
+    def _pager(self,IP,text):
+        '''
+        This function is used as a callback replacment to IPython pager function
+
+        It puts the 'text' value inside the self._doc_text string that can be retrived via getDocText
+        function.
+        '''
+        self._doc_text = text
+    
+    def _raw_input(self, prompt=''):
+        '''
+        Custom raw_input() replacement. Get's current line from console buffer.
+
+        @param prompt: Prompt to print. Here for compatability as replacement.
+        @type prompt: string
+
+        @return: The current command line text.
+        @rtype: string
+        '''
+        return self._line_to_execute
+
+    def _execute(self):
+        '''
+        Executes the current line provided by the shell object.
+        '''
+        orig_stdout = sys.stdout
+        sys.stdout = IPython.Shell.Term.cout
+                
+        try:
+            line = self._IP.raw_input(None, self._iter_more)
+            if self._IP.autoindent:
+                self._IP.readline_startup_hook(None)
+
+        except KeyboardInterrupt:
+            self._IP.write('\nKeyboardInterrupt\n')
+            self._IP.resetbuffer()
+            # keep cache in sync with the prompt counter:
+            self._IP.outputcache.prompt_count -= 1
+
+            if self._IP.autoindent:
+                self._IP.indent_current_nsp = 0
+            self._iter_more = 0
+        except:
+            self._IP.showtraceback()
+        else:
+            self._iter_more = self._IP.push(line)
+            if (self._IP.SyntaxTB.last_syntax_error and
+                    self._IP.rc.autoedit_syntax):
+                self._IP.edit_syntax_error()
+        if self._iter_more:
+            self._prompt = str(self._IP.outputcache.prompt2).strip()
+            if self._IP.autoindent:
+                self._IP.readline_startup_hook(self._IP.pre_readline)
+        else:
+            self._prompt = str(self._IP.outputcache.prompt1).strip()
+            self._IP.indent_current_nsp = 0 #we set indentation to 0
+        sys.stdout = orig_stdout
+    
+    def _shell(self, ip, cmd):
+        '''
+        Replacement method to allow shell commands without them blocking.
+
+        @param ip: Ipython instance, same as self._IP
+        @type cmd: Ipython instance
+        @param cmd: Shell command to execute.
+        @type cmd: string
+        '''
+        stdin, stdout = os.popen4(cmd)
+        result = stdout.read().decode('cp437').encode(locale.getpreferredencoding())
+        #we use print command because the shell command is called inside IPython instance and thus is
+        #redirected to thread cout
+        #"\x01\x1b[1;36m\x02" <-- add colour to the text...
+        print "\x01\x1b[1;36m\x02"+result
+        stdout.close()
+        stdin.close()
+
+class WxConsoleView(stc.StyledTextCtrl):
+    '''
+    Specialized styled text control view for console-like workflow.
+    We use here a scintilla frontend thus it can be reused in any GUI taht supports
+    scintilla with less work.
+
+    @cvar ANSI_COLORS_BLACK: Mapping of terminal colors to X11 names.(with Black background)
+    @type ANSI_COLORS_BLACK: dictionary
+
+    @cvar ANSI_COLORS_WHITE: Mapping of terminal colors to X11 names.(with White background)
+    @type ANSI_COLORS_WHITE: dictionary
+
+    @ivar color_pat: Regex of terminal color pattern
+    @type color_pat: _sre.SRE_Pattern
+    '''
+    ANSI_STYLES_BLACK ={'0;30': [0,'WHITE'],             '0;31': [1,'RED'],
+                        '0;32': [2,'GREEN'],             '0;33': [3,'BROWN'],
+                        '0;34': [4,'BLUE'],              '0;35': [5,'PURPLE'],
+                        '0;36': [6,'CYAN'],              '0;37': [7,'LIGHT GREY'],
+                        '1;30': [8,'DARK GREY'],         '1;31': [9,'RED'],
+                        '1;32': [10,'SEA GREEN'],        '1;33': [11,'YELLOW'],
+                        '1;34': [12,'LIGHT BLUE'],       '1;35': [13,'MEDIUM VIOLET RED'],
+                        '1;36': [14,'LIGHT STEEL BLUE'], '1;37': [15,'YELLOW']}
+
+    ANSI_STYLES_WHITE ={'0;30': [0,'BLACK'],             '0;31': [1,'RED'],
+                        '0;32': [2,'GREEN'],             '0;33': [3,'BROWN'],
+                        '0;34': [4,'BLUE'],              '0;35': [5,'PURPLE'],
+                        '0;36': [6,'CYAN'],              '0;37': [7,'LIGHT GREY'],
+                        '1;30': [8,'DARK GREY'],         '1;31': [9,'RED'],
+                        '1;32': [10,'SEA GREEN'],        '1;33': [11,'YELLOW'],
+                        '1;34': [12,'LIGHT BLUE'],       '1;35': [13,'MEDIUM VIOLET RED'],
+                        '1;36': [14,'LIGHT STEEL BLUE'], '1;37': [15,'YELLOW']}
+
+    def __init__(self,parent,prompt,intro="",background_color="BLACK",pos=wx.DefaultPosition, ID = -1, size=wx.DefaultSize,
+                 style=0):
+        '''
+        Initialize console view.
+
+        @param parent: Parent widget
+        @param prompt: User specified prompt
+        @type intro: string
+        @param intro: User specified startup introduction string
+        @type intro: string
+        @param background_color: Can be BLACK or WHITE
+        @type background_color: string
+        @param other: init param of styledTextControl (can be used as-is)
+        '''
+        stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
+
+        ####### Scintilla configuration ##################################################
+        
+        # Ctrl + B or Ctrl + N can be used to zoomin/zoomout the text inside the widget
+        self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
+        self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
+
+        #we define platform specific fonts
+        if wx.Platform == '__WXMSW__':
+                faces = { 'times': 'Times New Roman',
+                          'mono' : 'Courier New',
+                          'helv' : 'Arial',
+                          'other': 'Comic Sans MS',
+                          'size' : 10,
+                          'size2': 8,
+                         }
+        elif wx.Platform == '__WXMAC__':
+            faces = { 'times': 'Times New Roman',
+                      'mono' : 'Monaco',
+                      'helv' : 'Arial',
+                      'other': 'Comic Sans MS',
+                      'size' : 10,
+                      'size2': 8,
+                     }
+        else:
+            faces = { 'times': 'Times',
+                      'mono' : 'Courier',
+                      'helv' : 'Helvetica',
+                      'other': 'new century schoolbook',
+                      'size' : 10,
+                      'size2': 8,
+                     }
+
+        #We draw a line at position 80
+        self.SetEdgeMode(stc.STC_EDGE_LINE)
+        self.SetEdgeColumn(80)
+        self.SetEdgeColour(wx.LIGHT_GREY)
+
+        #self.SetViewWhiteSpace(True)
+        #self.SetViewEOL(True)
+        self.SetEOLMode(stc.STC_EOL_CRLF)
+        #self.SetWrapMode(stc.STC_WRAP_CHAR)
+        #self.SetWrapMode(stc.STC_WRAP_WORD)
+        self.SetBufferedDraw(True)
+        #self.SetUseAntiAliasing(True)
+        self.SetLayoutCache(stc.STC_CACHE_PAGE)
+
+        self.EnsureCaretVisible()
+        
+        self.SetMargins(3,3) #text is moved away from border with 3px
+        # Suppressing Scintilla margins
+        self.SetMarginWidth(0,0)
+        self.SetMarginWidth(1,0)
+        self.SetMarginWidth(2,0)
+
+        # make some styles
+        if background_color != "BLACK":
+            self.background_color = "WHITE"
+            self.SetCaretForeground("BLACK")
+            self.ANSI_STYLES = self.ANSI_STYLES_WHITE
+        else:
+            self.background_color = background_color
+            self.SetCaretForeground("WHITE")
+            self.ANSI_STYLES = self.ANSI_STYLES_BLACK
+
+        self.StyleSetSpec(stc.STC_STYLE_DEFAULT, "fore:%s,back:%s,size:%d,face:%s" % (self.ANSI_STYLES['0;30'][1],
+                                                                                      self.background_color,
+                                                                                      faces['size'], faces['mono']))
+        self.StyleClearAll()
+        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  "fore:#FF0000,back:#0000FF,bold")
+        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold")
+    
+        for style in self.ANSI_STYLES.values():
+            self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])
+        
+        #######################################################################
+        
+        self.indent = 0
+        self.prompt_count = 0
+        self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
+        
+        self.write(intro)
+        self.setPrompt(prompt)
+        self.showPrompt()
+        
+        self.Bind(wx.EVT_KEY_DOWN, self._onKeypress, self)
+        #self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)
+
+    def write(self, text):
+        '''
+        Write given text to buffer.
+
+        @param text: Text to append.
+        @type text: string
+        '''
+        segments = self.color_pat.split(text)
+        segment = segments.pop(0)
+        self.StartStyling(self.getCurrentLineEnd(),0xFF)
+        self.AppendText(segment)
+        
+        if segments:
+            ansi_tags = self.color_pat.findall(text)
+
+            for tag in ansi_tags:
+                i = segments.index(tag)
+                self.StartStyling(self.getCurrentLineEnd(),0xFF)
+                self.AppendText(segments[i+1])
+
+                if tag != '0':
+                    self.SetStyling(len(segments[i+1]),self.ANSI_STYLES[tag][0])
+
+                segments.pop(i)
+                
+        self.moveCursor(self.getCurrentLineEnd())
+         
+    def getPromptLen(self):
+        '''
+        Return the length of current prompt
+        '''
+        return len(str(self.prompt_count)) + 7
+
+    def setPrompt(self,prompt):
+        self.prompt = prompt
+
+    def setIndentation(self,indentation):
+        self.indent = indentation
+        
+    def setPromptCount(self,count):
+        self.prompt_count = count
+        
+    def showPrompt(self):
+        '''
+        Prints prompt at start of line.
+
+        @param prompt: Prompt to print.
+        @type prompt: string
+        '''
+        self.write(self.prompt)
+        #now we update the position of end of prompt
+        self.current_start = self.getCurrentLineEnd()
+        
+        autoindent = self.indent*' '
+        autoindent = autoindent.replace('    ','\t')
+        self.write(autoindent)
+        
+    def changeLine(self, text):
+        '''
+        Replace currently entered command line with given text.
+
+        @param text: Text to use as replacement.
+        @type text: string
+        '''
+        self.SetSelection(self.getCurrentPromptStart(),self.getCurrentLineEnd())
+        self.ReplaceSelection(text)
+        self.moveCursor(self.getCurrentLineEnd())
+
+    def getCurrentPromptStart(self):
+        return self.current_start
+
+    def getCurrentLineStart(self):
+        return self.GotoLine(self.LineFromPosition(self.GetCurrentPos()))
+
+    def getCurrentLineEnd(self):
+        return self.GetLength()
+
+    def getCurrentLine(self):
+        '''
+        Get text in current command line.
+
+        @return: Text of current command line.
+        @rtype: string
+        '''
+        return self.GetTextRange(self.getCurrentPromptStart(),
+                                 self.getCurrentLineEnd())
+
+    def showReturned(self, text):
+        '''
+        Show returned text from last command and print new prompt.
+
+        @param text: Text to show.
+        @type text: string
+        '''
+        self.write('\n'+text)
+        if text:
+            self.write('\n')
+        self.showPrompt()
+
+    def moveCursorOnNewValidKey(self):
+        #If cursor is at wrong position put it at last line...
+        if self.GetCurrentPos() < self.getCurrentPromptStart():
+            self.GotoPos(self.getCurrentPromptStart())
+        
+    def removeFromTo(self,from_pos,to_pos):
+        if from_pos < to_pos:
+            self.SetSelection(from_pos,to_pos)
+            self.DeleteBack()
+                                                          
+    def removeCurrentLine(self):
+        self.LineDelete()
+        
+    def moveCursor(self,position):
+        self.GotoPos(position)
+
+    def getCursorPos(self):
+        return self.GetCurrentPos()
+
+    def selectFromTo(self,from_pos,to_pos):
+        self.SetSelectionStart(from_pos)
+        self.SetSelectionEnd(to_pos)
+        
+    def writeHistory(self,history):
+        self.removeFromTo(self.getCurrentPromptStart(),self.getCurrentLineEnd())
+        self.changeLine(history)
+        
+    def writeCompletion(self, possibilities):
+        max_len = len(max(possibilities,key=len))
+        max_symbol =' '*max_len
+        
+        #now we check how much symbol we can put on a line...
+        cursor_pos = self.getCursorPos()
+        test_buffer = max_symbol + ' '*4
+        current_lines = self.GetLineCount()
+        
+        allowed_symbols = 80/len(test_buffer)
+        if allowed_symbols == 0:
+                allowed_symbols = 1
+        
+        pos = 1
+        buf = ''
+        for symbol in possibilities:
+            #buf += symbol+'\n'#*spaces)
+            if pos<allowed_symbols:
+                spaces = max_len - len(symbol) + 4
+                buf += symbol+' '*spaces
+                pos += 1
+            else:
+                buf+=symbol+'\n'
+                pos = 1
+        self.write(buf)
+                             
+    def _onKeypress(self, event, skip=True):
+        '''
+        Key press callback used for correcting behavior for console-like
+        interfaces. For example 'home' should go to prompt, not to begining of
+        line.
+
+        @param widget: Widget that key press accored in.
+        @type widget: gtk.Widget
+        @param event: Event object
+        @type event: gtk.gdk.Event
+
+        @return: Return True if event as been catched.
+        @rtype: boolean
+        '''
+	
+        if event.GetKeyCode() == wx.WXK_HOME:
+            if event.Modifiers == wx.MOD_NONE:
+                self.moveCursorOnNewValidKey()
+                self.moveCursor(self.getCurrentPromptStart())
+                return True
+            elif event.Modifiers == wx.MOD_SHIFT:
+                self.moveCursorOnNewValidKey()
+                self.selectFromTo(self.getCurrentPromptStart(),self.getCursorPos())
+                return True
+            else:
+                return False
+
+        elif event.GetKeyCode() == wx.WXK_LEFT:
+            if event.Modifiers == wx.MOD_NONE:
+                self.moveCursorOnNewValidKey()
+                
+                self.moveCursor(self.getCursorPos()-1)
+                if self.getCursorPos() < self.getCurrentPromptStart():
+                    self.moveCursor(self.getCurrentPromptStart())
+                return True
+
+        elif event.GetKeyCode() == wx.WXK_BACK:
+            self.moveCursorOnNewValidKey()
+	    if self.getCursorPos() > self.getCurrentPromptStart():
+                self.removeFromTo(self.getCursorPos()-1,self.getCursorPos())
+	    return True
+        
+        if skip:
+            if event.GetKeyCode() not in [wx.WXK_PAGEUP,wx.WXK_PAGEDOWN] and event.Modifiers == wx.MOD_NONE:
+                self.moveCursorOnNewValidKey()
+                
+            event.Skip()
+            return True
+        return False
+
+    def OnUpdateUI(self, evt):
+        # check for matching braces
+        braceAtCaret = -1
+        braceOpposite = -1
+        charBefore = None
+        caretPos = self.GetCurrentPos()
+
+        if caretPos > 0:
+            charBefore = self.GetCharAt(caretPos - 1)
+            styleBefore = self.GetStyleAt(caretPos - 1)
+
+        # check before
+        if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:
+            braceAtCaret = caretPos - 1
+
+        # check after
+        if braceAtCaret < 0:
+            charAfter = self.GetCharAt(caretPos)
+            styleAfter = self.GetStyleAt(caretPos)
+
+            if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
+                braceAtCaret = caretPos
+
+        if braceAtCaret >= 0:
+            braceOpposite = self.BraceMatch(braceAtCaret)
+
+        if braceAtCaret != -1  and braceOpposite == -1:
+            self.BraceBadLight(braceAtCaret)
+        else:
+            self.BraceHighlight(braceAtCaret, braceOpposite)
+            #pt = self.PointFromPosition(braceOpposite)
+            #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))
+            #print pt
+            #self.Refresh(False)
+        
+class WxIPythonViewPanel(wx.Panel):
+    '''
+    This is wx.Panel that embbed the IPython Thread and the wx.StyledTextControl
+    If you want to port this to any other GUI toolkit, just replace the WxConsoleView
+    by YOURGUIConsoleView and make YOURGUIIPythonView derivate from whatever container you want.
+    I've choosed to derivate from a wx.Panel because it seems to be ore usefull
+    Any idea to make it more 'genric' welcomed.
+    '''
+    def __init__(self,parent,exit_handler=None,intro=None,background_color="BLACK"):
+        '''
+        Initialize.
+        Instanciate an IPython thread.
+        Instanciate a WxConsoleView.
+        Redirect I/O to console.
+        '''
+        wx.Panel.__init__(self,parent,-1)
+
+        ### IPython thread instanciation ###
+        self.cout = StringIO()
+        self.IP = IterableIPShell(cout=self.cout,cerr=self.cout,
+                             exit_handler = exit_handler,
+                             time_loop = 0.1)
+        self.IP.start()
+        
+        ### IPython wx console view instanciation ###
+        #If user didn't defined an intro text, we create one for him
+        #If you really wnat an empty intrp just call wxIPythonViewPanel with intro=''
+        if intro == None:
+            welcome_text = "Welcome to WxIPython Shell.\n\n"
+            welcome_text+= self.IP.getBanner()
+            welcome_text+= "!command  -> Execute command in shell\n"
+            welcome_text+= "TAB       -> Autocompletion\n"
+
+        self.text_ctrl = WxConsoleView(self,
+                                       self.IP.getPrompt(),
+                                       intro=welcome_text,
+                                       background_color=background_color)
+        
+        self.text_ctrl.Bind(wx.EVT_KEY_DOWN, self.keyPress, self.text_ctrl)
+
+        ### making the layout of the panel ###
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(self.text_ctrl, 1, wx.EXPAND)
+        self.SetAutoLayout(True)
+        sizer.Fit(self)
+        sizer.SetSizeHints(self)
+        self.SetSizer(sizer)
+        #and we focus on the widget :)
+        self.SetFocus()
+
+        ### below are the thread communication variable ###
+        # the IPython thread is managed via unidirectional communication.
+        # It's a thread slave that can't interact by itself with the GUI.
+        # When the GUI event loop is done runStateMachine() is called and the thread sate is then
+        # managed.
+        
+        #Initialize the state machine #kept for information
+        #self.states = ['IDLE',
+        #               'DO_EXECUTE_LINE',
+        #               'WAIT_END_OF_EXECUTION',
+        #               'SHOW_DOC',
+        #               'SHOW_PROMPT']
+        
+        self.cur_state = 'IDLE'
+	self.pager_state = 'DONE'
+        #wx.CallAfter(self.runStateMachine)
+
+        # This creates a new Event class and a EVT binder function
+        (self.AskExitEvent, EVT_ASK_EXIT) = wx.lib.newevent.NewEvent()
+
+        self.Bind(wx.EVT_IDLE, self.runStateMachine)
+        self.Bind(EVT_ASK_EXIT, exit_handler)
+        
+    def __del__(self):
+        self.IP.shutdown()
+        self.IP.join()
+        WxConsoleView.__del__()
+        
+    #---------------------------- IPython Thread Management ---------------------------------------
+    def runStateMachine(self,event):
+        #print >>self.sys_stdout,"state:",self.cur_state
+        self.updateStatusTracker(self.cur_state)
+        
+        if self.cur_state == 'DO_EXECUTE_LINE':
+            #print >>self.sys_stdout,"command:",self.getCurrentLine()
+            self.IP.doExecute(self.text_ctrl.getCurrentLine().replace('\t',' '*4))
+            self.updateHistoryTracker(self.text_ctrl.getCurrentLine())
+            self.cur_state = 'WAIT_END_OF_EXECUTION'
+        
+        if self.cur_state == 'WAIT_END_OF_EXECUTION':
+            if self.IP.isExecuteDone():
+                self.doc = self.IP.getDocText()
+                if self.IP.getAskExit():
+                    evt = self.AskExitEvent()
+                    wx.PostEvent(self, evt)
+                    self.IP.clearAskExit()
+                if self.doc:
+                    self.pager_state = 'INIT'
+		    self.cur_state = 'SHOW_DOC'
+                else:
+                    self.cur_state = 'SHOW_PROMPT'
+                
+        if self.cur_state == 'SHOW_PROMPT':
+            self.text_ctrl.setPrompt(self.IP.getPrompt())
+            self.text_ctrl.setIndentation(self.IP.getIndentation())
+            self.text_ctrl.setPromptCount(self.IP.getPromptCount())
+            rv = self.cout.getvalue()
+            if rv: rv = rv.strip('\n')
+            self.text_ctrl.showReturned(rv)
+            self.cout.truncate(0)
+	    self.IP.initHistoryIndex()
+            self.cur_state = 'IDLE'
+            
+        if self.cur_state == 'SHOW_DOC':
+            self.pager(self.doc)
+            if self.pager_state == 'DONE':
+                self.cur_state = 'SHOW_PROMPT'
+                
+        event.Skip()
+
+    #---------------------------- IPython pager ---------------------------------------
+    def pager(self,text):#,start=0,screen_lines=0,pager_cmd = None):
+        if self.pager_state == 'WAITING':
+		#print >>self.sys_stdout,"PAGER waiting"
+        	return
+	
+	if self.pager_state == 'INIT':
+		#print >>self.sys_stdout,"PAGER state:",self.pager_state
+        	self.pager_lines = text[7:].split('\n')
+		self.pager_nb_lines = len(self.pager_lines)
+		self.pager_index = 0
+		self.pager_do_remove = False
+		self.text_ctrl.write('\n')
+		self.pager_state = 'PROCESS_LINES'
+		
+	if self.pager_state == 'PROCESS_LINES':
+        	#print >>self.sys_stdout,"PAGER state:",self.pager_state
+        	if self.pager_do_remove == True:
+			self.text_ctrl.removeCurrentLine()
+			self.pager_do_remove = False
+	
+		if self.pager_nb_lines > 10:
+	                #print >>self.sys_stdout,"PAGER processing 10 lines"
+			if self.pager_index > 0:
+				self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
+			else:
+				self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
+			
+			for line in self.pager_lines[self.pager_index+1:self.pager_index+9]:
+				self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
+			self.pager_index += 10
+			self.pager_nb_lines -= 10
+			self.text_ctrl.write("--- Push Enter to continue or 'Q' to quit---")
+			self.pager_do_remove = True
+			self.pager_state = 'WAITING'
+			return
+        	else:
+	                #print >>self.sys_stdout,"PAGER processing last lines"
+			if self.pager_nb_lines > 0:
+				if self.pager_index > 0:
+					self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
+				else:
+					self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
+				
+				self.pager_index += 1
+                                self.pager_nb_lines -= 1
+	              	if self.pager_nb_lines > 0:
+        	        	for line in self.pager_lines[self.pager_index:]:
+					self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
+                			self.pager_nb_lines = 0
+			self.pager_state = 'DONE'          
+                
+    #---------------------------- Key Handler --------------------------------------------
+    def keyPress(self, event):
+        '''
+        Key press callback with plenty of shell goodness, like history,
+        autocompletions, etc.
+        '''
+	
+        if event.GetKeyCode() == ord('C'):
+            if event.Modifiers == wx.MOD_CONTROL:
+                if self.cur_state == 'WAIT_END_OF_EXECUTION':
+                    #we raise an exception inside the IPython thread container
+                    self.IP.raise_exc(KeyboardInterrupt)
+                    return
+                
+        if event.KeyCode == wx.WXK_RETURN:
+            if self.cur_state == 'IDLE':
+                #we change the state ot the state machine
+                self.cur_state = 'DO_EXECUTE_LINE'
+                return
+            if self.pager_state == 'WAITING':
+                self.pager_state = 'PROCESS_LINES'
+                return
+            
+        if event.GetKeyCode() in [ord('q'),ord('Q')]:
+            if self.pager_state == 'WAITING':
+                self.pager_state = 'DONE'
+                return
+            
+        #scroll_position = self.text_ctrl.GetScrollPos(wx.VERTICAL)
+	if self.cur_state == 'IDLE':
+            if event.KeyCode == wx.WXK_UP:
+                history = self.IP.historyBack()
+                self.text_ctrl.writeHistory(history)
+                return
+            if event.KeyCode == wx.WXK_DOWN:
+                history = self.IP.historyForward()
+                self.text_ctrl.writeHistory(history)
+                return
+            if event.KeyCode == wx.WXK_TAB:
+                #if line empty we disable tab completion
+                if not self.text_ctrl.getCurrentLine().strip():
+                    self.text_ctrl.write('\t')
+                    return
+                completed, possibilities = self.IP.complete(self.text_ctrl.getCurrentLine())
+                if len(possibilities) > 1:
+                    cur_slice = self.text_ctrl.getCurrentLine()
+                    self.text_ctrl.write('\n')
+                    self.text_ctrl.writeCompletion(possibilities)
+                    self.text_ctrl.write('\n')
+
+                    self.text_ctrl.showPrompt()
+                    self.text_ctrl.write(cur_slice)
+                self.text_ctrl.changeLine(completed or cur_slice)
+                
+                return
+            event.Skip()
+	
+    #---------------------------- Hook Section --------------------------------------------
+    def updateHistoryTracker(self,command_line):
+        '''
+        Default history tracker (does nothing)
+        '''
+        pass
+    
+    def setHistoryTrackerHook(self,func):
+        '''
+        Define a new history tracker
+        '''
+        self.updateHistoryTracker = func
+    def updateStatusTracker(self,status):
+        '''
+        Default status tracker (does nothing)
+        '''
+        pass
+    
+    def setStatusTrackerHook(self,func):
+        '''
+        Define a new status tracker
+        '''
+        self.updateStatusTracker = func
+    
diff --git a/IPython/gui/wx/wxIPython.py b/IPython/gui/wx/wxIPython.py
new file mode 100644
index 0000000..18d0fd7
--- /dev/null
+++ b/IPython/gui/wx/wxIPython.py
@@ -0,0 +1,201 @@
+#!/usr/bin/python
+# -*- coding: iso-8859-15 -*-
+
+import wx.aui
+import wx.py
+from wx.lib.wordwrap import wordwrap
+
+from ipython_view import *
+from ipython_history import *
+
+__version__ = 0.8
+__author__  = "Laurent Dufrechou"
+__email__   = "laurent.dufrechou _at_ gmail.com"
+__license__ = "BSD"
+
+#-----------------------------------------
+# Creating one main frame for our 
+# application with movables windows
+#-----------------------------------------
+class MyFrame(wx.Frame):
+    """Creating one main frame for our 
+    application with movables windows"""
+    def __init__(self, parent=None, id=-1, title="WxIPython", pos=wx.DefaultPosition,
+                size=(800, 600), style=wx.DEFAULT_FRAME_STYLE):
+        wx.Frame.__init__(self, parent, id, title, pos, size, style)
+        self._mgr = wx.aui.AuiManager()
+        
+        # notify PyAUI which frame to use
+        self._mgr.SetManagedWindow(self)
+        
+        #create differents panels and make them persistant 
+        self.history_panel    = IPythonHistoryPanel(self)
+        
+        self.ipython_panel    = WxIPythonViewPanel(self,self.OnExitDlg,
+                                                   background_color = "BLACK")
+        
+        #self.ipython_panel    = WxIPythonViewPanel(self,self.OnExitDlg,
+        #                                           background_color = "WHITE")
+        
+        self.ipython_panel.setHistoryTrackerHook(self.history_panel.write)
+        self.ipython_panel.setStatusTrackerHook(self.updateStatus)
+        
+        self.statusbar = self.createStatus()
+        self.createMenu()
+        
+        ########################################################################
+        ### add the panes to the manager
+        # main panels
+        self._mgr.AddPane(self.ipython_panel , wx.CENTER, "IPython Shell")
+        self._mgr.AddPane(self.history_panel , wx.RIGHT,  "IPython history")
+        
+        # now we specify some panel characteristics
+        self._mgr.GetPane(self.ipython_panel).CaptionVisible(True);
+        self._mgr.GetPane(self.history_panel).CaptionVisible(True);
+        self._mgr.GetPane(self.history_panel).MinSize((200,400));
+                
+        
+        
+        # tell the manager to "commit" all the changes just made
+        self._mgr.Update()
+
+        #global event handling
+        self.Bind(wx.EVT_CLOSE, self.OnClose)
+        self.Bind(wx.EVT_MENU,  self.OnClose,id=wx.ID_EXIT)
+        self.Bind(wx.EVT_MENU,  self.OnShowIPythonPanel,id=wx.ID_HIGHEST+1)
+        self.Bind(wx.EVT_MENU,  self.OnShowHistoryPanel,id=wx.ID_HIGHEST+2)
+        self.Bind(wx.EVT_MENU,  self.OnShowAbout, id=wx.ID_HIGHEST+3)
+        self.Bind(wx.EVT_MENU,  self.OnShowAllPanel,id=wx.ID_HIGHEST+6)
+
+        warn_text = 'Hello from IPython and wxPython.\n'
+        warn_text +='Please Note that this work is still EXPERIMENTAL\n'
+        warn_text +='It does NOT emulate currently all the IPython functions.\n'
+        
+        dlg = wx.MessageDialog(self,
+                               warn_text,
+                               'Warning Box',
+                               wx.OK | wx.ICON_INFORMATION
+                               )
+        dlg.ShowModal()
+        dlg.Destroy()
+     
+    def createMenu(self):
+        """local method used to create one menu bar"""
+        
+        mb = wx.MenuBar()
+
+        file_menu = wx.Menu()
+        file_menu.Append(wx.ID_EXIT, "Exit")
+        
+        view_menu = wx.Menu()
+        view_menu.Append(wx.ID_HIGHEST+1, "Show IPython Panel")
+        view_menu.Append(wx.ID_HIGHEST+2, "Show History Panel")
+        view_menu.AppendSeparator()
+        view_menu.Append(wx.ID_HIGHEST+6, "Show All")
+        
+        about_menu = wx.Menu()
+        about_menu.Append(wx.ID_HIGHEST+3, "About")
+
+        #view_menu.AppendSeparator()
+        #options_menu = wx.Menu()
+        #options_menu.AppendCheckItem(wx.ID_HIGHEST+7, "Allow Floating")
+        #options_menu.AppendCheckItem(wx.ID_HIGHEST+8, "Transparent Hint")
+        #options_menu.AppendCheckItem(wx.ID_HIGHEST+9, "Transparent Hint Fade-in")
+        
+        
+        mb.Append(file_menu, "File")
+        mb.Append(view_menu, "View")
+        mb.Append(about_menu, "About")
+        #mb.Append(options_menu, "Options")
+        
+        self.SetMenuBar(mb)
+
+    def createStatus(self):
+        statusbar = self.CreateStatusBar(2, wx.ST_SIZEGRIP)
+        statusbar.SetStatusWidths([-2, -3])
+        statusbar.SetStatusText("Ready", 0)
+        statusbar.SetStatusText("WxIPython "+str(__version__), 1)
+        return statusbar
+
+    def updateStatus(self,text):
+        states = {'IDLE':'Idle',
+                  'DO_EXECUTE_LINE':'Send command',
+                  'WAIT_END_OF_EXECUTION':'Running command',
+                  'SHOW_DOC':'Showing doc',
+                  'SHOW_PROMPT':'Showing prompt'}
+        self.statusbar.SetStatusText(states[text], 0)
+        
+    def OnClose(self, event):
+        """#event used to close program  """
+        # deinitialize the frame manager
+        self._mgr.UnInit()
+        self.Destroy()        
+        event.Skip()
+    
+    def OnExitDlg(self, event):
+        dlg = wx.MessageDialog(self, 'Are you sure you want to quit WxIPython',
+                                'WxIPython exit',
+                                wx.ICON_QUESTION |
+                                wx.YES_NO | wx.NO_DEFAULT
+                                )
+        if dlg.ShowModal() == wx.ID_YES:
+            dlg.Destroy()
+            self._mgr.UnInit()
+            self.Destroy()
+        dlg.Destroy()
+      
+    #event to display IPython pannel      
+    def OnShowIPythonPanel(self,event):
+        """ #event to display Boxpannel """
+        self._mgr.GetPane(self.ipython_panel).Show(True)
+        self._mgr.Update()  
+    #event to display History pannel      
+    def OnShowHistoryPanel(self,event):
+        self._mgr.GetPane(self.history_panel).Show(True)
+        self._mgr.Update()  
+         
+    def OnShowAllPanel(self,event):
+        """#event to display all Pannels"""
+        self._mgr.GetPane(self.ipython_panel).Show(True)
+        self._mgr.GetPane(self.history_panel).Show(True)
+        self._mgr.Update()
+
+    def OnShowAbout(self, event):
+        # First we create and fill the info object
+        info = wx.AboutDialogInfo()
+        info.Name = "WxIPython"
+        info.Version = str(__version__)
+        info.Copyright = "(C) 2007 Laurent Dufrechou"
+        info.Description = wordwrap(
+            "A Gui that embbed a multithreaded IPython Shell",
+            350, wx.ClientDC(self))
+        info.WebSite = ("http://ipython.scipy.org/", "IPython home page")
+        info.Developers = [ "Laurent Dufrechou" ]
+        licenseText="BSD License.\nAll rights reserved. This program and the accompanying materials are made available under the terms of the BSD which accompanies this distribution, and is available at http://www.opensource.org/licenses/bsd-license.php"
+        info.License = wordwrap(licenseText, 500, wx.ClientDC(self))
+
+        # Then we call wx.AboutBox giving it that info object
+        wx.AboutBox(info) 
+        
+#-----------------------------------------
+#Creating our application
+#----------------------------------------- 
+class MyApp(wx.PySimpleApp):
+    """Creating our application"""
+    def __init__(self):
+        wx.PySimpleApp.__init__(self)
+        
+        self.frame = MyFrame()
+        self.frame.Show()
+        
+#-----------------------------------------
+#Main loop
+#----------------------------------------- 
+def main():
+    app = MyApp()
+    app.SetTopWindow(app.frame)
+    app.MainLoop()
+
+#if launched as main program run this
+if __name__ == '__main__':
+    main()
diff --git a/IPython/history.py b/IPython/history.py
new file mode 100644
index 0000000..acfea45
--- /dev/null
+++ b/IPython/history.py
@@ -0,0 +1,272 @@
+# -*- coding: utf-8 -*-
+
+""" History related magics and functionality """
+
+# Stdlib imports
+import fnmatch
+import os
+
+# IPython imports
+from IPython.genutils import Term, ask_yes_no
+
+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.
+
+      -t: (default) print the 'translated' history, as IPython understands it.
+      IPython filters your input and converts it all into valid Python source
+      before executing it (things like magics or aliases are turned into
+      function calls, for example). With this option, you'll see the native
+      history instead of the user-entered version: '%cd /' will be seen as
+      '_ip.magic("%cd /")' instead of '%cd /'.
+      
+      -r: print the 'raw' history, i.e. the actual commands you typed.
+      
+      -g: treat the arg as a pattern to grep for in (full) history.
+      This includes the "shadow history" (almost all commands ever written).
+      Use '%hist -g' to show full shadow history (may be very long).
+      In shadow history, every index nuwber starts with 0.
+
+      -f FILENAME: instead of printing the output to the screen, redirect it to
+       the given file.  The file is always overwritten, though IPython asks for
+       confirmation first if it already exists.
+      
+
+    """
+
+    ip = self.api
+    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,'gntsrf:',mode='list')
+
+    # Check if output to specific file was requested.
+    try:
+        outfname = opts['f']
+    except KeyError:
+        outfile = Term.cout
+        # We don't want to close stdout at the end!
+        close_at_end = False
+    else:
+        if os.path.exists(outfname):
+            ans = ask_yes_no("File %r exists. Overwrite?" % outfname)
+            if not ans:
+                print 'Aborting.'
+                return
+            else:
+                outfile = open(outfname,'w')
+                close_at_end = True
+                
+
+    if opts.has_key('t'):
+        input_hist = shell.input_hist
+    elif opts.has_key('r'):
+        input_hist = shell.input_hist_raw
+    else:
+        input_hist = shell.input_hist
+        
+    
+    default_length = 40
+    pattern = None
+    if opts.has_key('g'):
+        init = 1
+        final = len(input_hist)
+        parts = parameter_s.split(None,1)
+        if len(parts) == 1:
+            parts += '*'
+        head, pattern = parts
+        pattern = "*" + pattern + "*"
+    elif 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')
+    
+    found = False
+    if pattern is not None:
+        sh = ip.IP.shadowhist.all()
+        for idx, s in sh:
+            if fnmatch.fnmatch(s, pattern):
+                print "0%d: %s" %(idx, s)
+                found = True
+    
+    if found:
+        print "==="
+        print "shadow history ends, fetch by %rep <number> (must start with 0)"
+        print "=== start of normal history ==="
+        
+    for in_num in range(init,final):        
+        inline = input_hist[in_num]
+        if pattern is not None and not fnmatch.fnmatch(inline, pattern):
+            continue
+            
+        multiline = int(inline.count('\n') > 1)
+        if print_nums:
+            print >> outfile, \
+                  '%s:%s' % (str(in_num).ljust(width),line_sep[multiline]),
+        print >> outfile, inline,
+
+    if close_at_end:
+        outfile.close()
+
+
+
+def magic_hist(self, parameter_s=''):
+    """Alternate name for %history."""
+    return self.magic_history(parameter_s)
+
+
+
+def rep_f(self, arg):
+    r""" Repeat a command, or get command to input line for editing
+
+    - %rep (no arguments):
+    
+    Place a string version of last computation result (stored in the special '_'
+    variable) to the next input prompt. Allows you to create elaborate command
+    lines without using copy-paste::
+    
+        $ l = ["hei", "vaan"]       
+        $ "".join(l)        
+        ==> heivaan        
+        $ %rep        
+        $ heivaan_ <== cursor blinking    
+    
+    %rep 45
+    
+    Place history line 45 to next input prompt. Use %hist to find out the
+    number.
+    
+    %rep 1-4 6-7 3
+    
+    Repeat the specified lines immediately. Input slice syntax is the same as
+    in %macro and %save.
+    
+    %rep foo
+    
+    Place the most recent line that has the substring "foo" to next input.
+    (e.g. 'svn ci -m foobar').
+    
+    """
+    
+    
+    opts,args = self.parse_options(arg,'',mode='list')
+    ip = self.api    
+    if not args:
+        ip.set_next_input(str(ip.user_ns["_"]))
+        return
+
+    if len(args) == 1 and not '-' in args[0]:
+        arg = args[0]
+        if len(arg) > 1 and arg.startswith('0'):
+            # get from shadow hist
+            num = int(arg[1:])
+            line = self.shadowhist.get(num)
+            ip.set_next_input(str(line))
+            return
+        try:
+            num = int(args[0])
+            ip.set_next_input(str(ip.IP.input_hist_raw[num]).rstrip())
+            return
+        except ValueError:
+            pass
+        
+        for h in reversed(self.shell.input_hist_raw):
+            if 'rep' in h:
+                continue
+            if fnmatch.fnmatch(h,'*' + arg + '*'):
+                ip.set_next_input(str(h).rstrip())
+                return
+        
+
+    try:
+        lines = self.extract_input_slices(args, True)
+        print "lines",lines
+        ip.runlines(lines)
+    except ValueError:
+        print "Not found in recent history:", args
+        
+
+
+_sentinel = object()
+
+class ShadowHist:
+    def __init__(self,db):
+        # cmd => idx mapping
+        self.curidx = 0
+        self.db = db
+    
+    def inc_idx(self):
+        idx = self.db.get('shadowhist_idx', 1)
+        self.db['shadowhist_idx'] = idx + 1
+        return idx
+        
+    def add(self, ent):
+        old = self.db.hget('shadowhist', ent, _sentinel)
+        if old is not _sentinel:
+            return
+        newidx = self.inc_idx()
+        #print "new",newidx # dbg
+        self.db.hset('shadowhist',ent, newidx)
+    
+    def all(self):
+        d = self.db.hdict('shadowhist')
+        items = [(i,s) for (s,i) in d.items()]
+        items.sort()
+        return items
+
+    def get(self, idx):
+        all = self.all()
+        
+        for k, v in all:
+            #print k,v
+            if k == idx:
+                return v
+
+def test_shist():
+    from IPython.Extensions import pickleshare
+    db = pickleshare.PickleShareDB('~/shist')
+    s = ShadowHist(db)
+    s.add('hello')
+    s.add('world')
+    s.add('hello')
+    s.add('hello')
+    s.add('karhu')
+    print "all",s.all()
+    print s.get(2)
+
+def init_ipython(ip):
+    ip.expose_magic("rep",rep_f)        
+    ip.expose_magic("hist",magic_hist)            
+    ip.expose_magic("history",magic_history)
+
+    import ipy_completers
+    ipy_completers.quick_completer('%hist' ,'-g -t -r -n')
+#test_shist()
diff --git a/IPython/hooks.py b/IPython/hooks.py
new file mode 100644
index 0000000..517e4b1
--- /dev/null
+++ b/IPython/hooks.py
@@ -0,0 +1,237 @@
+"""hooks for IPython.
+
+In Python, it is possible to overwrite any method of any object if you really
+want to.  But IPython exposes a few 'hooks', methods which are _designed_ to
+be overwritten by users for customization purposes.  This module defines the
+default versions of all such hooks, which get used by IPython if not
+overridden by the user.
+
+hooks are simple functions, but they should be declared with 'self' as their
+first argument, because when activated they are registered into IPython as
+instance methods.  The self argument will be the IPython running instance
+itself, so hooks have full access to the entire IPython object.
+
+If you wish to define a new hook and activate it, you need to put the
+necessary code into a python file which can be either imported or execfile()'d
+from within your ipythonrc configuration.
+
+For example, suppose that you have a module called 'myiphooks' in your
+PYTHONPATH, which contains the following definition:
+
+import os
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+def calljed(self,filename, linenum):
+    "My editor hook calls the jed editor directly."
+    print "Calling my own editor, jed ..."
+    os.system('jed +%d %s' % (linenum,filename))
+
+ip.set_hook('editor', calljed)
+
+You can then enable the functionality by doing 'import myiphooks'
+somewhere in your configuration files or ipython command line.
+
+$Id: hooks.py 2998 2008-01-31 10:06:04Z vivainio $"""
+
+#*****************************************************************************
+#       Copyright (C) 2005 Fernando Perez. <fperez@colorado.edu>
+#
+#  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
+from IPython import ipapi
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+__version__ = Release.version
+
+import os,bisect
+from genutils import Term,shell
+from pprint import PrettyPrinter
+
+# List here all the default hooks.  For now it's just the editor functions
+# but over time we'll move here all the public API for user-accessible things.
+__all__ = ['editor', 'fix_error_editor', 'result_display',
+           'input_prefilter', 'shutdown_hook', 'late_startup_hook',
+           'generate_prompt', 'generate_output_prompt','shell_hook',
+           'show_in_pager']
+
+pformat = PrettyPrinter().pformat
+
+def editor(self,filename, linenum=None):
+    """Open the default editor at the given filename and linenumber.
+
+    This is IPython's default editor hook, you can use it as an example to
+    write your own modified one.  To set your own editor function as the
+    new editor hook, call ip.set_hook('editor',yourfunc)."""
+
+    # IPython configures a default editor at startup by reading $EDITOR from
+    # the environment, and falling back on vi (unix) or notepad (win32).
+    editor = self.rc.editor
+    
+    # marker for at which line to open the file (for existing objects)
+    if linenum is None or editor=='notepad':
+        linemark = ''
+    else:
+        linemark = '+%d' % int(linenum)
+    
+    # Enclose in quotes if necessary and legal
+    if ' ' in editor and os.path.isfile(editor) and editor[0] != '"':
+        editor = '"%s"' % editor
+        
+    # Call the actual editor
+    os.system('%s %s %s' % (editor,linemark,filename))
+
+import tempfile
+def fix_error_editor(self,filename,linenum,column,msg):
+    """Open the editor at the given filename, linenumber, column and 
+    show an error message. This is used for correcting syntax errors.
+    The current implementation only has special support for the VIM editor,
+    and falls back on the 'editor' hook if VIM is not used.
+
+    Call ip.set_hook('fix_error_editor',youfunc) to use your own function,
+    """
+    def vim_quickfix_file():
+        t = tempfile.NamedTemporaryFile()
+        t.write('%s:%d:%d:%s\n' % (filename,linenum,column,msg))
+        t.flush()
+        return t
+    if os.path.basename(self.rc.editor) != 'vim':
+        self.hooks.editor(filename,linenum)
+        return
+    t = vim_quickfix_file()
+    try:
+        os.system('vim --cmd "set errorformat=%f:%l:%c:%m" -q ' + t.name)
+    finally:
+        t.close()
+
+
+class CommandChainDispatcher:
+    """ Dispatch calls to a chain of commands until some func can handle it
+    
+    Usage: instantiate, execute "add" to add commands (with optional
+    priority), execute normally via f() calling mechanism.
+    
+    """
+    def __init__(self,commands=None):
+        if commands is None:
+            self.chain = []
+        else:
+            self.chain = commands
+            
+            
+    def __call__(self,*args, **kw):
+        """ Command chain is called just like normal func. 
+        
+        This will call all funcs in chain with the same args as were given to this
+        function, and return the result of first func that didn't raise
+        TryNext """
+        
+        for prio,cmd in self.chain:
+            #print "prio",prio,"cmd",cmd #dbg
+            try:
+                ret = cmd(*args, **kw)
+                return ret
+            except ipapi.TryNext, exc:
+                if exc.args or exc.kwargs:
+                    args = exc.args
+                    kw = exc.kwargs
+        # if no function will accept it, raise TryNext up to the caller
+        raise ipapi.TryNext
+                
+    def __str__(self):
+        return str(self.chain)
+    
+    def add(self, func, priority=0):
+        """ Add a func to the cmd chain with given priority """
+        bisect.insort(self.chain,(priority,func))
+
+    def __iter__(self):
+        """ Return all objects in chain.
+        
+        Handy if the objects are not callable.
+        """
+        return iter(self.chain)
+    
+def result_display(self,arg):
+    """ Default display hook.
+    
+    Called for displaying the result to the user.
+    """
+    
+    if self.rc.pprint:
+        out = pformat(arg)
+        if '\n' in out:
+            # So that multi-line strings line up with the left column of
+            # the screen, instead of having the output prompt mess up
+            # their first line.                
+            Term.cout.write('\n')
+        print >>Term.cout, out
+    else:
+        # By default, the interactive prompt uses repr() to display results,
+        # so we should honor this.  Users who'd rather use a different
+        # mechanism can easily override this hook.
+        print >>Term.cout, repr(arg)
+    # the default display hook doesn't manipulate the value to put in history
+    return None 
+
+def input_prefilter(self,line):     
+    """ Default input prefilter
+    
+    This returns the line as unchanged, so that the interpreter
+    knows that nothing was done and proceeds with "classic" prefiltering
+    (%magics, !shell commands etc.). 
+    
+    Note that leading whitespace is not passed to this hook. Prefilter
+    can't alter indentation.
+    
+    """
+    #print "attempt to rewrite",line #dbg
+    return line
+
+def shutdown_hook(self):
+    """ default shutdown hook
+    
+    Typically, shotdown hooks should raise TryNext so all shutdown ops are done
+    """
+    
+    #print "default shutdown hook ok" # dbg
+    return
+
+def late_startup_hook(self):
+    """ Executed after ipython has been constructed and configured 
+    
+    """
+    #print "default startup hook ok" # dbg
+
+def generate_prompt(self, is_continuation):
+    """ calculate and return a string with the prompt to display """
+    ip = self.api
+    if is_continuation:
+        return str(ip.IP.outputcache.prompt2)
+    return str(ip.IP.outputcache.prompt1)
+
+def generate_output_prompt(self):
+    ip = self.api
+    return str(ip.IP.outputcache.prompt_out)
+
+def shell_hook(self,cmd):
+    """ Run system/shell command a'la os.system() """
+
+    shell(cmd, header=self.rc.system_header, verbose=self.rc.system_verbose)
+
+def show_in_pager(self,s):
+    """ Run a string through pager """
+    # raising TryNext here will use the default paging functionality
+    raise ipapi.TryNext
+
+def pre_command_hook(self,cmd):
+    """" Executed before starting to execute a command """
+    return None
+
+def post_command_hook(self,cmd):
+    """ Executed after executing a command """
+    
+
diff --git a/IPython/ipapi.py b/IPython/ipapi.py
new file mode 100644
index 0000000..57c8960
--- /dev/null
+++ b/IPython/ipapi.py
@@ -0,0 +1,596 @@
+''' IPython customization API
+
+Your one-stop module for configuring & extending ipython
+
+The API will probably break when ipython 1.0 is released, but so 
+will the other configuration method (rc files).
+
+All names prefixed by underscores are for internal use, not part 
+of the public api.
+
+Below is an example that you can just put to a module and import from ipython. 
+
+A good practice is to install the config script below as e.g. 
+
+~/.ipython/my_private_conf.py
+
+And do 
+
+import_mod my_private_conf 
+
+in ~/.ipython/ipythonrc
+
+That way the module is imported at startup and you can have all your
+personal configuration (as opposed to boilerplate ipythonrc-PROFILENAME 
+stuff) in there. 
+
+-----------------------------------------------
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+def ankka_f(self, arg):
+    print "Ankka",self,"says uppercase:",arg.upper()
+
+ip.expose_magic("ankka",ankka_f)
+
+ip.magic('alias sayhi echo "Testing, hi ok"')
+ip.magic('alias helloworld echo "Hello world"')
+ip.system('pwd')
+
+ip.ex('import re')
+ip.ex("""
+def funcci(a,b):
+    print a+b
+print funcci(3,4)
+""")
+ip.ex("funcci(348,9)")
+
+def jed_editor(self,filename, linenum=None):
+    print "Calling my own editor, jed ... via hook!"
+    import os
+    if linenum is None: linenum = 0
+    os.system('jed +%d %s' % (linenum, filename))
+    print "exiting jed"
+
+ip.set_hook('editor',jed_editor)
+
+o = ip.options
+o.autocall = 2  # FULL autocall mode
+
+print "done!"
+'''
+
+# stdlib imports
+import __builtin__
+import sys
+
+try: # Python 2.3 compatibility
+    set
+except NameError:
+    import sets
+    set = sets.Set
+
+# our own
+#from IPython.genutils import warn,error
+ 
+class TryNext(Exception):
+    """Try next hook exception.
+     
+    Raise this in your hook function to indicate that the next hook handler
+    should be used to handle the operation.  If you pass arguments to the
+    constructor those arguments will be used by the next hook instead of the
+    original ones.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+class UsageError(Exception):
+    """ Error in magic function arguments, etc.
+    
+    Something that probably won't warrant a full traceback, but should
+    nevertheless interrupt a macro / batch file.   
+    """
+
+class IPyAutocall:
+    """ Instances of this class are always autocalled
+    
+    This happens regardless of 'autocall' variable state. Use this to
+    develop macro-like mechanisms.
+    """
+    
+    def set_ip(self,ip):
+        """ Will be used to set _ip point to current ipython instance b/f call
+        
+        Override this method if you don't want this to happen.
+        
+        """
+        self._ip = ip
+    
+
+# contains the most recently instantiated IPApi
+
+class IPythonNotRunning:
+    """Dummy do-nothing class.
+
+    Instances of this class return a dummy attribute on all accesses, which
+    can be called and warns.  This makes it easier to write scripts which use
+    the ipapi.get() object for informational purposes to operate both with and
+    without ipython.  Obviously code which uses the ipython object for
+    computations will not work, but this allows a wider range of code to
+    transparently work whether ipython is being used or not."""
+
+    def __init__(self,warn=True):
+        if warn:
+            self.dummy = self._dummy_warn
+        else:
+            self.dummy = self._dummy_silent
+    
+    def __str__(self):
+        return "<IPythonNotRunning>"
+
+    __repr__ = __str__
+
+    def __getattr__(self,name):
+        return self.dummy
+
+    def _dummy_warn(self,*args,**kw):
+        """Dummy function, which doesn't do anything but warn."""
+
+        print ("IPython is not running, this is a dummy no-op function")
+
+    def _dummy_silent(self,*args,**kw):
+        """Dummy function, which doesn't do anything and emits no warnings."""
+        pass
+
+_recent = None
+
+
+def get(allow_dummy=False,dummy_warn=True):
+    """Get an IPApi object.
+
+    If allow_dummy is true, returns an instance of IPythonNotRunning 
+    instead of None if not running under IPython.
+
+    If dummy_warn is false, the dummy instance will be completely silent.
+
+    Running this should be the first thing you do when writing extensions that
+    can be imported as normal modules. You can then direct all the
+    configuration operations against the returned object.
+    """
+    global _recent
+    if allow_dummy and not _recent:
+        _recent = IPythonNotRunning(dummy_warn)
+    return _recent
+
+class IPApi:
+    """ The actual API class for configuring IPython 
+    
+    You should do all of the IPython configuration by getting an IPApi object
+    with IPython.ipapi.get() and using the attributes and methods of the
+    returned object."""
+    
+    def __init__(self,ip):
+        
+        # All attributes exposed here are considered to be the public API of
+        # IPython.  As needs dictate, some of these may be wrapped as
+        # properties.
+
+        self.magic = ip.ipmagic
+        
+        self.system = ip.system
+        
+        self.set_hook = ip.set_hook
+        
+        self.set_custom_exc = ip.set_custom_exc
+
+        self.user_ns = ip.user_ns
+        self.user_ns['_ip'] = self
+
+        self.set_crash_handler = ip.set_crash_handler
+
+        # Session-specific data store, which can be used to store
+        # data that should persist through the ipython session.
+        self.meta =  ip.meta
+    
+        # The ipython instance provided
+        self.IP = ip
+
+        self.extensions = {}
+
+        self.dbg = DebugTools(self)
+        
+        global _recent
+        _recent = self
+
+    # Use a property for some things which are added to the instance very
+    # late.  I don't have time right now to disentangle the initialization
+    # order issues, so a property lets us delay item extraction while
+    # providing a normal attribute API.
+    def get_db(self):
+        """A handle to persistent dict-like database (a PickleShareDB object)"""
+        return self.IP.db
+
+    db = property(get_db,None,None,get_db.__doc__)
+
+    def get_options(self):
+        """All configurable variables."""
+        
+        # catch typos by disabling new attribute creation. If new attr creation
+        # is in fact wanted (e.g. when exposing new options), do allow_new_attr(True) 
+        # for the received rc struct.
+        
+        self.IP.rc.allow_new_attr(False)
+        return self.IP.rc
+
+    options = property(get_options,None,None,get_options.__doc__)
+    
+    def expose_magic(self,magicname, func):
+        ''' Expose own function as magic function for ipython 
+    
+        def foo_impl(self,parameter_s=''):
+            """My very own magic!. (Use docstrings, IPython reads them)."""
+            print 'Magic function. Passed parameter is between < >: <'+parameter_s+'>'
+            print 'The self object is:',self
+    
+        ipapi.expose_magic("foo",foo_impl)
+        '''
+                
+        import new
+        im = new.instancemethod(func,self.IP, self.IP.__class__)
+        old = getattr(self.IP, "magic_" + magicname, None)
+        if old:
+            self.dbg.debug_stack("Magic redefinition '%s', old %s" % (magicname,
+                                 old))
+            
+        setattr(self.IP, "magic_" + magicname, im)
+    
+    def ex(self,cmd):
+        """ Execute a normal python statement in user namespace """
+        exec cmd in self.user_ns
+    
+    def ev(self,expr):
+        """ Evaluate python expression expr in user namespace 
+        
+        Returns the result of evaluation"""
+        return eval(expr,self.user_ns)
+    
+    def runlines(self,lines):
+        """ Run the specified lines in interpreter, honoring ipython directives.
+        
+        This allows %magic and !shell escape notations.
+        
+        Takes either all lines in one string or list of lines.
+        """
+
+        def cleanup_ipy_script(script):
+            """ Make a script safe for _ip.runlines() 
+            
+            - Removes empty lines
+            - Suffixes all indented blocks that end with unindented lines with empty lines
+            
+            """
+            res = []
+            lines = script.splitlines()
+            level = 0
+            for l in lines:
+                stripped = l.lstrip()
+                if not l.strip():
+                    continue
+                newlevel = len(l) - len(stripped)
+                if level > 0 and newlevel == 0:
+                    # add empty line
+                    res.append('')
+                res.append(l)
+                level = newlevel
+            return '\n'.join(res) + '\n'
+        
+        if isinstance(lines,basestring):
+            script = lines            
+        else:
+            script = '\n'.join(lines)
+        clean=cleanup_ipy_script(script)
+
+        self.IP.runlines(clean)
+    def to_user_ns(self,vars, interactive = True):
+        """Inject a group of variables into the IPython user namespace.
+
+        Inputs:
+
+         - vars: string with variable names separated by whitespace, or a
+         dict with name/value pairs.
+
+         - interactive: if True (default), the var will be listed with
+        %whos et. al.
+         
+        This utility routine is meant to ease interactive debugging work,
+        where you want to easily propagate some internal variable in your code
+        up to the interactive namespace for further exploration.
+
+        When you run code via %run, globals in your script become visible at
+        the interactive prompt, but this doesn't happen for locals inside your
+        own functions and methods.  Yet when debugging, it is common to want
+        to explore some internal variables further at the interactive propmt.
+
+        Examples:
+
+        To use this, you first must obtain a handle on the ipython object as
+        indicated above, via:
+
+        import IPython.ipapi
+        ip = IPython.ipapi.get()
+
+        Once this is done, inside a routine foo() where you want to expose
+        variables x and y, you do the following:
+
+        def foo():
+            ...
+            x = your_computation()
+            y = something_else()
+            
+            # This pushes x and y to the interactive prompt immediately, even
+            # if this routine crashes on the next line after:
+            ip.to_user_ns('x y')
+            ...
+            
+            # To expose *ALL* the local variables from the function, use:
+            ip.to_user_ns(locals())
+
+            ...
+            # return           
+        
+
+        If you need to rename variables, the dict input makes it easy.  For
+        example, this call exposes variables 'foo' as 'x' and 'bar' as 'y'
+        in IPython user namespace:
+
+        ip.to_user_ns(dict(x=foo,y=bar))    
+        """
+
+        # print 'vars given:',vars # dbg
+        
+        # We need a dict of name/value pairs to do namespace updates.
+        if isinstance(vars,dict):
+            # If a dict was given, no need to change anything.
+            vdict = vars
+        elif isinstance(vars,basestring):
+            # If a string with names was given, get the caller's frame to
+            # evaluate the given names in
+            cf = sys._getframe(1)
+            vdict = {}
+            for name in vars.split():
+                try:
+                    vdict[name] = eval(name,cf.f_globals,cf.f_locals)
+                except:
+                    print ('could not get var. %s from %s' %
+                    (name,cf.f_code.co_name))
+        else:
+            raise ValueError('vars must be a string or a dict')
+            
+        # Propagate variables to user namespace
+        self.user_ns.update(vdict)
+
+        # And configure interactive visibility
+        config_ns = self.IP.user_config_ns
+        if interactive:
+            for name,val in vdict.iteritems():
+                config_ns.pop(name,None)
+        else:
+            for name,val in vdict.iteritems():
+                config_ns[name] = val                    
+
+
+    def expand_alias(self,line):
+        """ Expand an alias in the command line 
+        
+        Returns the provided command line, possibly with the first word 
+        (command) translated according to alias expansion rules.
+        
+        [ipython]|16> _ip.expand_aliases("np myfile.txt")
+                 <16> 'q:/opt/np/notepad++.exe myfile.txt'
+        """
+        
+        pre,fn,rest = self.IP.split_user_input(line)
+        res = pre + self.IP.expand_aliases(fn,rest)
+        return res
+
+    def itpl(self, s, depth = 1):
+        """ Expand Itpl format string s.
+        
+        Only callable from command line (i.e. prefilter results);
+        If you use in your scripts, you need to use a bigger depth!
+        """
+        return self.IP.var_expand(s, depth)
+        
+    def defalias(self, name, cmd):
+        """ Define a new alias
+        
+        _ip.defalias('bb','bldmake bldfiles')
+        
+        Creates a new alias named 'bb' in ipython user namespace
+        """
+
+        self.dbg.check_hotname(name)
+        
+
+        if name in self.IP.alias_table:
+            self.dbg.debug_stack("Alias redefinition: '%s' => '%s' (old '%s')" %
+                             (name, cmd, self.IP.alias_table[name]))
+            
+
+        if callable(cmd):
+            self.IP.alias_table[name] = cmd
+            import IPython.shadowns
+            setattr(IPython.shadowns, name,cmd)
+            return
+            
+        if isinstance(cmd,basestring):
+            nargs = cmd.count('%s')
+            if nargs>0 and cmd.find('%l')>=0:
+                raise Exception('The %s and %l specifiers are mutually exclusive '
+                                'in alias definitions.')
+                  
+            self.IP.alias_table[name] = (nargs,cmd)
+            return
+        
+        # just put it in - it's probably (0,'foo')
+        self.IP.alias_table[name] = cmd
+    
+    def defmacro(self, *args):
+        """ Define a new macro
+    
+        2 forms of calling:
+        
+        mac = _ip.defmacro('print "hello"\nprint "world"')
+        
+        (doesn't put the created macro on user namespace)
+        
+        _ip.defmacro('build', 'bldmake bldfiles\nabld build winscw udeb')
+        
+        (creates a macro named 'build' in user namespace)
+        """
+        
+        import IPython.macro
+        
+        if len(args) == 1:
+            return IPython.macro.Macro(args[0])
+        elif len(args) == 2:
+            self.user_ns[args[0]] = IPython.macro.Macro(args[1])
+        else:
+            return Exception("_ip.defmacro must be called with 1 or 2 arguments")
+        
+    def set_next_input(self, s):
+        """ Sets the 'default' input string for the next command line.
+        
+        Requires readline.
+        
+        Example:
+        
+        [D:\ipython]|1> _ip.set_next_input("Hello Word")
+        [D:\ipython]|2> Hello Word_  # cursor is here        
+        """
+
+        self.IP.rl_next_input = s
+
+    def load(self, mod):
+        """ Load an extension.
+        
+        Some modules should (or must) be 'load()':ed, rather than just imported.
+        
+        Loading will do:
+        
+        - run init_ipython(ip)
+        - run ipython_firstrun(ip)
+        
+        """
+        if mod in self.extensions:
+            # just to make sure we don't init it twice
+            # note that if you 'load' a module that has already been
+            # imported, init_ipython gets run anyway
+            
+            return self.extensions[mod]
+        __import__(mod)
+        m = sys.modules[mod]
+        if hasattr(m,'init_ipython'):
+            m.init_ipython(self)
+            
+        if hasattr(m,'ipython_firstrun'):
+            already_loaded = self.db.get('firstrun_done', set())
+            if mod not in already_loaded:
+                m.ipython_firstrun(self)
+                already_loaded.add(mod)
+                self.db['firstrun_done'] = already_loaded
+            
+        self.extensions[mod] = m
+        return m
+
+
+class DebugTools:
+    """ Used for debugging mishaps in api usage
+    
+    So far, tracing redefinitions is supported.
+    """
+    
+    def __init__(self, ip):
+        self.ip = ip
+        self.debugmode = False
+        self.hotnames = set()
+        
+    def hotname(self, name_to_catch):
+        self.hotnames.add(name_to_catch)
+        
+    def debug_stack(self, msg = None):
+        if not self.debugmode:
+            return
+        
+        import traceback
+        if msg is not None:
+            print '====== %s  ========' % msg
+        traceback.print_stack()
+
+    def check_hotname(self,name):
+        if name in self.hotnames:
+            self.debug_stack( "HotName '%s' caught" % name)
+
+def launch_new_instance(user_ns = None):
+    """ Make and start a new ipython instance.
+    
+    This can be called even without having an already initialized 
+    ipython session running.
+    
+    This is also used as the egg entry point for the 'ipython' script.
+    
+    """
+    ses = make_session(user_ns)
+    ses.mainloop()
+
+
+def make_user_ns(user_ns = None):
+    """Return a valid user interactive namespace.
+
+    This builds a dict with the minimal information needed to operate as a
+    valid IPython user namespace, which you can pass to the various embedding
+    classes in ipython.
+    """
+
+    if user_ns is None:
+        # Set __name__ to __main__ to better match the behavior of the
+        # normal interpreter.
+        user_ns = {'__name__'     :'__main__',
+                   '__builtins__' : __builtin__,
+                   }
+    else:
+        user_ns.setdefault('__name__','__main__')
+        user_ns.setdefault('__builtins__',__builtin__)
+
+    return user_ns
+
+
+def make_user_global_ns(ns = None):
+    """Return a valid user global namespace.
+
+    Similar to make_user_ns(), but global namespaces are really only needed in
+    embedded applications, where there is a distinction between the user's
+    interactive namespace and the global one where ipython is running."""
+
+    if ns is None: ns = {}
+    return ns
+
+
+def make_session(user_ns = None):
+    """Makes, but does not launch an IPython session.
+    
+    Later on you can call obj.mainloop() on the returned object.
+
+    Inputs:
+
+      - user_ns(None): a dict to be used as the user's namespace with initial
+      data.
+    
+    WARNING: This should *not* be run when a session exists already."""
+
+    import IPython.Shell
+    return IPython.Shell.start(user_ns)
+
+
diff --git a/IPython/iplib.py b/IPython/iplib.py
new file mode 100644
index 0000000..caa3432
--- /dev/null
+++ b/IPython/iplib.py
@@ -0,0 +1,2673 @@
+# -*- 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 3005 2008-02-01 16:43:34Z vivainio $
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
+#       Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
+#
+#  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 pydoc
+import re
+import shutil
+import string
+import sys
+import tempfile
+import traceback
+import types
+from sets import Set
+from pprint import pprint, pformat
+
+# IPython's own modules
+#import IPython
+from IPython import Debugger,OInspect,PyColorize,ultraTB
+from IPython.ColorANSI import ColorScheme,ColorSchemeTable  # too long names
+from IPython.Extensions import pickleshare
+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 *
+from IPython.strdispatch import StrDispatch
+import IPython.ipapi
+import IPython.history
+import IPython.prefilter as prefilter
+import IPython.shadowns
+# 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 Quitter(object):
+    """Simple class to handle exit, similar to Python 2.5's.
+
+    It handles exiting in an ipython-safe manner, which the one in Python 2.5
+    doesn't do (obviously, since it doesn't know about ipython)."""
+    
+    def __init__(self,shell,name):
+        self.shell = shell
+        self.name = name
+        
+    def __repr__(self):
+        return 'Type %s() to exit.' % self.name
+    __str__ = __repr__
+
+    def __call__(self):
+        self.shell.exit()
+
+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
+        self.more = False
+
+        # 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
+        if embedded:
+            # Control variable so users can, from within the embedded instance,
+            # permanently deactivate it.
+            self.embedded_active = True
+
+        # 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 like 2.5, and for 2.5 it's identical.
+        __builtin__.exit = Quitter(self,'exit')
+        __builtin__.quit = Quitter(self,'quit')
+        
+        # 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 <aleaxit@yahoo.com>
+        # Datum: Freitag 01 Oktober 2004 04:45:34 nachmittags/abends
+        # Gruppen: comp.lang.python
+
+        # Michael Hohn <hohn@hooknose.lbl.gov> 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)
+
+        # Now that FakeModule produces a real module, we've run into a nasty
+        # problem: after script execution (via %run), the module where the user
+        # code ran is deleted.  Now that this object is a true module (needed
+        # so docetst and other tools work correctly), the Python module
+        # teardown mechanism runs over it, and sets to None every variable
+        # present in that module.  This means that later calls to functions
+        # defined in the script (which have become interactively visible after
+        # script exit) fail, because they hold references to objects that have
+        # become overwritten into None.  The only solution I see right now is
+        # to protect every FakeModule used by %run by holding an internal
+        # reference to it.  This private list will be used for that.  The
+        # %reset command will flush it as well.
+        self._user_main_modules = []
+
+        # List of input with multi-line handling.
+        # Fill its zero entry, user counter starts at 1
+        self.input_hist = InputList(['\n'])
+        # 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 OSError:
+            self.dir_hist = []
+
+        # dict of output history
+        self.output_hist = {}
+
+        # Get system encoding at startup time.  Certain terminals (like Emacs
+        # under Win32 have it set to None, and we need to have a known valid
+        # encoding to use in the raw_input() method
+        self.stdin_encoding = sys.stdin.encoding or 'ascii'
+
+        # 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
+
+        self.user_ns['_sh'] = IPython.shadowns
+        # Object variable to store code object waiting execution.  This is
+        # used mainly by the multithreaded shells, but it can come in handy in
+        # other situations.  No need to use a Queue here, since it's a single
+        # item which gets cleared once run.
+        self.code_to_run = None
+        
+        # escapes for automatic behavior on the command line
+        self.ESC_SHELL  = '!'
+        self.ESC_SH_CAP = '!!'
+        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,
+                             self.ESC_SH_CAP : 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()
+        
+        self.strdispatchers = {}
+        
+        # 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 = []
+
+        # Functions to call the underlying shell.
+
+        # 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: \
+                      self.hooks.shell_hook(self.var_expand(cmd,depth=2))
+
+        # These are for getoutput and getoutputerror:
+        self.getoutput = lambda cmd: \
+                         getoutput(self.var_expand(cmd,depth=2),
+                                   header=self.rc.system_header,
+                                   verbose=self.rc.system_verbose)
+
+        self.getoutputerror = lambda cmd: \
+                              getoutputerror(self.var_expand(cmd,depth=2),
+                                             header=self.rc.system_header,
+                                             verbose=self.rc.system_verbose)
+ 
+
+        # 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:
+            ipCrashHandler = ultraTB.FormattedTB()
+        else:
+            from IPython import CrashHandler
+            ipCrashHandler = CrashHandler.IPythonCrashHandler(self)
+        self.set_crash_handler(ipCrashHandler)
+
+        # 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 = ('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]
+
+        
+        # Produce a public API instance
+        self.api = IPython.ipapi.IPApi(self)
+
+        # Call the actual (public) initializer
+        self.init_auto_alias()
+
+        # 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.
+        
+        #TODO: remove this, redundant
+        self.add_builtins()
+
+        
+        
+
+    # end __init__
+
+    def var_expand(self,cmd,depth=0):
+        """Expand python variables in a string.
+
+        The depth argument indicates how many frames above the caller should
+        be walked to look for the local namespace where to expand variables.
+
+        The global namespace for expansion is always the user's interactive
+        namespace.
+        """
+
+        return str(ItplNS(cmd,
+                          self.user_ns,  # globals
+                          # Skip our own frame in searching for locals:
+                          sys._getframe(depth+1).f_locals # locals
+                          ))
+
+    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
+        try:
+            self.db = pickleshare.PickleShareDB(rc.ipythondir + "/db")            
+        except exceptions.UnicodeDecodeError:
+            print "Your ipythondir can't be decoded to unicode!"
+            print "Please set HOME environment variable to something that"
+            print r"only has ASCII characters, e.g. c:\home"
+            print "Now it is",rc.ipythondir
+            sys.exit()
+        self.shadowhist = IPython.history.ShadowHist(self.db)            
+            
+    
+    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)
+        
+        self.rl_next_input = None
+        self.rl_do_indent = False
+        # 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.  We first save the original and then
+        # overwrite it.
+        self.sys_displayhook = sys.displayhook
+        sys.displayhook = self.outputcache
+
+        # Do a proper resetting of doctest, including the necessary displayhook
+        # monkeypatching
+        doctest_reload()
+        
+        # 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()
+        
+        for cmd in self.rc.autoexec:
+            #print "autoexec>",cmd #dbg
+            self.api.runlines(cmd)
+            
+        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
+        # without -i option, exit after running the batch file
+        if batchrun and not self.rc.interact:
+            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 of these, they are unsafe
+        builtins_new  = dict(__IPYTHON__ = self,
+             ip_set_hook = self.set_hook, 
+             jobs = self.jobs,
+             ipmagic = wrap_deprecated(self.ipmagic,'_ip.magic()'),  
+             ipalias = wrap_deprecated(self.ipalias),  
+             ipsystem = wrap_deprecated(self.ipsystem,'_ip.system()'),
+             #_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, str_key = None, re_key = None):
+        """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.
+        
+        f = new.instancemethod(hook,self,self.__class__)
+
+        # check if the hook is for strdispatcher first
+        if str_key is not None:
+            sdp = self.strdispatchers.get(name, StrDispatch())
+            sdp.add_s(str_key, f, priority )
+            self.strdispatchers[name] = sdp
+            return
+        if re_key is not None:
+            sdp = self.strdispatchers.get(name, StrDispatch())
+            sdp.add_re(re.compile(re_key), f, priority )
+            self.strdispatchers[name] = sdp
+            return
+            
+        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()
+        
+        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_crash_handler(self,crashHandler):
+        """Set the IPython crash handler.
+
+        This must be a callable with a signature suitable for use as
+        sys.excepthook."""
+
+        # Install the given crash handler as the Python exception hook
+        sys.excepthook = crashHandler
+        
+        # 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
+
+
+    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 set_completer(self):
+        """reset readline's completer to be our own."""
+        self.readline.set_completer(self.Completer.complete)
+        
+    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,1)
+            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.  When we make 2.4 a requirement,
+        # start using sets instead, which are faster.
+        comps = {}
+        while True:
+            newcomp = complete(text,state,line_buffer=text)
+            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.getapi().defalias(alias,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]
+            print "Initializing from configuration",rcdir
+        except IndexError:
+            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 create a minimal default configuration for you.
+
+"""
+            warn(warning)
+            wait()
+            
+            if sys.platform =='win32':
+                inif = 'ipythonrc.ini'
+            else:
+                inif = 'ipythonrc'
+            minimal_setup = {'ipy_user_conf.py' : 'import ipy_defaults', inif : '# intentionally left blank' }    
+            os.makedirs(ipythondir, mode = 0777)
+            for f, cont in minimal_setup.items():
+                open(ipythondir + '/' + f,'w').write(cont)
+                             
+            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
+
+        self.hooks.shutdown_hook()
+        
+    def savehist(self):
+        """Save input history to a file (via readline library)."""
+
+        if not self.has_readline:
+            return
+        
+        try:
+            self.readline.write_history_file(self.histfile)
+        except:
+            print 'Unable to save IPython command history to file: ' + \
+                  `self.histfile`
+
+    def reloadhist(self):
+        """Reload the input history from disk file."""
+
+        if self.has_readline:
+            self.readline.clear_history()
+            self.readline.read_history_file(self.shell.histfile)
+
+    def history_saving_wrapper(self, func):
+        """ Wrap func for readline history saving
+        
+        Convert func into callable that saves & restores
+        history around the call """
+        
+        if not self.has_readline:
+            return func
+        
+        def wrapper():
+            self.savehist()
+            try:
+                func()
+            finally:
+                readline.read_history_file(self.histfile)
+        return wrapper
+                
+            
+    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:')
+
+        if self.rl_do_indent:
+            self.readline.insert_text(self.indent_current_str())
+        if self.rl_next_input is not None:
+            self.readline.insert_text(self.rl_next_input)
+            self.rl_next_input = None
+
+    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)
+            sdisp = self.strdispatchers.get('complete_command', StrDispatch())
+            self.strdispatchers['complete_command'] = sdisp
+            self.Completer.custom_completers = sdisp
+            # 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)
+            # Or if libedit is used, load editrc.
+            inputrc_name = os.environ.get('INPUTRC')
+            if inputrc_name is None:
+                home_dir = get_home_dir()
+                if home_dir is not None:
+                    inputrc_name = '.inputrc'
+                    if readline.uses_libedit:
+                        inputrc_name = '.editrc'
+                    inputrc_name = os.path.join(home_dir, inputrc_name)
+            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
+            self.set_completer()
+
+            # Configure readline according to user's prefs
+            # This is only done if GNU readline is being used.  If libedit
+            # is being used (as on Leopard) the readline config is
+            # not run as the syntax for libedit is different.
+            if not readline.uses_libedit:
+                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,force=False):
+        """Call the pydb/pdb debugger.
+
+        Keywords:
+
+          - force(False): by default, this routine checks the instance call_pdb
+          flag and does not actually invoke the debugger if the flag is false.
+          The 'force' option forces the debugger to activate even if the flag
+          is false.
+        """
+
+        if not (force or self.call_pdb):
+            return
+
+        if not hasattr(sys,'last_traceback'):
+            error('No traceback has been produced, nothing to debug.')
+            return
+
+        # use pydb if available
+        if Debugger.has_pydb:
+            from pydb import pm
+        else:
+            # fallback to our internal debugger
+            pm = lambda : self.InteractiveTB.debugger(force=True)
+        self.history_saving_wrapper(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.
+        
+        try:
+            if exc_tuple is None:
+                etype, value, tb = sys.exc_info()
+            else:
+                etype, value, tb = exc_tuple
+    
+            if etype is SyntaxError:
+                self.showsyntaxerror(filename)
+            elif etype is IPython.ipapi.UsageError:
+                print "UsageError:", value
+            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
+    
+                if etype in self.custom_exceptions:
+                    self.CustomTB(etype,value,tb)
+                else:
+                    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.set_completer()
+        except KeyboardInterrupt:
+            self.write("\nKeyboardInterrupt\n")
+            
+        
+
+    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
+
+        while 1:
+            try:
+                self.interact(banner)
+                #self.interact_with_readline()                
+                # XXX for testing of a readline-decoupled repl loop, call interact_with_readline above
+
+                break
+            except KeyboardInterrupt:
+                # this should not be necessary, but KeyboardInterrupt
+                # handling seems rather unpredictable...
+                self.write("\nKeyboardInterrupt in interact()\n")
+
+    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.prefilter(self.rc.c, False))
+        if not self.rc.interact:
+            self.exit_now = True
+
+    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 <rxe@renre-europe.com>
+        # 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_prompt(self):
+        """ Print the prompt (in read-eval-print loop) 
+
+        Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not 
+        used in standard IPython flow.
+        """
+        if self.more:
+            try:
+                prompt = self.hooks.generate_prompt(True)
+            except:
+                self.showtraceback()
+            if self.autoindent:
+                self.rl_do_indent = True
+
+        else:
+            try:
+                prompt = self.hooks.generate_prompt(False)
+            except:
+                self.showtraceback()
+        self.write(prompt)
+
+    def interact_handle_input(self,line):
+        """ Handle the input line (in read-eval-print loop)
+        
+        Provided for those who want to implement their own read-eval-print loop (e.g. GUIs), not 
+        used in standard IPython flow.        
+        """
+        if line.lstrip() == line:
+            self.shadowhist.add(line.strip())
+        lineout = self.prefilter(line,self.more)
+
+        if line.strip():
+            if self.more:
+                self.input_hist_raw[-1] += '%s\n' % line
+            else:
+                self.input_hist_raw.append('%s\n' % line)                
+
+        
+        self.more = self.push(lineout)
+        if (self.SyntaxTB.last_syntax_error and
+            self.rc.autoedit_syntax):
+            self.edit_syntax_error()
+
+    def interact_with_readline(self):
+        """ Demo of using interact_handle_input, interact_prompt
+        
+        This is the main read-eval-print loop. If you need to implement your own (e.g. for GUI),
+        it should work like this.
+        """ 
+        self.readline_startup_hook(self.pre_readline)
+        while not self.exit_now:
+            self.interact_prompt()
+            if self.more:
+                self.rl_do_indent = True
+            else:
+                self.rl_do_indent = False
+            line = raw_input_original().decode(self.stdin_encoding)
+            self.interact_handle_input(line)
+
+        
+    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
+        
+        if self.has_readline:
+            self.readline_startup_hook(self.pre_readline)
+        # exit_now is set by a call to %Exit or %Quit
+        
+        while not self.exit_now:
+            if more:
+                try:
+                    prompt = self.hooks.generate_prompt(True)
+                except:
+                    self.showtraceback()
+                if self.autoindent:
+                    self.rl_do_indent = True
+                    
+            else:
+                try:
+                    prompt = self.hooks.generate_prompt(False)
+                except:
+                    self.showtraceback()
+            try:
+                line = self.raw_input(prompt,more)
+                if self.exit_now:
+                    # quick exit on sys.std[in|out] close
+                    break
+                if self.autoindent:
+                    self.rl_do_indent = False
+                    
+            except KeyboardInterrupt:
+                #double-guard against keyboardinterrupts during kbdint handling
+                try:
+                    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 KeyboardInterrupt:
+                    pass
+            except EOFError:
+                if self.autoindent:
+                    self.rl_do_indent = False
+                    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 expand_aliases(self,fn,rest):
+        """ Expand multiple levels of aliases:
+        
+        if:
+        
+        alias foo bar /tmp
+        alias baz foo
+        
+        then:
+        
+        baz huhhahhei -> bar /tmp huhhahhei
+        
+        """
+        line = fn + " " + rest
+        
+        done = Set()
+        while 1:
+            pre,fn,rest = prefilter.splitUserInput(line,
+                                                   prefilter.shell_line_split)
+            if fn in self.alias_table:
+                if fn in done:
+                    warn("Cyclic alias definition, repeated '%s'" % fn)
+                    return ""
+                done.add(fn)
+
+                l2 = self.transform_alias(fn,rest)
+                # dir -> dir 
+                # print "alias",line, "->",l2  #dbg
+                if l2 == line:
+                    break
+                # ls -> ls -F should not recurse forever
+                if l2.split(None,1)[0] == line.split(None,1)[0]:
+                    line = l2
+                    break
+                
+                line=l2
+                
+                
+                # print "al expand to",line #dbg
+            else:
+                break
+                
+        return line
+
+    def transform_alias(self, alias,rest=''):
+        """ Transform alias to system command string.
+        """
+        trg = self.alias_table[alias]
+
+        nargs,cmd = trg
+        # print trg #dbg
+        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:
+                # push to raw history, so hist line numbers stay in sync
+                self.input_hist_raw.append("# " + line + "\n")
+                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
+            else:
+                self.input_hist_raw.append("\n")
+        # 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."""
+
+        # if the source code has leading blanks, add 'if 1:\n' to it
+        # this allows execution of indented pasted code. It is tempting
+        # to add '\n' at the end of source to run commands like ' a=1'
+        # directly, but this fails for more complicated scenarios
+        source=source.encode(self.stdin_encoding)
+        if source[:1] in [' ', '\t']:
+            source = 'if 1:\n%s' % source
+
+        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 split_user_input(self, line):
+        # This is really a hold-over to support ipapi and some extensions
+        return prefilter.splitUserInput(line)
+
+    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.
+        """
+
+        # Code run by the user may have modified the readline completer state.
+        # We must ensure that our completer is back in place.
+        if self.has_readline:
+            self.set_completer()
+        
+        try:
+            line = raw_input_original(prompt).decode(self.stdin_encoding)
+        except ValueError:
+            warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
+                 " or sys.stdout.close()!\nExiting IPython!")
+            self.exit_now = True
+            return ""
+
+        # 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()
+                        if histlen > 1:
+                            newhist = self.input_hist_raw[-1].rstrip()
+                            self.readline.remove_history_item(histlen-1)
+                            self.readline.replace_history_item(histlen-2,
+                                            newhist.encode(self.stdin_encoding))
+                    except AttributeError:
+                        pass # re{move,place}_history_item are new in 2.4.                
+            else:
+                self.input_hist_raw.append('%s\n' % line)                
+            # only entries starting at first column go to shadow history
+            if line.lstrip() == line:
+                self.shadowhist.add(line.strip())
+        elif not continue_prompt:
+            self.input_hist_raw.append('\n')
+        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 _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).
+
+        #.....................................................................
+        # 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
+
+        if not line:
+            # Return immediately on purely empty lines, so that if the user
+            # previously typed some whitespace that started a continuation
+            # prompt, he can break out of that loop with just an empty line.
+            # This is how the default python prompt works.
+
+            # Only return if the accumulated input buffer was just whitespace!
+            if ''.join(self.buffer).isspace():
+                self.buffer[:] = []
+            return ''
+        
+        line_info = prefilter.LineInfo(line, continue_prompt)
+        
+        # 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_info)
+
+        # 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_info)
+
+
+        # 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 = line_info.pre + rewritten  # add indentation
+            return self.handle_normal(prefilter.LineInfo(rewritten,
+                                                         continue_prompt))
+            
+        #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest)  # dbg
+        
+        return prefilter.prefilter(line_info, self)
+
+
+    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_info):
+        """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.
+        line = line_info.line
+        continue_prompt = line_info.continue_prompt
+        
+        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_info):
+        """Handle alias input lines. """
+        tgt = self.alias_table[line_info.iFun]
+        # print "=>",tgt #dbg
+        if callable(tgt):
+            if '$' in line_info.line:
+                call_meth = '(_ip, _ip.itpl(%s))'
+            else:
+                call_meth = '(_ip,%s)'
+            line_out = ("%s_sh.%s" + call_meth) % (line_info.preWhitespace,
+                                         line_info.iFun, 
+            make_quoted_expr(line_info.line))
+        else:
+            transformed = self.expand_aliases(line_info.iFun,line_info.theRest)
+
+            # pre is needed, because it carries the leading whitespace.  Otherwise
+            # aliases won't work in indented sections.
+            line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
+                                             make_quoted_expr( transformed ))
+        
+        self.log(line_info.line,line_out,line_info.continue_prompt)
+        #print 'line out:',line_out # dbg
+        return line_out
+
+    def handle_shell_escape(self, line_info):
+        """Execute the line in a shell, empty return value"""
+        #print 'line in :', `line` # dbg
+        line = line_info.line
+        if line.lstrip().startswith('!!'):
+            # rewrite LineInfo's line, iFun and theRest to properly hold the
+            # call to %sx and the actual command to be executed, so
+            # handle_magic can work correctly.  Note that this works even if
+            # the line is indented, so it handles multi_line_specials
+            # properly.
+            new_rest = line.lstrip()[2:]
+            line_info.line = '%ssx %s' % (self.ESC_MAGIC,new_rest)
+            line_info.iFun = 'sx'
+            line_info.theRest = new_rest
+            return self.handle_magic(line_info)
+        else:
+            cmd = line.lstrip().lstrip('!')
+            line_out = '%s_ip.system(%s)' % (line_info.preWhitespace,
+                                             make_quoted_expr(cmd))
+        # update cache/log and return
+        self.log(line,line_out,line_info.continue_prompt)
+        return line_out
+
+    def handle_magic(self, line_info):
+        """Execute magic functions."""
+        iFun    = line_info.iFun
+        theRest = line_info.theRest
+        cmd = '%s_ip.magic(%s)' % (line_info.preWhitespace,
+                                   make_quoted_expr(iFun + " " + theRest))
+        self.log(line_info.line,cmd,line_info.continue_prompt)
+        #print 'in handle_magic, cmd=<%s>' % cmd  # dbg
+        return cmd
+
+    def handle_auto(self, line_info):
+        """Hande lines which can be auto-executed, quoting if requested."""
+
+        #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun,theRest)  # dbg
+        line    = line_info.line
+        iFun    = line_info.iFun
+        theRest = line_info.theRest
+        pre     = line_info.pre
+        continue_prompt = line_info.continue_prompt
+        obj = line_info.ofind(self)['obj']
+        
+        # This should only be active for single-line input!
+        if continue_prompt:
+            self.log(line,line,continue_prompt)
+            return line
+
+        force_auto = isinstance(obj, IPython.ipapi.IPyAutocall)
+        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) and not force_auto:
+                newcmd = '%s %s' % (iFun,theRest)
+                auto_rewrite = False
+            else:
+                if not force_auto and 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:
+            rw = self.outputcache.prompt1.auto_rewrite() + newcmd
+            
+            try:
+                # plain ascii works better w/ pyreadline, on some machines, so
+                # we use it and only print uncolored rewrite if we have unicode
+                rw = str(rw)
+                print >>Term.cout, rw
+            except UnicodeEncodeError:
+                print "-------------->" + 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_info):
+        """Try to get some help for the object.
+
+        obj? or ?obj   -> basic information.
+        obj?? or ??obj -> more details.
+        """
+        
+        line = line_info.line
+        # 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,line_info.continue_prompt)
+            if line:
+                #print 'line:<%r>' % line  # dbg
+                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_info)
+        else:
+            # If the code compiles ok, we should handle it normally
+            return self.handle_normal(line_info)
+
+    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_info):
+        """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_info.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
+
+    def safe_execfile(self,fname,*where,**kw):
+        """A safe version of the builtin execfile().
+
+        This version will never throw an exception, and knows how to handle
+        ipython logs as well.
+
+        :Parameters:
+          fname : string
+            Name of the file to be executed.
+            
+          where : tuple
+            One or two namespaces, passed to execfile() as (globals,locals).
+            If only one is given, it is passed as both.
+
+        :Keywords:
+          islog : boolean (False)
+
+          quiet : boolean (True)
+
+          exit_ignore : boolean (False)
+          """
+
+        def syspath_cleanup():
+            """Internal cleanup routine for sys.path."""
+            if add_dname:
+                try:
+                    sys.path.remove(dname)
+                except ValueError:
+                    # For some reason the user has already removed it, ignore.
+                    pass
+        
+        fname = os.path.expanduser(fname)
+
+        # Find things also in current directory.  This is needed to mimic the
+        # behavior of running a script from the system command line, where
+        # Python inserts the script's directory into sys.path
+        dname = os.path.dirname(os.path.abspath(fname))
+        add_dname = False
+        if dname not in sys.path:
+            sys.path.insert(0,dname)
+            add_dname = True
+
+        try:
+            xfile = open(fname)
+        except:
+            print >> Term.cerr, \
+                  'Could not open file <%s> for safe execution.' % fname
+            syspath_cleanup()
+            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:
+                if sys.platform == 'win32' and sys.version_info < (2,5,1):
+                    # Work around a bug in Python for Windows.  The bug was
+                    # fixed in in Python 2.5 r54159 and 54158, but that's still
+                    # SVN Python as of March/07.  For details, see:
+                    # http://projects.scipy.org/ipython/ipython/ticket/123
+                    try:
+                        globs,locs = where[0:2]
+                    except:
+                        try:
+                            globs = locs = where[0]
+                        except:
+                            globs = locs = globals()
+                    exec file(fname) in globs,locs
+                else:
+                    execfile(fname,*where)
+            except SyntaxError:
+                self.showsyntaxerror()
+                warn('Failure executing file: <%s>' % fname)
+            except SystemExit,status:
+                # Code that correctly sets the exit status flag to success (0)
+                # shouldn't be bothered with a traceback.  Note that a plain
+                # sys.exit() does NOT set the message to 0 (it's empty) so that
+                # will still get a traceback.  Note that the structure of the
+                # SystemExit exception changed between Python 2.4 and 2.5, so
+                # the checks must be done in a version-dependent way.
+                show = False
+
+                if sys.version_info[:2] > (2,5):
+                    if status.message!=0 and not kw['exit_ignore']:
+                        show = True
+                else:
+                    if status.code and not kw['exit_ignore']:
+                        show = True
+                if show:
+                    self.showtraceback()
+                    warn('Failure executing file: <%s>' % fname)
+            except:
+                self.showtraceback()
+                warn('Failure executing file: <%s>' % fname)
+
+        syspath_cleanup()
+
+#************************* end of file <iplib.py> *****************************
diff --git a/IPython/ipmaker.py b/IPython/ipmaker.py
new file mode 100644
index 0000000..0bf9a95
--- /dev/null
+++ b/IPython/ipmaker.py
@@ -0,0 +1,765 @@
+# -*- coding: utf-8 -*-
+"""
+IPython -- An enhanced Interactive Python
+
+Requires Python 2.1 or better.
+
+This file contains the main make_IPython() starter function.
+
+$Id: ipmaker.py 2930 2008-01-11 07:03:11Z vivainio $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez. <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+__version__ = Release.version
+
+try:
+    credits._Printer__data = """
+    Python: %s
+
+    IPython: Fernando Perez, Janko Hauser, Nathan Gray, and many users.
+    See http://ipython.scipy.org for more information.""" \
+    % credits._Printer__data
+
+    copyright._Printer__data += """
+
+    Copyright (c) 2001-2004 Fernando Perez, Janko Hauser, Nathan Gray.
+    All Rights Reserved."""
+except NameError:
+    # Can happen if ipython was started with 'python -S', so that site.py is
+    # not loaded
+    pass
+
+#****************************************************************************
+# Required modules
+
+# From the standard library
+import __main__
+import __builtin__
+import os
+import re
+import sys
+import types
+from pprint import pprint,pformat
+
+# Our own
+from IPython import DPyGetOpt
+from IPython.ipstruct import Struct
+from IPython.OutputTrap import OutputTrap
+from IPython.ConfigLoader import ConfigLoader
+from IPython.iplib import InteractiveShell
+from IPython.usage import cmd_line_usage,interactive_usage
+from IPython.genutils import *
+
+#-----------------------------------------------------------------------------
+def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,
+                 rc_override=None,shell_class=InteractiveShell,
+                 embedded=False,**kw):
+    """This is a dump of IPython into a single function.
+
+    Later it will have to be broken up in a sensible manner.
+
+    Arguments:
+
+    - argv: a list similar to sys.argv[1:].  It should NOT contain the desired
+    script name, b/c DPyGetOpt strips the first argument only for the real
+    sys.argv.
+
+    - user_ns: a dict to be used as the user's namespace."""
+
+    #----------------------------------------------------------------------
+    # Defaults and initialization
+    
+    # For developer debugging, deactivates crash handler and uses pdb.
+    DEVDEBUG = False
+
+    if argv is None:
+        argv = sys.argv
+
+    # __IP is the main global that lives throughout and represents the whole
+    # application. If the user redefines it, all bets are off as to what
+    # happens.
+
+    # __IP is the name of he global which the caller will have accessible as
+    # __IP.name. We set its name via the first parameter passed to
+    # InteractiveShell:
+
+    IP = shell_class('__IP',user_ns=user_ns,user_global_ns=user_global_ns,
+                     embedded=embedded,**kw)
+
+    # Put 'help' in the user namespace
+    from site import _Helper
+    IP.user_config_ns = {}
+    IP.user_ns['help'] = _Helper()
+
+
+    if DEVDEBUG:
+        # For developer debugging only (global flag)
+        from IPython import ultraTB
+        sys.excepthook = ultraTB.VerboseTB(call_pdb=1)
+
+    IP.BANNER_PARTS = ['Python %s\n'
+                         'Type "copyright", "credits" or "license" '
+                         'for more information.\n'
+                         % (sys.version.split('\n')[0],),
+                         "IPython %s -- An enhanced Interactive Python."
+                         % (__version__,),
+"""\
+?         -> Introduction and overview of IPython's features.
+%quickref -> Quick reference.
+help      -> Python's own help system.
+object?   -> Details about 'object'. ?object also works, ?? prints more.
+""" ]
+
+    IP.usage = interactive_usage
+
+    # Platform-dependent suffix and directory names.  We use _ipython instead
+    # of .ipython under win32 b/c there's software that breaks with .named
+    # directories on that platform.
+    if os.name == 'posix':
+        rc_suffix = ''
+        ipdir_def = '.ipython'
+    else:
+        rc_suffix = '.ini'
+        ipdir_def = '_ipython'
+
+    # default directory for configuration
+    ipythondir_def = os.path.abspath(os.environ.get('IPYTHONDIR',
+                                 os.path.join(IP.home_dir,ipdir_def)))
+
+    sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran
+
+    # we need the directory where IPython itself is installed
+    import IPython
+    IPython_dir = os.path.dirname(IPython.__file__)
+    del IPython
+    
+    #-------------------------------------------------------------------------
+    # Command line handling
+
+    # Valid command line options (uses DPyGetOpt syntax, like Perl's
+    # GetOpt::Long)
+
+    # Any key not listed here gets deleted even if in the file (like session
+    # or profile). That's deliberate, to maintain the rc namespace clean.
+
+    # Each set of options appears twice: under _conv only the names are
+    # listed, indicating which type they must be converted to when reading the
+    # ipythonrc file. And under DPyGetOpt they are listed with the regular
+    # DPyGetOpt syntax (=s,=i,:f,etc).
+
+    # Make sure there's a space before each end of line (they get auto-joined!)
+    cmdline_opts = ('autocall=i autoindent! automagic! banner! cache_size|cs=i '
+                    'c=s classic|cl color_info! colors=s confirm_exit! '
+                    'debug! deep_reload! editor=s log|l messages! nosep '
+                    'object_info_string_level=i pdb! '
+                    'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s '
+                    'pydb! '
+                    'pylab_import_all! '
+                    'quick screen_length|sl=i prompts_pad_left=i '
+                    'logfile|lf=s logplay|lp=s profile|p=s '
+                    'readline! readline_merge_completions! '
+                    'readline_omit__names! '
+                    'rcfile=s separate_in|si=s separate_out|so=s '
+                    'separate_out2|so2=s xmode=s wildcards_case_sensitive! '
+                    'magic_docstrings system_verbose! '
+                    'multi_line_specials! '
+                    'term_title! wxversion=s '
+                    'autoedit_syntax!')
+
+    # Options that can *only* appear at the cmd line (not in rcfiles).
+    
+    # The "ignore" option is a kludge so that Emacs buffers don't crash, since
+    # the 'C-c !' command in emacs automatically appends a -i option at the end.
+    cmdline_only = ('help interact|i ipythondir=s Version upgrade '
+                    'gthread! qthread! q4thread! wthread! tkthread! pylab! tk!')
+
+    # Build the actual name list to be used by DPyGetOpt
+    opts_names = qw(cmdline_opts) + qw(cmdline_only)
+
+    # Set sensible command line defaults.
+    # This should have everything from  cmdline_opts and cmdline_only
+    opts_def = Struct(autocall = 1,
+                      autoedit_syntax = 0,
+                      autoindent = 0,
+                      automagic = 1,
+                      autoexec = [],
+                      banner = 1,
+                      c = '',
+                      cache_size = 1000,
+                      classic = 0,
+                      color_info = 0,
+                      colors = 'NoColor',
+                      confirm_exit = 1,
+                      debug = 0,
+                      deep_reload = 0,
+                      editor = '0',
+                      gthread = 0,
+                      help = 0,
+                      interact = 1,
+                      ipythondir = ipythondir_def,
+                      log = 0,
+                      logfile = '',
+                      logplay = '',
+                      messages = 1,
+                      multi_line_specials = 1,
+                      nosep = 0,
+                      object_info_string_level = 0,
+                      pdb = 0,
+                      pprint = 0,
+                      profile = '',
+                      prompt_in1 = 'In [\\#]: ',
+                      prompt_in2 = '   .\\D.: ',
+                      prompt_out = 'Out[\\#]: ',
+                      prompts_pad_left = 1,
+                      pylab = 0,
+                      pylab_import_all = 1,
+                      q4thread = 0,
+                      qthread = 0,
+                      quick = 0,
+                      quiet = 0,
+                      rcfile = 'ipythonrc' + rc_suffix,
+                      readline = 1,
+                      readline_merge_completions = 1,
+                      readline_omit__names = 0,
+                      screen_length = 0,
+                      separate_in = '\n',
+                      separate_out = '\n',
+                      separate_out2 = '',
+                      system_header = 'IPython system call: ',
+                      system_verbose = 0,
+                      term_title = 1,
+                      tk = 0,
+                      upgrade = 0,
+                      Version = 0,
+                      wildcards_case_sensitive = 1,
+                      wthread = 0,
+                      wxversion = '0',
+                      xmode = 'Context',
+                      magic_docstrings = 0,  # undocumented, for doc generation
+                      )
+    
+    # Things that will *only* appear in rcfiles (not at the command line).
+    # Make sure there's a space before each end of line (they get auto-joined!)
+    rcfile_opts = { qwflat: 'include import_mod import_all execfile ',
+                    qw_lol: 'import_some ',
+                    # for things with embedded whitespace:
+                    list_strings:'execute alias readline_parse_and_bind ',
+                    # Regular strings need no conversion:
+                    None:'readline_remove_delims ',
+                    }
+    # Default values for these
+    rc_def = Struct(include = [],
+                    import_mod = [], 
+                    import_all = [],
+                    import_some = [[]],
+                    execute = [],
+                    execfile = [],
+                    alias = [],
+                    readline_parse_and_bind = [],
+                    readline_remove_delims = '',
+                    )
+
+    # Build the type conversion dictionary from the above tables:
+    typeconv = rcfile_opts.copy()
+    typeconv.update(optstr2types(cmdline_opts))
+
+    # FIXME: the None key appears in both, put that back together by hand. Ugly!
+    typeconv[None] += ' ' + rcfile_opts[None]
+
+    # Remove quotes at ends of all strings (used to protect spaces)
+    typeconv[unquote_ends] = typeconv[None]
+    del typeconv[None]
+
+    # Build the list we'll use to make all config decisions with defaults:
+    opts_all = opts_def.copy()
+    opts_all.update(rc_def)
+
+    # Build conflict resolver for recursive loading of config files:
+    # - preserve means the outermost file maintains the value, it is not
+    # overwritten if an included file has the same key.
+    # - add_flip applies + to the two values, so it better make sense to add
+    # those types of keys. But it flips them first so that things loaded
+    # deeper in the inclusion chain have lower precedence.
+    conflict = {'preserve': ' '.join([ typeconv[int],
+                                       typeconv[unquote_ends] ]),
+                'add_flip': ' '.join([ typeconv[qwflat],
+                                       typeconv[qw_lol],
+                                       typeconv[list_strings] ])
+                }
+
+    # Now actually process the command line
+    getopt = DPyGetOpt.DPyGetOpt()
+    getopt.setIgnoreCase(0)
+
+    getopt.parseConfiguration(opts_names)
+
+    try:
+        getopt.processArguments(argv)
+    except DPyGetOpt.ArgumentError, exc:
+        print cmd_line_usage
+        warn('\nError in Arguments: "%s"' % exc)
+        sys.exit(1)
+
+    # convert the options dict to a struct for much lighter syntax later
+    opts = Struct(getopt.optionValues)
+    args = getopt.freeValues
+
+    # this is the struct (which has default values at this point) with which
+    # we make all decisions:
+    opts_all.update(opts)
+
+    # Options that force an immediate exit
+    if opts_all.help:
+        page(cmd_line_usage)
+        sys.exit()
+
+    if opts_all.Version:
+        print __version__
+        sys.exit()
+
+    if opts_all.magic_docstrings:
+        IP.magic_magic('-latex')
+        sys.exit()
+
+    # add personal ipythondir to sys.path so that users can put things in
+    # there for customization
+    sys.path.append(os.path.abspath(opts_all.ipythondir))
+
+    # Create user config directory if it doesn't exist. This must be done
+    # *after* getting the cmd line options.
+    if not os.path.isdir(opts_all.ipythondir):
+        IP.user_setup(opts_all.ipythondir,rc_suffix,'install')
+
+    # upgrade user config files while preserving a copy of the originals
+    if opts_all.upgrade:
+        IP.user_setup(opts_all.ipythondir,rc_suffix,'upgrade')
+
+    # check mutually exclusive options in the *original* command line
+    mutex_opts(opts,[qw('log logfile'),qw('rcfile profile'),
+                     qw('classic profile'),qw('classic rcfile')])
+
+    #---------------------------------------------------------------------------
+    # Log replay
+    
+    # if -logplay, we need to 'become' the other session. That basically means
+    # replacing the current command line environment with that of the old
+    # session and moving on.
+
+    # this is needed so that later we know we're in session reload mode, as
+    # opts_all will get overwritten:
+    load_logplay = 0
+
+    if opts_all.logplay:
+        load_logplay = opts_all.logplay 
+        opts_debug_save = opts_all.debug
+        try:
+            logplay = open(opts_all.logplay)
+        except IOError:
+            if opts_all.debug: IP.InteractiveTB()
+            warn('Could not open logplay file '+`opts_all.logplay`)
+            # restore state as if nothing had happened and move on, but make
+            # sure that later we don't try to actually load the session file
+            logplay = None
+            load_logplay = 0
+            del opts_all.logplay
+        else:
+            try: 
+                logplay.readline()
+                logplay.readline();
+                # this reloads that session's command line
+                cmd = logplay.readline()[6:] 
+                exec cmd
+                # restore the true debug flag given so that the process of
+                # session loading itself can be monitored.
+                opts.debug = opts_debug_save
+                # save the logplay flag so later we don't overwrite the log
+                opts.logplay = load_logplay
+                # now we must update our own structure with defaults
+                opts_all.update(opts)
+                # now load args
+                cmd = logplay.readline()[6:] 
+                exec cmd
+                logplay.close()
+            except:
+                logplay.close()
+                if opts_all.debug: IP.InteractiveTB()
+                warn("Logplay file lacking full configuration information.\n"
+                     "I'll try to read it, but some things may not work.")
+
+    #-------------------------------------------------------------------------
+    # set up output traps: catch all output from files, being run, modules
+    # loaded, etc. Then give it to the user in a clean form at the end.
+    
+    msg_out = 'Output messages. '
+    msg_err = 'Error messages. '
+    msg_sep = '\n'
+    msg = Struct(config    = OutputTrap('Configuration Loader',msg_out,
+                                        msg_err,msg_sep,debug,
+                                        quiet_out=1),
+                 user_exec = OutputTrap('User File Execution',msg_out,
+                                        msg_err,msg_sep,debug),
+                 logplay   = OutputTrap('Log Loader',msg_out,
+                                        msg_err,msg_sep,debug),
+                 summary = ''
+                 )
+
+    #-------------------------------------------------------------------------
+    # Process user ipythonrc-type configuration files
+
+    # turn on output trapping and log to msg.config
+    # remember that with debug on, trapping is actually disabled
+    msg.config.trap_all()
+
+    # look for rcfile in current or default directory
+    try:
+        opts_all.rcfile = filefind(opts_all.rcfile,opts_all.ipythondir)
+    except IOError:
+        if opts_all.debug:  IP.InteractiveTB()
+        warn('Configuration file %s not found. Ignoring request.'
+             % (opts_all.rcfile) )
+
+    # 'profiles' are a shorthand notation for config filenames
+    profile_handled_by_legacy = False
+    if opts_all.profile:
+            
+        try:
+            opts_all.rcfile = filefind('ipythonrc-' + opts_all.profile
+                                       + rc_suffix,
+                                       opts_all.ipythondir)
+            profile_handled_by_legacy = True
+        except IOError:
+           if opts_all.debug:  IP.InteractiveTB()
+           opts.profile = ''  # remove profile from options if invalid
+           # We won't warn anymore, primary method is ipy_profile_PROFNAME
+           # which does trigger a warning.
+
+    # load the config file
+    rcfiledata = None
+    if opts_all.quick:
+        print 'Launching IPython in quick mode. No config file read.'
+    elif opts_all.rcfile:
+        try:
+            cfg_loader = ConfigLoader(conflict)
+            rcfiledata = cfg_loader.load(opts_all.rcfile,typeconv,
+                                         'include',opts_all.ipythondir,
+                                         purge = 1,
+                                         unique = conflict['preserve'])
+        except:
+            IP.InteractiveTB()
+            warn('Problems loading configuration file '+
+                 `opts_all.rcfile`+
+                 '\nStarting with default -bare bones- configuration.')
+    else:
+        warn('No valid configuration file found in either currrent directory\n'+
+             'or in the IPython config. directory: '+`opts_all.ipythondir`+
+             '\nProceeding with internal defaults.')
+
+    #------------------------------------------------------------------------
+    # Set exception handlers in mode requested by user.
+    otrap = OutputTrap(trap_out=1)  # trap messages from magic_xmode
+    IP.magic_xmode(opts_all.xmode)
+    otrap.release_out()
+
+    #------------------------------------------------------------------------
+    # Execute user config
+
+    # Create a valid config structure with the right precedence order:
+    # defaults < rcfile < command line.  This needs to be in the instance, so
+    # that method calls below that rely on it find it.
+    IP.rc = rc_def.copy()
+
+    # Work with a local alias inside this routine to avoid unnecessary
+    # attribute lookups.
+    IP_rc = IP.rc
+    
+    IP_rc.update(opts_def)
+    if rcfiledata:
+        # now we can update 
+        IP_rc.update(rcfiledata)
+    IP_rc.update(opts)
+    IP_rc.update(rc_override)
+
+    # Store the original cmd line for reference:
+    IP_rc.opts = opts
+    IP_rc.args = args
+
+    # create a *runtime* Struct like rc for holding parameters which may be
+    # created and/or modified by runtime user extensions.
+    IP.runtime_rc = Struct()
+
+    # from this point on, all config should be handled through IP_rc,
+    # opts* shouldn't be used anymore.
+
+    
+    # update IP_rc with some special things that need manual
+    # tweaks. Basically options which affect other options. I guess this
+    # should just be written so that options are fully orthogonal and we
+    # wouldn't worry about this stuff!
+
+    if IP_rc.classic:
+        IP_rc.quick = 1
+        IP_rc.cache_size = 0
+        IP_rc.pprint = 0
+        IP_rc.prompt_in1 = '>>> '
+        IP_rc.prompt_in2 = '... '
+        IP_rc.prompt_out = ''
+        IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
+        IP_rc.colors = 'NoColor'
+        IP_rc.xmode = 'Plain'
+
+    IP.pre_config_initialization()
+    # configure readline
+    # Define the history file for saving commands in between sessions
+    if IP_rc.profile:
+        histfname = 'history-%s' % IP_rc.profile
+    else:
+        histfname = 'history'
+    IP.histfile = os.path.join(opts_all.ipythondir,histfname)
+
+    # update exception handlers with rc file status
+    otrap.trap_out()  # I don't want these messages ever.
+    IP.magic_xmode(IP_rc.xmode)
+    otrap.release_out()
+
+    # activate logging if requested and not reloading a log
+    if IP_rc.logplay:
+        IP.magic_logstart(IP_rc.logplay + ' append')
+    elif  IP_rc.logfile:
+        IP.magic_logstart(IP_rc.logfile)
+    elif IP_rc.log:
+        IP.magic_logstart()
+
+    # find user editor so that it we don't have to look it up constantly
+    if IP_rc.editor.strip()=='0':
+        try:
+            ed = os.environ['EDITOR']
+        except KeyError:
+            if os.name == 'posix':
+                ed = 'vi'  # the only one guaranteed to be there!
+            else:
+                ed = 'notepad' # same in Windows!
+        IP_rc.editor = ed
+
+    # Keep track of whether this is an embedded instance or not (useful for
+    # post-mortems).
+    IP_rc.embedded = IP.embedded
+
+    # Recursive reload
+    try:
+        from IPython import deep_reload
+        if IP_rc.deep_reload:
+            __builtin__.reload = deep_reload.reload
+        else:
+            __builtin__.dreload = deep_reload.reload
+        del deep_reload
+    except ImportError:
+        pass
+
+    # Save the current state of our namespace so that the interactive shell
+    # can later know which variables have been created by us from config files
+    # and loading. This way, loading a file (in any way) is treated just like
+    # defining things on the command line, and %who works as expected.
+
+    # DON'T do anything that affects the namespace beyond this point!
+    IP.internal_ns.update(__main__.__dict__)
+
+    #IP.internal_ns.update(locals()) # so our stuff doesn't show up in %who
+
+    # Now run through the different sections of the users's config
+    if IP_rc.debug:    
+        print 'Trying to execute the following configuration structure:'
+        print '(Things listed first are deeper in the inclusion tree and get'
+        print 'loaded first).\n'
+        pprint(IP_rc.__dict__)
+        
+    for mod in IP_rc.import_mod:
+        try:
+            exec 'import '+mod in IP.user_ns
+        except :
+            IP.InteractiveTB()
+            import_fail_info(mod)
+
+    for mod_fn in IP_rc.import_some:
+        if not mod_fn == []: 
+            mod,fn = mod_fn[0],','.join(mod_fn[1:])
+            try:
+                exec 'from '+mod+' import '+fn in IP.user_ns
+            except :
+                IP.InteractiveTB()
+                import_fail_info(mod,fn)
+
+    for mod in IP_rc.import_all:
+        try:
+            exec 'from '+mod+' import *' in IP.user_ns
+        except :
+            IP.InteractiveTB()
+            import_fail_info(mod)
+
+    for code in IP_rc.execute:
+        try:
+            exec code in IP.user_ns
+        except:
+            IP.InteractiveTB()
+            warn('Failure executing code: ' + `code`)
+
+    # Execute the files the user wants in ipythonrc
+    for file in IP_rc.execfile:
+        try:
+            file = filefind(file,sys.path+[IPython_dir])
+        except IOError:
+            warn(itpl('File $file not found. Skipping it.'))
+        else:
+            IP.safe_execfile(os.path.expanduser(file),IP.user_ns)
+
+    # finally, try importing ipy_*_conf for final configuration
+    try:
+        import ipy_system_conf
+    except ImportError:
+        if opts_all.debug:  IP.InteractiveTB()
+        warn("Could not import 'ipy_system_conf'")        
+    except:
+        IP.InteractiveTB()
+        import_fail_info('ipy_system_conf')
+        
+    # only import prof module if ipythonrc-PROF was not found
+    if opts_all.profile and not profile_handled_by_legacy:
+        profmodname = 'ipy_profile_' + opts_all.profile
+        try:
+            __import__(profmodname)
+        except:
+            IP.InteractiveTB()
+            print "Error importing",profmodname,"- perhaps you should run %upgrade?"
+            import_fail_info(profmodname)
+    else:
+        import ipy_profile_none
+    try:    
+        import ipy_user_conf
+        
+    except:
+        conf = opts_all.ipythondir + "/ipy_user_conf.py"
+        IP.InteractiveTB()
+        if not os.path.isfile(conf):
+            warn(conf + ' does not exist, please run %upgrade!')
+
+        import_fail_info("ipy_user_conf")
+
+    # finally, push the argv to options again to ensure highest priority
+    IP_rc.update(opts)
+    
+    # release stdout and stderr and save config log into a global summary
+    msg.config.release_all()
+    if IP_rc.messages:
+        msg.summary += msg.config.summary_all()
+
+    #------------------------------------------------------------------------
+    # Setup interactive session
+
+    # Now we should be fully configured. We can then execute files or load
+    # things only needed for interactive use. Then we'll open the shell.
+
+    # Take a snapshot of the user namespace before opening the shell. That way
+    # we'll be able to identify which things were interactively defined and
+    # which were defined through config files.
+    IP.user_config_ns.update(IP.user_ns)
+
+    # Force reading a file as if it were a session log. Slower but safer.
+    if load_logplay:
+        print 'Replaying log...'
+        try:
+            if IP_rc.debug:
+                logplay_quiet = 0
+            else:
+                 logplay_quiet = 1
+
+            msg.logplay.trap_all()
+            IP.safe_execfile(load_logplay,IP.user_ns,
+                             islog = 1, quiet = logplay_quiet)
+            msg.logplay.release_all()
+            if IP_rc.messages:
+                msg.summary += msg.logplay.summary_all()
+        except:
+            warn('Problems replaying logfile %s.' % load_logplay)
+            IP.InteractiveTB()
+
+    # Load remaining files in command line
+    msg.user_exec.trap_all()
+
+    # 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.
+
+    # XXX FIXME: the execution of user files should be moved out to after
+    # ipython is fully initialized, just as if they were run via %run at the
+    # ipython prompt.  This would also give them the benefit of ipython's
+    # nice tracebacks.
+
+    if (not embedded and IP_rc.args and 
+        not IP_rc.args[0].lower().endswith('.ipy')):
+        name_save = IP.user_ns['__name__']
+        IP.user_ns['__name__'] = '__main__'
+        # Set our own excepthook in case the user code tries to call it
+        # directly. This prevents triggering the IPython crash handler.
+        old_excepthook,sys.excepthook = sys.excepthook, IP.excepthook
+
+        save_argv = sys.argv[1:] # save it for later restoring
+        
+        sys.argv = args
+        
+        try:
+            IP.safe_execfile(args[0], IP.user_ns)
+        finally:
+            # Reset our crash handler in place
+            sys.excepthook = old_excepthook
+            sys.argv[:] = save_argv
+            IP.user_ns['__name__'] = name_save
+        
+    msg.user_exec.release_all()
+
+    if IP_rc.messages:
+        msg.summary += msg.user_exec.summary_all()
+
+    # since we can't specify a null string on the cmd line, 0 is the equivalent:
+    if IP_rc.nosep:
+        IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
+    if IP_rc.separate_in == '0': IP_rc.separate_in = ''
+    if IP_rc.separate_out == '0': IP_rc.separate_out = ''
+    if IP_rc.separate_out2 == '0': IP_rc.separate_out2 = ''
+    IP_rc.separate_in = IP_rc.separate_in.replace('\\n','\n')
+    IP_rc.separate_out = IP_rc.separate_out.replace('\\n','\n')
+    IP_rc.separate_out2 = IP_rc.separate_out2.replace('\\n','\n')
+
+    # Determine how many lines at the bottom of the screen are needed for
+    # showing prompts, so we can know wheter long strings are to be printed or
+    # paged:
+    num_lines_bot = IP_rc.separate_in.count('\n')+1
+    IP_rc.screen_length = IP_rc.screen_length - num_lines_bot
+
+    # configure startup banner
+    if IP_rc.c:  # regular python doesn't print the banner with -c
+        IP_rc.banner = 0
+    if IP_rc.banner:
+        BANN_P = IP.BANNER_PARTS
+    else:
+        BANN_P = []
+
+    if IP_rc.profile: BANN_P.append('IPython profile: %s\n' % IP_rc.profile)
+
+    # add message log (possibly empty)
+    if msg.summary: BANN_P.append(msg.summary)
+    # Final banner is a string
+    IP.BANNER = '\n'.join(BANN_P)
+
+    # Finalize the IPython instance.  This assumes the rc structure is fully
+    # in place.
+    IP.post_config_initialization()
+
+    return IP
+#************************ end of file <ipmaker.py> **************************
diff --git a/IPython/ipstruct.py b/IPython/ipstruct.py
new file mode 100644
index 0000000..5318460
--- /dev/null
+++ b/IPython/ipstruct.py
@@ -0,0 +1,394 @@
+# -*- coding: utf-8 -*-
+"""Mimic C structs with lots of extra functionality.
+
+$Id: ipstruct.py 1950 2006-11-28 19:15:35Z vivainio $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+__all__ = ['Struct']
+
+import types
+import pprint
+
+from IPython.genutils import list2dict2
+
+class Struct:
+    """Class to mimic C structs but also provide convenient dictionary-like
+    functionality.
+
+    Instances can be initialized with a dictionary, a list of key=value pairs
+    or both. If both are present, the dictionary must come first.
+
+    Because Python classes provide direct assignment to their members, it's
+    easy to overwrite normal methods (S.copy = 1 would destroy access to
+    S.copy()). For this reason, all builtin method names are protected and
+    can't be assigned to. An attempt to do s.copy=1 or s['copy']=1 will raise
+    a KeyError exception. If you really want to, you can bypass this
+    protection by directly assigning to __dict__: s.__dict__['copy']=1 will
+    still work. Doing this will break functionality, though. As in most of
+    Python, namespace protection is weakly enforced, so feel free to shoot
+    yourself if you really want to.
+
+    Note that this class uses more memory and is *much* slower than a regular
+    dictionary, so be careful in situations where memory or performance are
+    critical. But for day to day use it should behave fine. It is particularly
+    convenient for storing configuration data in programs.
+
+    +,+=,- and -= are implemented. +/+= do merges (non-destructive updates),
+    -/-= remove keys from the original. See the method descripitions.
+
+    This class allows a quick access syntax: both s.key and s['key'] are
+    valid.  This syntax has a limitation: each 'key' has to be explicitly
+    accessed by its original name. The normal s.key syntax doesn't provide
+    access to the keys via variables whose values evaluate to the desired
+    keys. An example should clarify this:
+
+    Define a dictionary and initialize both with dict and k=v pairs:
+    >>> d={'a':1,'b':2}
+    >>> s=Struct(d,hi=10,ho=20)
+    The return of __repr__ can be used to create a new instance:
+    >>> s
+    Struct({'ho': 20, 'b': 2, 'hi': 10, 'a': 1})
+    __str__ (called by print) shows it's not quite a regular dictionary:
+    >>> print s
+    Struct {a: 1, b: 2, hi: 10, ho: 20}
+    Access by explicitly named key with dot notation:
+    >>> s.a
+    1
+    Or like a dictionary:
+    >>> s['a']
+    1
+    If you want a variable to hold the key value, only dictionary access works:
+    >>> key='hi'
+    >>> s.key
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in ?
+    AttributeError: Struct instance has no attribute 'key'
+    >>> s[key]
+    10
+
+    Another limitation of the s.key syntax (and Struct(key=val)
+    initialization): keys can't be numbers. But numeric keys can be used and
+    accessed using the dictionary syntax. Again, an example:
+
+    This doesn't work:
+    >>> s=Struct(4='hi')
+    SyntaxError: keyword can't be an expression
+    But this does:
+    >>> s=Struct()
+    >>> s[4]='hi'
+    >>> s
+    Struct({4: 'hi'})
+    >>> s[4]
+    'hi'
+    """
+
+    # Attributes to which __setitem__ and __setattr__ will block access.
+    # Note: much of this will be moot in Python 2.2 and will be done in a much
+    # cleaner way.
+    __protected = ('copy dict dictcopy get has_attr has_key items keys '
+                   'merge popitem setdefault update values '
+                   '__make_dict __dict_invert ').split()
+
+    def __init__(self,dict=None,**kw):
+        """Initialize with a dictionary, another Struct, or by giving
+        explicitly the list of attributes.
+
+        Both can be used, but the dictionary must come first:
+        Struct(dict), Struct(k1=v1,k2=v2) or Struct(dict,k1=v1,k2=v2).
+        """
+        self.__dict__['__allownew'] = True
+        if dict is None:
+            dict = {}
+        if isinstance(dict,Struct):
+            dict = dict.dict()
+        elif dict and  type(dict) is not types.DictType:
+            raise TypeError,\
+                  'Initialize with a dictionary or key=val pairs.'
+        dict.update(kw)
+        # do the updating by hand to guarantee that we go through the
+        # safety-checked __setitem__
+        for k,v in dict.items():
+            self[k] = v
+        
+
+    def __setitem__(self,key,value):
+        """Used when struct[key] = val calls are made."""
+        if key in Struct.__protected:
+            raise KeyError,'Key '+`key`+' is a protected key of class Struct.'
+        if not self['__allownew'] and key not in self.__dict__:
+            raise KeyError(
+            "Can't create unknown attribute %s - Check for typos, or use allow_new_attr to create new attributes!" %
+            key)
+            
+        self.__dict__[key] = value
+
+    def __setattr__(self, key, value):
+        """Used when struct.key = val calls are made."""
+        self.__setitem__(key,value)
+
+    def __str__(self):
+        """Gets called by print."""
+        
+        return 'Struct('+ pprint.pformat(self.__dict__)+')'
+
+    def __repr__(self):
+        """Gets called by repr.
+        
+        A Struct can be recreated with S_new=eval(repr(S_old))."""
+        return self.__str__()
+
+    def __getitem__(self,key):
+        """Allows struct[key] access."""
+        return self.__dict__[key]
+
+    def __contains__(self,key):
+        """Allows use of the 'in' operator."""
+        return self.__dict__.has_key(key)
+
+    def __iadd__(self,other):
+        """S += S2 is a shorthand for S.merge(S2)."""
+        self.merge(other)
+        return self
+
+    def __add__(self,other):
+        """S + S2 -> New Struct made form S and S.merge(S2)"""
+        Sout = self.copy()
+        Sout.merge(other)
+        return Sout
+
+    def __sub__(self,other):
+        """Return S1-S2, where all keys in S2 have been deleted (if present)
+        from S1."""
+        Sout = self.copy()
+        Sout -= other
+        return Sout
+
+    def __isub__(self,other):
+        """Do in place S = S - S2, meaning all keys in S2 have been deleted
+        (if present) from S1."""
+
+        for k in other.keys():
+            if self.has_key(k):
+                del self.__dict__[k]
+
+    def __make_dict(self,__loc_data__,**kw):
+        "Helper function for update and merge. Return a dict from data."
+
+        if __loc_data__ == None:
+            dict = {}
+        elif type(__loc_data__) is types.DictType:
+            dict = __loc_data__
+        elif isinstance(__loc_data__,Struct):
+            dict = __loc_data__.__dict__
+        else:
+            raise TypeError, 'Update with a dict, a Struct or key=val pairs.'
+        if kw:
+            dict.update(kw)
+        return dict
+
+    def __dict_invert(self,dict):
+        """Helper function for merge. Takes a dictionary whose values are
+        lists and returns a dict. with the elements of each list as keys and
+        the original keys as values."""
+
+        outdict = {}
+        for k,lst in dict.items():
+            if type(lst) is types.StringType:
+                lst = lst.split()
+            for entry in lst:
+                outdict[entry] = k
+        return outdict
+
+    def clear(self):
+        """Clear all attributes."""
+        self.__dict__.clear()
+
+    def copy(self):
+        """Return a (shallow) copy of a Struct."""
+        return Struct(self.__dict__.copy())
+
+    def dict(self):
+        """Return the Struct's dictionary."""
+        return self.__dict__
+
+    def dictcopy(self):
+        """Return a (shallow) copy of the Struct's dictionary."""
+        return self.__dict__.copy()
+
+    def popitem(self):
+        """S.popitem() -> (k, v), remove and return some (key, value) pair as
+        a 2-tuple; but raise KeyError if S is empty."""
+        return self.__dict__.popitem()
+
+    def update(self,__loc_data__=None,**kw):
+        """Update (merge) with data from another Struct or from a dictionary.
+        Optionally, one or more key=value pairs can be given at the end for
+        direct update."""
+
+        # The funny name __loc_data__ is to prevent a common variable name which
+        # could be a fieled of a Struct to collide with this parameter. The problem
+        # would arise if the function is called with a keyword with this same name
+        # that a user means to add as a Struct field.
+        newdict = Struct.__make_dict(self,__loc_data__,**kw)
+        for k,v in newdict.items():
+            self[k] = v
+
+    def merge(self,__loc_data__=None,__conflict_solve=None,**kw):
+        """S.merge(data,conflict,k=v1,k=v2,...) -> merge data and k=v into S.
+
+        This is similar to update(), but much more flexible.  First, a dict is
+        made from data+key=value pairs. When merging this dict with the Struct
+        S, the optional dictionary 'conflict' is used to decide what to do.
+
+        If conflict is not given, the default behavior is to preserve any keys
+        with their current value (the opposite of the update method's
+        behavior).
+
+        conflict is a dictionary of binary functions which will be used to
+        solve key conflicts. It must have the following structure:
+
+          conflict == { fn1 : [Skey1,Skey2,...], fn2 : [Skey3], etc }
+
+        Values must be lists or whitespace separated strings which are
+        automatically converted to lists of strings by calling string.split().
+
+        Each key of conflict is a function which defines a policy for
+        resolving conflicts when merging with the input data. Each fn must be
+        a binary function which returns the desired outcome for a key
+        conflict. These functions will be called as fn(old,new).
+
+        An example is probably in order. Suppose you are merging the struct S
+        with a dict D and the following conflict policy dict:
+
+            S.merge(D,{fn1:['a','b',4], fn2:'key_c key_d'})
+
+        If the key 'a' is found in both S and D, the merge method will call:
+
+            S['a'] = fn1(S['a'],D['a'])
+
+        As a convenience, merge() provides five (the most commonly needed)
+        pre-defined policies: preserve, update, add, add_flip and add_s. The
+        easiest explanation is their implementation:
+
+          preserve = lambda old,new: old
+          update   = lambda old,new: new
+          add      = lambda old,new: old + new
+          add_flip = lambda old,new: new + old  # note change of order!
+          add_s    = lambda old,new: old + ' ' + new  # only works for strings!
+
+        You can use those four words (as strings) as keys in conflict instead
+        of defining them as functions, and the merge method will substitute
+        the appropriate functions for you. That is, the call
+
+          S.merge(D,{'preserve':'a b c','add':[4,5,'d'],my_function:[6]})
+
+        will automatically substitute the functions preserve and add for the
+        names 'preserve' and 'add' before making any function calls.
+
+        For more complicated conflict resolution policies, you still need to
+        construct your own functions. """
+
+        data_dict = Struct.__make_dict(self,__loc_data__,**kw)
+
+        # policies for conflict resolution: two argument functions which return
+        # the value that will go in the new struct
+        preserve = lambda old,new: old
+        update   = lambda old,new: new
+        add      = lambda old,new: old + new
+        add_flip = lambda old,new: new + old  # note change of order!
+        add_s    = lambda old,new: old + ' ' + new
+
+        # default policy is to keep current keys when there's a conflict
+        conflict_solve = list2dict2(self.keys(),default = preserve)
+
+        # the conflict_solve dictionary is given by the user 'inverted': we
+        # need a name-function mapping, it comes as a function -> names
+        # dict. Make a local copy (b/c we'll make changes), replace user
+        # strings for the three builtin policies and invert it.
+        if __conflict_solve:
+            inv_conflict_solve_user = __conflict_solve.copy()
+            for name, func in [('preserve',preserve), ('update',update),
+                               ('add',add), ('add_flip',add_flip), ('add_s',add_s)]:
+                if name in inv_conflict_solve_user.keys():
+                    inv_conflict_solve_user[func] = inv_conflict_solve_user[name]
+                    del inv_conflict_solve_user[name]
+            conflict_solve.update(Struct.__dict_invert(self,inv_conflict_solve_user))
+        #print 'merge. conflict_solve: '; pprint(conflict_solve) # dbg
+        #print '*'*50,'in merger. conflict_solver:';  pprint(conflict_solve)
+        for key in data_dict:
+            if key not in self:
+                self[key] = data_dict[key]
+            else:
+                self[key] = conflict_solve[key](self[key],data_dict[key])
+
+    def has_key(self,key):
+        """Like has_key() dictionary method."""
+        return self.__dict__.has_key(key)
+
+    def hasattr(self,key):
+        """hasattr function available as a method.
+
+        Implemented like has_key, to make sure that all available keys in the
+        internal dictionary of the Struct appear also as attributes (even
+        numeric keys)."""
+        return self.__dict__.has_key(key)
+
+    def items(self):
+        """Return the items in the Struct's dictionary, in the same format
+        as a call to {}.items()."""
+        return self.__dict__.items()
+
+    def keys(self):
+        """Return the keys in the Struct's dictionary, in the same format
+        as a call to {}.keys()."""
+        return self.__dict__.keys()
+
+    def values(self,keys=None):
+        """Return the values in the Struct's dictionary, in the same format
+        as a call to {}.values().
+
+        Can be called with an optional argument keys, which must be a list or
+        tuple of keys. In this case it returns only the values corresponding
+        to those keys (allowing a form of 'slicing' for Structs)."""
+        if not keys:
+            return self.__dict__.values()
+        else:
+            ret=[]
+            for k in keys:
+                ret.append(self[k])
+            return ret
+
+    def get(self,attr,val=None):
+        """S.get(k[,d]) -> S[k] if S.has_key(k), else d.  d defaults to None."""
+        try:
+            return self[attr]
+        except KeyError:
+            return val
+
+    def setdefault(self,attr,val=None):
+        """S.setdefault(k[,d]) -> S.get(k,d), also set S[k]=d if not S.has_key(k)"""
+        if not self.has_key(attr):
+            self[attr] = val
+        return self.get(attr,val)
+    
+    def allow_new_attr(self, allow = True):
+        """ Set whether new attributes can be created inside struct
+        
+        This can be used to catch typos by verifying that the attribute user tries to 
+        change already exists in this Struct.
+        """
+        self['__allownew'] = allow
+        
+        
+# end class Struct
+
diff --git a/IPython/irunner.py b/IPython/irunner.py
new file mode 100644
index 0000000..7539802
--- /dev/null
+++ b/IPython/irunner.py
@@ -0,0 +1,441 @@
+#!/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
+"""
+
+def pexpect_monkeypatch():
+    """Patch pexpect to prevent unhandled exceptions at VM teardown.
+
+    Calling this function will monkeypatch the pexpect.spawn class and modify
+    its __del__ method to make it more robust in the face of failures that can
+    occur if it is called when the Python VM is shutting down.
+
+    Since Python may fire __del__ methods arbitrarily late, it's possible for
+    them to execute during the teardown of the Python VM itself.  At this
+    point, various builtin modules have been reset to None.  Thus, the call to
+    self.close() will trigger an exception because it tries to call os.close(),
+    and os is now None.
+    """
+    
+    if pexpect.__version__[:3] >= '2.2':
+        # No need to patch, fix is already the upstream version.
+        return
+    
+    def __del__(self):
+        """This makes sure that no system resources are left open.
+        Python only garbage collects Python objects. OS file descriptors
+        are not Python objects, so they must be handled explicitly.
+        If the child file descriptor was opened outside of this class
+        (passed to the constructor) then this does not close it.
+        """
+        if not self.closed:
+            try:
+                self.close()
+            except AttributeError:
+                pass
+
+    pexpect.spawn.__del__ = __del__
+
+pexpect_monkeypatch()
+
+# 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,out=sys.stdout,echo=True):
+        """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.
+
+          - out(sys.stdout): if given, an output stream to be used when writing
+          output.  The only requirement is that it must have a .write() method.
+
+        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
+        self.out = out
+        self.echo = echo
+        # Other public members which we don't make as parameters, but which
+        # users may occasionally want to tweak
+        self.delaybeforesend = 0
+
+        # Create child process and hold on to it so we don't have to re-create
+        # for every single execution call
+        c = self.child = pexpect.spawn(self.program,self.args,timeout=None)
+        c.delaybeforesend = self.delaybeforesend
+        # pexpect hard-codes the terminal size as (24,80) (rows,columns).
+        # This causes problems because any line longer than 80 characters gets
+        # completely overwrapped on the printed outptut (even though
+        # internally the code runs fine).  We reset this to 99 rows X 200
+        # columns (arbitrarily chosen), which should avoid problems in all
+        # reasonable cases.
+        c.setwinsize(99,200)
+
+    def close(self):
+        """close child process"""
+
+        self.child.close()
+
+    def run_file(self,fname,interact=False,get_output=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:
+            out = self.run_source(fobj,interact,get_output)
+        finally:
+            fobj.close()
+        if get_output:
+            return out
+
+    def run_source(self,source,interact=False,get_output=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.
+
+          - get_output(False): if true, capture the output of the child process
+          (filtering the input commands out) and return it as a string.
+
+        Returns:
+          A string containing the process output, but only if requested.
+          """
+
+        # 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)
+
+        if self.echo:
+            # normalize all strings we write to use the native OS line
+            # separators.
+            linesep  = os.linesep
+            stdwrite = self.out.write
+            write    = lambda s: stdwrite(s.replace('\r\n',linesep))
+        else:
+            # Quiet mode, all writes are no-ops
+            write = lambda s: None
+            
+        c = self.child
+        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
+
+        # If the output was requested, store it in a list for return at the end
+        if get_output:
+            output = []
+            store_output = output.append
+        
+        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('#')):
+                write(cmd)
+                continue
+
+            #write('AFTER: '+c.after)  # dbg
+            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)
+
+            # With an echoing process, the output we get in c.before contains
+            # the command sent, a newline, and then the actual process output
+            if get_output:
+                store_output(c.before[len(cmd+'\n'):])
+                #write('CMD: <<%s>>' % cmd)  # dbg
+                #write('OUTPUT: <<%s>>' % output[-1])  # dbg
+
+        self.out.flush()
+        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')
+                    self.out.flush()
+        else:
+            if interact:
+                e="Further interaction is not possible: child process is dead."
+                print >> sys.stderr, e
+
+        # Leave the child ready for more input later on, otherwise select just
+        # hangs on the second invocation.
+        c.send('\n')
+        
+        # Return any requested output
+        if get_output:
+            return ''.join(output)
+                
+    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,out=sys.stdout,echo=True):
+        """New runner, optionally passing the ipython command to use."""
+        
+        args0 = ['-colors','NoColor',
+                 '-pi1','In [\\#]: ',
+                 '-pi2','   .\\D.: ',
+                 '-noterm_title',
+                 '-noautoindent']
+        if args is None: args = args0
+        else: args = args0 + args
+        prompts = [r'In \[\d+\]: ',r'   \.*: ']
+        InteractiveRunner.__init__(self,program,prompts,args,out,echo)
+
+
+class PythonRunner(InteractiveRunner):
+    """Interactive Python runner."""
+
+    def __init__(self,program='python',args=None,out=sys.stdout,echo=True):
+        """New runner, optionally passing the python command to use."""
+
+        prompts = [r'>>> ',r'\.\.\. ']
+        InteractiveRunner.__init__(self,program,prompts,args,out,echo)
+
+
+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,out=sys.stdout,echo=True):
+        """New runner, optionally passing the sage command to use."""
+
+        prompts = ['sage: ',r'\s*\.\.\. ']
+        InteractiveRunner.__init__(self,program,prompts,args,out,echo)
+
+
+class RunnerFactory(object):
+    """Code runner factory.
+
+    This class provides an IPython code runner, but enforces that only one
+    runner is ever instantiated.  The runner is created based on the extension
+    of the first file to run, and it raises an exception if a runner is later
+    requested for a different extension type.
+
+    This ensures that we don't generate example files for doctest with a mix of
+    python and ipython syntax.
+    """
+
+    def __init__(self,out=sys.stdout):
+        """Instantiate a code runner."""
+        
+        self.out = out
+        self.runner = None
+        self.runnerClass = None
+
+    def _makeRunner(self,runnerClass):
+        self.runnerClass = runnerClass
+        self.runner = runnerClass(out=self.out)
+        return self.runner
+          
+    def __call__(self,fname):
+        """Return a runner for the given filename."""
+
+        if fname.endswith('.py'):
+            runnerClass = PythonRunner
+        elif fname.endswith('.ipy'):
+            runnerClass = IPythonRunner
+        else:
+            raise ValueError('Unknown file type for Runner: %r' % fname)
+
+        if self.runner is None:
+            return self._makeRunner(runnerClass)
+        else:
+            if runnerClass==self.runnerClass:
+                return self.runner
+            else:
+                e='A runner of type %r can not run file %r' % \
+                   (self.runnerClass,fname)
+                raise ValueError(e)
+
+
+# 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)
+
+    try:
+        ext = os.path.splitext(args[0])[-1]
+    except IndexError:
+        ext = ''
+    modes = {'.ipy':'ipython',
+             '.py':'python',
+             '.sage':'sage'}
+    mode = modes.get(ext,opts.mode)
+    runners[mode]().main(args)
+
+if __name__ == '__main__':
+    main()
diff --git a/IPython/macro.py b/IPython/macro.py
new file mode 100644
index 0000000..e28ffae
--- /dev/null
+++ b/IPython/macro.py
@@ -0,0 +1,44 @@
+"""Support for interactive macros in IPython"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2005 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+import IPython.ipapi 
+
+
+from IPython.genutils import Term
+from IPython.ipapi import IPyAutocall
+
+class Macro(IPyAutocall):
+    """Simple class to store the value of macros as strings.
+
+    Macro is just a callable that executes a string of IPython
+    input when called.
+    
+    Args to macro are available in _margv list if you need them.
+    """
+
+    def __init__(self,data):
+
+        # store the macro value, as a single string which can be evaluated by
+        # runlines()
+        self.value = ''.join(data).rstrip()+'\n'
+        
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return 'IPython.macro.Macro(%s)' % repr(self.value)
+    
+    def __call__(self,*args):
+        Term.cout.flush()
+        self._ip.user_ns['_margv'] = args
+        self._ip.runlines(self.value)
+    
+    def __getstate__(self):
+        """ needed for safe pickling via %store """
+        return {'value': self.value}
\ No newline at end of file
diff --git a/IPython/numutils.py b/IPython/numutils.py
new file mode 100644
index 0000000..4233dc8
--- /dev/null
+++ b/IPython/numutils.py
@@ -0,0 +1,307 @@
+# -*- coding: utf-8 -*-
+"""
+A set of convenient utilities for numerical work.
+
+Most of this module requires Numerical Python or is meant to be used with it.
+See http://www.pfdubois.com/numpy for details.
+
+$Id: numutils.py 958 2005-12-27 23:17:51Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2005 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+__all__ = ['sum_flat','mean_flat','rms_flat','base_repr','binary_repr',
+           'amin','amax','amap','zeros_like','empty_like',
+           'frange','diagonal_matrix','identity',
+           'fromfunction_kw','log2','ispower2',
+           'norm','l1norm','l2norm','exp_safe',
+           'inf','infty','Infinity',
+           'Numeric']
+
+#****************************************************************************
+# required modules
+import __main__
+import math
+import operator
+import sys
+
+import Numeric
+from Numeric import *
+
+#*****************************************************************************
+# Globals
+
+# useful for testing infinities in results of array divisions (which don't
+# raise an exception)
+# Python, LaTeX and Mathematica names.
+inf = infty = Infinity = (array([1])/0.0)[0]
+
+#****************************************************************************
+# function definitions        
+exp_safe_MIN = math.log(2.2250738585072014e-308)
+exp_safe_MAX = 1.7976931348623157e+308
+
+def exp_safe(x):
+    """Compute exponentials which safely underflow to zero.
+
+    Slow but convenient to use. Note that NumArray will introduce proper
+    floating point exception handling with access to the underlying
+    hardware."""
+
+    if type(x) is ArrayType:
+        return exp(clip(x,exp_safe_MIN,exp_safe_MAX))
+    else:
+        return math.exp(x)
+
+def amap(fn,*args):
+    """amap(function, sequence[, sequence, ...]) -> array.
+
+    Works like map(), but it returns an array.  This is just a convenient
+    shorthand for Numeric.array(map(...))"""
+    return array(map(fn,*args))
+
+def amin(m,axis=0):
+    """amin(m,axis=0) returns the minimum of m along dimension axis.
+    """
+    return minimum.reduce(asarray(m),axis)
+
+def amax(m,axis=0):
+    """amax(m,axis=0) returns the maximum of m along dimension axis.
+    """
+    return maximum.reduce(asarray(m),axis)
+
+def zeros_like(a):
+    """Return an array of zeros of the shape and typecode of a.
+
+    If you don't explicitly need the array to be zeroed, you should instead
+    use empty_like(), which is faster as it only allocates memory."""
+
+    return zeros(a.shape,a.typecode())
+
+def empty_like(a):
+    """Return an empty (uninitialized) array of the shape and typecode of a.
+
+    Note that this does NOT initialize the returned array.  If you require
+    your array to be initialized, you should use zeros_like().
+
+    This requires Numeric.empty(), which appeared in Numeric 23.7."""
+
+    return empty(a.shape,a.typecode())
+
+def sum_flat(a):
+    """Return the sum of all the elements of a, flattened out.
+
+    It uses a.flat, and if a is not contiguous, a call to ravel(a) is made."""
+
+    if a.iscontiguous():
+        return Numeric.sum(a.flat)
+    else:
+        return Numeric.sum(ravel(a))
+
+def mean_flat(a):
+    """Return the mean of all the elements of a, flattened out."""
+
+    return sum_flat(a)/float(size(a))
+
+def rms_flat(a):
+    """Return the root mean square of all the elements of a, flattened out."""
+
+    return math.sqrt(sum_flat(absolute(a)**2)/float(size(a)))
+
+def l1norm(a):
+    """Return the l1 norm of a, flattened out.
+
+    Implemented as a separate function (not a call to norm() for speed).
+
+    Ref: http://mathworld.wolfram.com/L1-Norm.html"""
+
+    return sum_flat(absolute(a))
+
+def l2norm(a):
+    """Return the l2 norm of a, flattened out.
+
+    Implemented as a separate function (not a call to norm() for speed).
+
+    Ref: http://mathworld.wolfram.com/L2-Norm.html"""
+
+    return math.sqrt(sum_flat(absolute(a)**2))
+
+def norm(a,p=2):
+    """norm(a,p=2) -> l-p norm of a.flat
+
+    Return the l-p norm of a, considered as a flat array.  This is NOT a true
+    matrix norm, since arrays of arbitrary rank are always flattened.
+
+    p can be a number or one of the strings ('inf','Infinity') to get the
+    L-infinity norm.
+
+    Ref: http://mathworld.wolfram.com/VectorNorm.html
+         http://mathworld.wolfram.com/L-Infinity-Norm.html"""
+    
+    if p in ('inf','Infinity'):
+        return max(absolute(a).flat)
+    else:
+        return (sum_flat(absolute(a)**p))**(1.0/p)    
+    
+def frange(xini,xfin=None,delta=None,**kw):
+    """frange([start,] stop[, step, keywords]) -> array of floats
+
+    Return a Numeric array() containing a progression of floats. Similar to
+    arange(), but defaults to a closed interval.
+
+    frange(x0, x1) returns [x0, x0+1, x0+2, ..., x1]; start defaults to 0, and
+    the endpoint *is included*. This behavior is different from that of
+    range() and arange(). This is deliberate, since frange will probably be
+    more useful for generating lists of points for function evaluation, and
+    endpoints are often desired in this use. The usual behavior of range() can
+    be obtained by setting the keyword 'closed=0', in this case frange()
+    basically becomes arange().
+
+    When step is given, it specifies the increment (or decrement). All
+    arguments can be floating point numbers.
+
+    frange(x0,x1,d) returns [x0,x0+d,x0+2d,...,xfin] where xfin<=x1.
+
+    frange can also be called with the keyword 'npts'. This sets the number of
+    points the list should contain (and overrides the value 'step' might have
+    been given). arange() doesn't offer this option.
+
+    Examples:
+    >>> frange(3)
+    array([ 0.,  1.,  2.,  3.])
+    >>> frange(3,closed=0)
+    array([ 0.,  1.,  2.])
+    >>> frange(1,6,2)
+    array([1, 3, 5])
+    >>> frange(1,6.5,npts=5)
+    array([ 1.   ,  2.375,  3.75 ,  5.125,  6.5  ])
+    """
+
+    #defaults
+    kw.setdefault('closed',1)
+    endpoint = kw['closed'] != 0
+        
+    # funny logic to allow the *first* argument to be optional (like range())
+    # This was modified with a simpler version from a similar frange() found
+    # at http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66472
+    if xfin == None:
+        xfin = xini + 0.0
+        xini = 0.0
+        
+    if delta == None:
+        delta = 1.0
+
+    # compute # of points, spacing and return final list
+    try:
+        npts=kw['npts']
+        delta=(xfin-xini)/float(npts-endpoint)
+    except KeyError:
+        # round() gets npts right even with the vagaries of floating point.
+        npts=int(round((xfin-xini)/delta+endpoint))
+
+    return arange(npts)*delta+xini
+
+def diagonal_matrix(diag):
+    """Return square diagonal matrix whose non-zero elements are given by the
+    input array."""
+
+    return diag*identity(len(diag))
+
+def identity(n,rank=2,typecode='l'):
+    """identity(n,r) returns the identity matrix of shape (n,n,...,n) (rank r).
+
+    For ranks higher than 2, this object is simply a multi-index Kronecker
+    delta:
+                        /  1  if i0=i1=...=iR,
+    id[i0,i1,...,iR] = -|
+                        \  0  otherwise.
+
+    Optionally a typecode may be given (it defaults to 'l').
+
+    Since rank defaults to 2, this function behaves in the default case (when
+    only n is given) like the Numeric identity function."""
+    
+    iden = zeros((n,)*rank,typecode=typecode)
+    for i in range(n):
+        idx = (i,)*rank
+        iden[idx] = 1
+    return iden
+
+def base_repr (number, base = 2, padding = 0):
+    """Return the representation of a number in any given base."""
+    chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    if number < base: \
+       return (padding - 1) * chars [0] + chars [int (number)]
+    max_exponent = int (math.log (number)/math.log (base))
+    max_power = long (base) ** max_exponent
+    lead_digit = int (number/max_power)
+    return chars [lead_digit] + \
+           base_repr (number - max_power * lead_digit, base, \
+                      max (padding - 1, max_exponent))
+
+def binary_repr(number, max_length = 1025):
+    """Return the binary representation of the input number as a string.
+
+    This is more efficient than using base_repr with base 2.
+
+    Increase the value of max_length for very large numbers. Note that on
+    32-bit machines, 2**1023 is the largest integer power of 2 which can be
+    converted to a Python float."""
+    
+    assert number < 2L << max_length
+    shifts = map (operator.rshift, max_length * [number], \
+                  range (max_length - 1, -1, -1))
+    digits = map (operator.mod, shifts, max_length * [2])
+    if not digits.count (1): return 0
+    digits = digits [digits.index (1):]
+    return ''.join (map (repr, digits)).replace('L','')
+
+def log2(x,ln2 = math.log(2.0)):
+    """Return the log(x) in base 2.
+    
+    This is a _slow_ function but which is guaranteed to return the correct
+    integer value if the input is an ineger exact power of 2."""
+
+    try:
+        bin_n = binary_repr(x)[1:]
+    except (AssertionError,TypeError):
+        return math.log(x)/ln2
+    else:
+        if '1' in bin_n:
+            return math.log(x)/ln2
+        else:
+            return len(bin_n)
+
+def ispower2(n):
+    """Returns the log base 2 of n if n is a power of 2, zero otherwise.
+
+    Note the potential ambiguity if n==1: 2**0==1, interpret accordingly."""
+
+    bin_n = binary_repr(n)[1:]
+    if '1' in bin_n:
+        return 0
+    else:
+        return len(bin_n)
+
+def fromfunction_kw(function, dimensions, **kwargs):
+    """Drop-in replacement for fromfunction() from Numerical Python.
+ 
+    Allows passing keyword arguments to the desired function.
+
+    Call it as (keywords are optional):
+    fromfunction_kw(MyFunction, dimensions, keywords)
+
+    The function MyFunction() is responsible for handling the dictionary of
+    keywords it will recieve."""
+
+    return function(tuple(indices(dimensions)),**kwargs)
+
+#**************************** end file <numutils.py> ************************
diff --git a/IPython/platutils.py b/IPython/platutils.py
new file mode 100644
index 0000000..839e1b8
--- /dev/null
+++ b/IPython/platutils.py
@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+""" Proxy module for accessing platform specific utility functions. 
+
+Importing this module should give you the implementations that are correct 
+for your operation system, from platutils_PLATFORMNAME module.
+
+$Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
+
+
+"""
+
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Ville']
+__license__ = Release.license
+
+import os,sys
+
+if os.name == 'posix':
+    from platutils_posix import *
+elif sys.platform == 'win32':
+    from platutils_win32 import *
+else:
+    from platutils_dummy import *
+    import warnings
+    warnings.warn("Platutils not available for platform '%s', some features may be missing" %
+        os.name)
+    del warnings
diff --git a/IPython/platutils_dummy.py b/IPython/platutils_dummy.py
new file mode 100644
index 0000000..149acb9
--- /dev/null
+++ b/IPython/platutils_dummy.py
@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+""" Platform specific utility functions, dummy version 
+
+This has empty implementation of the platutils functions, used for 
+unsupported operating systems.
+
+$Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
+
+
+"""
+
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Ville']
+__license__ = Release.license
+
+
+def _dummy(*args,**kw):
+    pass
+
+set_term_title = _dummy
+
diff --git a/IPython/platutils_posix.py b/IPython/platutils_posix.py
new file mode 100644
index 0000000..ef80ad6
--- /dev/null
+++ b/IPython/platutils_posix.py
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+""" Platform specific utility functions, posix version 
+
+Importing this module directly is not portable - rather, import platutils 
+to use these functions in platform agnostic fashion.
+
+$Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
+
+"""
+
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Ville']
+__license__ = Release.license
+
+import sys
+import os
+
+
+def _dummy_op(*a, **b):
+    """ A no-op function """
+
+def _set_term_title_xterm(title):
+    """ Change virtual terminal title in xterm-workalikes """
+    sys.stdout.write('\033]%d;%s\007' % (0,title))
+
+
+if os.environ.get('TERM','') == 'xterm':
+    set_term_title = _set_term_title_xterm
+else:
+    set_term_title = _dummy_op
+
+    
diff --git a/IPython/platutils_win32.py b/IPython/platutils_win32.py
new file mode 100644
index 0000000..364afbc
--- /dev/null
+++ b/IPython/platutils_win32.py
@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+""" Platform specific utility functions, win32 version
+
+Importing this module directly is not portable - rather, import platutils 
+to use these functions in platform agnostic fashion.
+
+$Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
+
+"""
+
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Ville']
+__license__ = Release.license
+
+import os
+
+ignore_termtitle = 0
+
+try:
+    import ctypes
+    SetConsoleTitleW=ctypes.windll.kernel32.SetConsoleTitleW
+    SetConsoleTitleW.argtypes=[ctypes.c_wchar_p]
+    def _set_term_title(title):
+        """ Set terminal title using the ctypes"""
+        SetConsoleTitleW(title)
+
+except ImportError:
+    def _set_term_title(title):
+        """ Set terminal title using the 'title' command """
+        curr=os.getcwd()
+        os.chdir("C:") #Cannot be on network share when issuing system commands
+        ret = os.system("title " + title)
+        os.chdir(curr)
+        if ret:
+            ignore_termtitle = 1
+
+def set_term_title(title):
+    """ Set terminal title using the 'title' command """
+    global ignore_termtitle
+
+    if ignore_termtitle:
+        return
+    _set_term_title(title)
+
+
diff --git a/IPython/prefilter.py b/IPython/prefilter.py
new file mode 100644
index 0000000..44ab9c7
--- /dev/null
+++ b/IPython/prefilter.py
@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+"""
+Classes and functions for prefiltering (transforming) a line of user input.
+This module is responsible, primarily, for breaking the line up into useful
+pieces and triggering the appropriate handlers in iplib to do the actual
+transforming work.
+"""
+__docformat__ = "restructuredtext en"
+
+import re
+import IPython.ipapi
+
+class LineInfo(object):
+    """A single line of input and associated info.
+
+    Includes the following as properties: 
+
+    line
+      The original, raw line
+    
+    continue_prompt
+      Is this line a continuation in a sequence of multiline input?
+    
+    pre
+      The initial esc character or whitespace.
+    
+    preChar
+      The escape character(s) in pre or the empty string if there isn't one.
+      Note that '!!' is a possible value for preChar.  Otherwise it will
+      always be a single character.
+    
+    preWhitespace
+      The leading whitespace from pre if it exists.  If there is a preChar,
+      this is just ''.
+    
+    iFun
+      The 'function part', which is basically the maximal initial sequence
+      of valid python identifiers and the '.' character.  This is what is
+      checked for alias and magic transformations, used for auto-calling,
+      etc.
+    
+    theRest
+      Everything else on the line.
+    """
+    def __init__(self, line, continue_prompt):
+        self.line            = line
+        self.continue_prompt = continue_prompt
+        self.pre, self.iFun, self.theRest = splitUserInput(line)
+
+        self.preChar       = self.pre.strip()
+        if self.preChar:
+            self.preWhitespace = '' # No whitespace allowd before esc chars
+        else: 
+            self.preWhitespace = self.pre
+
+        self._oinfo = None
+
+    def ofind(self, ip):
+        """Do a full, attribute-walking lookup of the iFun in the various
+        namespaces for the given IPython InteractiveShell instance.
+
+        Return a dict with keys: found,obj,ospace,ismagic
+
+        Note: can cause state changes because of calling getattr, but should
+        only be run if autocall is on and if the line hasn't matched any
+        other, less dangerous handlers.
+
+        Does cache the results of the call, so can be called multiple times
+        without worrying about *further* damaging state.
+        """
+        if not self._oinfo:
+            self._oinfo = ip._ofind(self.iFun)
+        return self._oinfo
+    def __str__(self):                                                         
+        return "Lineinfo [%s|%s|%s]" %(self.pre,self.iFun,self.theRest)        
+
+def splitUserInput(line, pattern=None):
+    """Split user input into pre-char/whitespace, function part and rest.
+
+    Mostly internal to this module, but also used by iplib.expand_aliases,
+    which passes in a shell pattern.
+    """
+    # It seems to me that the shell splitting should be a separate method.
+    
+    if not pattern:
+        pattern = line_split
+    match = pattern.match(line)
+    if not match:
+        #print "match failed for line '%s'" % line
+        try:
+            iFun,theRest = line.split(None,1)
+        except ValueError:
+            #print "split failed for line '%s'" % line
+            iFun,theRest = line,''
+        pre = re.match('^(\s*)(.*)',line).groups()[0]
+    else:
+        pre,iFun,theRest = match.groups()
+
+    # iFun has to be a valid python identifier, so it better be only pure
+    # ascii, no unicode:
+    try:
+        iFun = iFun.encode('ascii')
+    except UnicodeEncodeError:
+        theRest = iFun + u' ' + theRest
+        iFun = u''
+
+    #print 'line:<%s>' % line # dbg
+    #print 'pre <%s> iFun <%s> rest <%s>' % (pre,iFun.strip(),theRest) # dbg
+    return pre,iFun.strip(),theRest.lstrip()
+
+
+# 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 escapes in iplib are changed, as they
+# are hardwired in.
+
+# Although it's not solely driven by the regex, note that:
+# ,;/% only trigger if they are the first character on the line
+# ! and !! trigger if they are first char(s) *or* follow an indent 
+# ? triggers as first or last char.
+
+# The three parts of the regex are:
+#  1) pre:     pre_char *or* initial whitespace 
+#  2) iFun:    first word/method (mix of \w and '.')
+#  3) theRest: rest of line (separated from iFun by space if non-empty)
+line_split = re.compile(r'^([,;/%?]|!!?|\s*)'
+                        r'\s*([\w\.]+)'
+                        r'(\s+.*$|$)')
+
+shell_line_split = re.compile(r'^(\s*)(\S*\s*)(.*$)')
+
+def prefilter(line_info, ip):
+    """Call one of the passed-in InteractiveShell's handler preprocessors,
+    depending on the form of the line.  Return the results, which must be a
+    value, even if it's a blank ('')."""
+    # Note: the order of these checks does matter. 
+    for check in [ checkEmacs,
+                   checkShellEscape,
+                   checkIPyAutocall,
+                   checkMultiLineMagic,
+                   checkEscChars,
+                   checkAssignment,
+                   checkAutomagic,
+                   checkAlias,
+                   checkPythonOps,
+                   checkAutocall,
+                   ]:
+        handler = check(line_info, ip)
+        if handler:
+            return handler(line_info)
+
+    return ip.handle_normal(line_info)
+
+# Handler checks
+#
+# All have the same interface: they take a LineInfo object and a ref to the
+# iplib.InteractiveShell object.  They check the line to see if a particular
+# handler should be called, and return either a handler or None.  The
+# handlers which they return are *bound* methods of the InteractiveShell
+# object. 
+#
+# In general, these checks should only take responsibility for their 'own'
+# handler.  If it doesn't get triggered, they should just return None and
+# let the rest of the check sequence run.
+
+def checkShellEscape(l_info,ip):
+    if l_info.line.lstrip().startswith(ip.ESC_SHELL):
+        return ip.handle_shell_escape
+
+def checkEmacs(l_info,ip):
+    "Emacs ipython-mode tags certain input lines."
+    if l_info.line.endswith('# PYTHON-MODE'):
+        return ip.handle_emacs
+    else:
+        return None
+
+def checkIPyAutocall(l_info,ip):
+    "Instances of IPyAutocall in user_ns get autocalled immediately"
+    obj = ip.user_ns.get(l_info.iFun, None)
+    if isinstance(obj, IPython.ipapi.IPyAutocall):
+        obj.set_ip(ip.api)
+        return ip.handle_auto
+    else:
+        return None
+    
+    
+def checkMultiLineMagic(l_info,ip):
+    "Allow ! and !! in multi-line statements if multi_line_specials is on"
+    # Note that this one of the only places we check the first character of
+    # iFun and *not* the preChar.  Also note that the below test matches
+    # both ! and !!.    
+    if l_info.continue_prompt \
+        and ip.rc.multi_line_specials:
+            if l_info.iFun.startswith(ip.ESC_MAGIC):
+                return ip.handle_magic
+    else:
+        return None
+
+def checkEscChars(l_info,ip):
+    """Check for escape character and return either a handler to handle it,
+    or None if there is no escape char."""
+    if l_info.line[-1] == ip.ESC_HELP \
+           and l_info.preChar != ip.ESC_SHELL \
+           and l_info.preChar != ip.ESC_SH_CAP:
+        # the ? can be at the end, but *not* for either kind of shell escape,
+        # because a ? can be a vaild final char in a shell cmd
+        return ip.handle_help
+    elif l_info.preChar in ip.esc_handlers:
+        return ip.esc_handlers[l_info.preChar]
+    else:
+        return None
+
+
+def checkAssignment(l_info,ip):
+    """Check to see if user is assigning to a var for the first time, in
+    which case we want to avoid any sort of automagic / autocall games.
+    
+    This 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).  E.g. ls='hi', or ls,that=1,2"""
+    if l_info.theRest and l_info.theRest[0] in '=,':
+        return ip.handle_normal
+    else:
+        return None
+
+
+def checkAutomagic(l_info,ip):
+    """If the iFun is magic, and automagic is on, run it.  Note: normal,
+    non-auto magic would already have been triggered via '%' in
+    check_esc_chars. This just checks for automagic.  Also, before
+    triggering the magic handler, make sure that there is nothing in the
+    user namespace which could shadow it."""
+    if not ip.rc.automagic or not hasattr(ip,'magic_'+l_info.iFun):
+        return None
+
+    # We have a likely magic method.  Make sure we should actually call it.
+    if l_info.continue_prompt and not ip.rc.multi_line_specials:
+        return None
+
+    head = l_info.iFun.split('.',1)[0]
+    if isShadowed(head,ip):
+        return None
+
+    return ip.handle_magic
+
+        
+def checkAlias(l_info,ip):
+    "Check if the initital identifier on the line is an alias."
+    # Note: aliases can not contain '.'
+    head = l_info.iFun.split('.',1)[0]
+    
+    if l_info.iFun not in ip.alias_table \
+           or head not in ip.alias_table \
+           or isShadowed(head,ip): 
+        return None
+
+    return ip.handle_alias
+
+
+def checkPythonOps(l_info,ip):
+    """If the 'rest' of the line begins with a function call or pretty much
+    any python operator, we should simply execute the line (regardless of
+    whether or not there's a possible autocall expansion).  This avoids
+    spurious (and very confusing) geattr() accesses."""
+    if l_info.theRest and l_info.theRest[0] in '!=()<>,+*/%^&|':
+        return ip.handle_normal
+    else:
+        return None
+
+
+def checkAutocall(l_info,ip):
+    "Check if the initial word/function is callable and autocall is on."
+    if not ip.rc.autocall:
+        return None
+
+    oinfo = l_info.ofind(ip) # This can mutate state via getattr
+    if not oinfo['found']:
+        return None
+        
+    if callable(oinfo['obj']) \
+           and (not re_exclude_auto.match(l_info.theRest)) \
+           and re_fun_name.match(l_info.iFun):
+        #print 'going auto'  # dbg
+        return ip.handle_auto
+    else:
+        #print 'was callable?', callable(l_info.oinfo['obj'])  # dbg
+        return None
+    
+# RegExp to identify potential function names
+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 checkPythonChars
+# 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.
+re_exclude_auto = re.compile(r'^[,&^\|\*/\+-]'
+                             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_.\[\]]*) ?$')
+
+# Handler Check Utilities
+def isShadowed(identifier,ip):
+    """Is the given identifier defined in one of the namespaces which shadow
+    the alias and magic namespaces?  Note that an identifier is different
+    than iFun, because it can not contain a '.' character."""
+    # This is much safer than calling ofind, which can change state
+    return (identifier in ip.user_ns \
+            or identifier in ip.internal_ns \
+            or identifier in ip.ns_table['builtin'])
+
diff --git a/IPython/rlineimpl.py b/IPython/rlineimpl.py
new file mode 100644
index 0000000..5253419
--- /dev/null
+++ b/IPython/rlineimpl.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+""" Imports and provides the 'correct' version of readline for the platform.
+
+Readline is used throughout IPython as 'import IPython.rlineimpl as readline'.
+
+In addition to normal readline stuff, this module provides have_readline
+boolean and _outputfile variable used in genutils.
+
+$Id: Magic.py 1096 2006-01-28 20:08:02Z vivainio $"""
+
+import sys
+
+try:
+    from readline import *
+    import readline as _rl
+    have_readline = True
+except ImportError:
+    try:
+        from pyreadline import *
+        import pyreadline as _rl
+        have_readline = True
+    except ImportError:    
+        have_readline = False
+
+if sys.platform == 'win32' and have_readline:
+    try:
+        _outputfile=_rl.GetOutputFile()
+    except AttributeError:
+        print "Failed GetOutputFile"
+        have_readline = False
+
+# Test to see if libedit is being used instead of GNU readline.
+# Thanks to Boyd Waters for this patch.
+uses_libedit = False
+if sys.platform == 'darwin' and have_readline:
+    import commands
+    (status, result) = commands.getstatusoutput( "otool -L %s | grep libedit" % _rl.__file__ )
+    if status == 0 and len(result) > 0:
+        # we are bound to libedit - new in Leopard
+        _rl.parse_and_bind("bind ^I rl_complete")
+        print "Leopard libedit detected."
+        uses_libedit = True
+
+
+# the clear_history() function was only introduced in Python 2.4 and is
+# actually optional in the readline API, so we must explicitly check for its
+# existence.  Some known platforms actually don't have it.  This thread:
+# http://mail.python.org/pipermail/python-dev/2003-August/037845.html
+# has the original discussion.
+
+if have_readline:
+    try:
+        _rl.clear_history
+    except AttributeError:
+        def clear_history(): pass
+        _rl.clear_history = clear_history
\ No newline at end of file
diff --git a/IPython/shadowns.py b/IPython/shadowns.py
new file mode 100644
index 0000000..d2d93b6
--- /dev/null
+++ b/IPython/shadowns.py
@@ -0,0 +1 @@
+""" Shadow namespace """
\ No newline at end of file
diff --git a/IPython/strdispatch.py b/IPython/strdispatch.py
new file mode 100644
index 0000000..8516528
--- /dev/null
+++ b/IPython/strdispatch.py
@@ -0,0 +1,65 @@
+from IPython.hooks import CommandChainDispatcher
+import IPython.hooks
+
+import re
+
+class StrDispatch(object):
+    """ Dispatch (lookup) a set of strings / regexps for match """
+    def __init__(self):
+        self.strs = {}
+        self.regexs = {}
+    def add_s(self, s, obj, priority= 0 ):
+        """ Adds a target 'string' for dispatching """
+        
+        chain = self.strs.get(s, CommandChainDispatcher())
+        chain.add(obj,priority)
+        self.strs[s] = chain
+
+    def add_re(self, regex, obj, priority= 0 ):
+        """ Adds a target regexp for dispatching """
+        
+        chain = self.regexs.get(regex, CommandChainDispatcher())
+        chain.add(obj,priority)
+        self.regexs[regex] = chain
+
+    def dispatch(self, key):
+        """ Get a seq of Commandchain objects that match key """
+        if key in self.strs:
+            yield self.strs[key]
+        
+        for r, obj in self.regexs.items():
+            if re.match(r, key):
+                yield obj
+            else: 
+                #print "nomatch",key
+                pass
+            
+
+    def __repr__(self):
+        return "<Strdispatch %s, %s>" % (self.strs, self.regexs)
+    
+    def s_matches(self, key):
+        if key not in self.strs:
+             return
+        for el in self.strs[key]:
+            yield el[1]
+        
+        
+    def flat_matches(self, key):
+        """ Yield all 'value' targets, without priority """
+        for val in self.dispatch(key):
+            for el in val:
+                yield el[1] # only value, no priority
+        return
+         
+
+def test():
+    d = StrDispatch()
+    d.add_s('hei',34, priority = 4)
+    d.add_s('hei',123, priority = 2)
+    print  list(d.dispatch('hei'))
+    d.add_re('h.i', 686)
+    print list(d.flat_matches('hei'))
+
+if __name__ == '__main__':
+    test()    
\ No newline at end of file
diff --git a/IPython/ultraTB.py b/IPython/ultraTB.py
new file mode 100644
index 0000000..06a5243
--- /dev/null
+++ b/IPython/ultraTB.py
@@ -0,0 +1,1045 @@
+# -*- 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 2908 2007-12-30 21:07:46Z vivainio $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001 Nathaniel Gray <n8gray@caltech.edu>
+#       Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
+#
+#  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 re
+import string
+import sys
+import time
+import tokenize
+import traceback
+import types
+
+# For purposes of monkeypatching inspect to fix a bug in it.
+from inspect import getsourcefile, getfile, getmodule,\
+     ismodule,  isclass, ismethod, isfunction, istraceback, isframe, iscode
+
+
+# IPython's own modules
+# Modified pdb which doesn't damage IPython's readline handling
+from IPython import Debugger, PyColorize
+from IPython.ipstruct import Struct
+from IPython.excolors import ExceptionColors
+from IPython.genutils import Term,uniq_stable,error,info
+
+# Globals
+# amount of space to put line numbers before verbose tracebacks
+INDENT_SIZE = 8
+
+# Default color scheme.  This is used, for example, by the traceback
+# formatter.  When running in an actual IPython instance, the user's rc.colors
+# value is used, but havinga module global makes this functionality available
+# to users of ultraTB who are NOT running inside ipython.
+DEFAULT_SCHEME = 'NoColor'
+
+#---------------------------------------------------------------------------
+# 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 findsource(object):
+    """Return the entire source file and starting line number for an object.
+
+    The argument may be a module, class, method, function, traceback, frame,
+    or code object.  The source code is returned as a list of all the lines
+    in the file and the line number indexes a line in that list.  An IOError
+    is raised if the source code cannot be retrieved.
+
+    FIXED version with which we monkeypatch the stdlib to work around a bug."""
+
+    file = getsourcefile(object) or getfile(object)
+    # If the object is a frame, then trying to get the globals dict from its
+    # module won't work. Instead, the frame object itself has the globals
+    # dictionary.
+    globals_dict = None
+    if inspect.isframe(object):
+        # XXX: can this ever be false?
+        globals_dict = object.f_globals
+    else:
+        module = getmodule(object, file)
+        if module:
+            globals_dict = module.__dict__
+    lines = linecache.getlines(file, globals_dict)
+    if not lines:
+        raise IOError('could not get source code')
+
+    if ismodule(object):
+        return lines, 0
+
+    if isclass(object):
+        name = object.__name__
+        pat = re.compile(r'^(\s*)class\s*' + name + r'\b')
+        # make some effort to find the best matching class definition:
+        # use the one with the least indentation, which is the one
+        # that's most probably not inside a function definition.
+        candidates = []
+        for i in range(len(lines)):
+            match = pat.match(lines[i])
+            if match:
+                # if it's at toplevel, it's already the best one
+                if lines[i][0] == 'c':
+                    return lines, i
+                # else add whitespace to candidate list
+                candidates.append((match.group(1), i))
+        if candidates:
+            # this will sort by whitespace, and by line number,
+            # less whitespace first
+            candidates.sort()
+            return lines, candidates[0][1]
+        else:
+            raise IOError('could not find class definition')
+
+    if ismethod(object):
+        object = object.im_func
+    if isfunction(object):
+        object = object.func_code
+    if istraceback(object):
+        object = object.tb_frame
+    if isframe(object):
+        object = object.f_code
+    if iscode(object):
+        if not hasattr(object, 'co_firstlineno'):
+            raise IOError('could not find function definition')
+        pat = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
+        pmatch = pat.match
+        # fperez - fix: sometimes, co_firstlineno can give a number larger than
+        # the length of lines, which causes an error.  Safeguard against that.
+        lnum = min(object.co_firstlineno,len(lines))-1
+        while lnum > 0:
+            if pmatch(lines[lnum]): break
+            lnum -= 1
+ 
+        return lines, lnum
+    raise IOError('could not find code object')
+
+# Monkeypatch inspect to apply our bugfix.  This code only works with py25
+if sys.version_info[:2] >= (2,5):
+    inspect.findsource = findsource
+
+def fix_frame_records_filenames(records):
+    """Try to fix the filenames in each record from inspect.getinnerframes().
+
+    Particularly, modules loaded from within zip files have useless filenames
+    attached to their code object, and inspect.getinnerframes() just uses it.
+    """
+    fixed_records = []
+    for frame, filename, line_no, func_name, lines, index in records:
+        # Look inside the frame's globals dictionary for __file__, which should
+        # be better.
+        better_fn = frame.f_globals.get('__file__', None)
+        if isinstance(better_fn, str):
+            # Check the type just in case someone did something weird with
+            # __file__. It might also be None if the error occurred during
+            # import.
+            filename = better_fn
+        fixed_records.append((frame, filename, line_no, func_name, lines, index))
+    return fixed_records
+
+
+def _fixed_getinnerframes(etb, context=1,tb_offset=0):
+    import linecache
+    LNUM_POS, LINES_POS, INDEX_POS =  2, 4, 5
+
+    records  = fix_frame_records_filenames(inspect.getinnerframes(etb, context))
+
+    # If the error is at the console, don't build any context, since it would
+    # otherwise produce 5 blank lines printed out (there is no file at the
+    # 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)
+
+_parser = PyColorize.Parser()
+    
+def _formatTracebackLines(lnum, index, lines, Colors, lvals=None,scheme=None):
+    numbers_width = INDENT_SIZE - 1
+    res = []
+    i = lnum - index
+
+    # This lets us get fully syntax-highlighted tracebacks.
+    if scheme is None:
+        try:
+            scheme = __IPYTHON__.rc.colors
+        except:
+            scheme = DEFAULT_SCHEME
+    _line_format = _parser.format2
+
+    for line in lines:
+        new_line, err = _line_format(line,'str',scheme)
+        if not err: line = new_line
+        
+        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):
+        Term.cout.flush()
+        Term.cerr.flush()
+        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 = []
+        try:
+            stype = Colors.excName + etype.__name__ + Colors.Normal
+        except AttributeError:
+            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
+        try:
+            etype = etype.__name__
+        except AttributeError:
+            pass
+        Colors        = self.Colors   # just a shorthand + quicker name lookup
+        ColorsNormal  = Colors.Normal  # used a lot
+        col_scheme    = self.color_scheme_table.active_scheme_name
+        indent        = ' '*INDENT_SIZE
+        em_normal     = '%s\n%s%s' % (Colors.valEm, indent,ColorsNormal)
+        undefined     = '%sundefined%s' % (Colors.em, ColorsNormal)
+        exc = '%s%s%s' % (Colors.excName,etype,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
+        try:
+            etype = etype.__name__
+        except AttributeError:
+            pass
+
+        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,Colors,lvals,
+                                          col_scheme))))
+
+        # 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,force=False):
+        """Call up the pdb debugger if desired, always clean up the tb
+        reference.
+
+        Keywords:
+
+          - force(False): by default, this routine checks the instance call_pdb
+          flag and does not actually invoke the debugger if the flag is false.
+          The 'force' option forces the debugger to activate even if the flag
+          is false.
+
+        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 force or 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
+            if hasattr(self,'tb'):
+                etb = self.tb
+            else:
+                etb = self.tb = sys.last_traceback
+            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)
+            finally:
+                sys.displayhook = dhook
+            
+        if hasattr(self,'tb'):
+            del self.tb
+
+    def handler(self, info=None):
+        (etype, evalue, etb) = info or sys.exc_info()
+        self.tb = etb
+        Term.cout.flush()
+        Term.cerr.flush()
+        print >> Term.cerr, self.text(etype, evalue, etb)
+
+    # 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))
+        try:
+            self.debugger()
+        except KeyboardInterrupt:
+            print "\nKeyboardInterrupt"
+
+#----------------------------------------------------------------------------
+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
+        Term.cout.flush()
+        out.flush()
+        if tb_offset is not None:
+            tb_offset, self.tb_offset = self.tb_offset, tb_offset
+            print >> out, self.text(etype, evalue, etb)
+            self.tb_offset = tb_offset
+        else:
+            print >> out, self.text(etype, evalue, etb)
+        try:
+            self.debugger()
+        except KeyboardInterrupt:
+            print "\nKeyboardInterrupt"
+
+    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 ''
+    
diff --git a/IPython/upgrade_dir.py b/IPython/upgrade_dir.py
new file mode 100644
index 0000000..2f31e93
--- /dev/null
+++ b/IPython/upgrade_dir.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+""" A script/util to upgrade all files in a directory
+
+This is rather conservative in its approach, only copying/overwriting
+new and unedited files.
+
+To be used by "upgrade" feature.
+"""
+try:
+    from IPython.external.path import path
+except ImportError:
+    from path import path
+
+import md5,pickle
+
+def showdiff(old,new):
+    import difflib
+    d = difflib.Differ()
+    lines = d.compare(old.lines(),new.lines())
+    realdiff = False
+    for l in lines:
+        print l,
+        if not realdiff and not l[0].isspace():
+            realdiff = True
+    return realdiff
+
+def upgrade_dir(srcdir, tgtdir):
+    """ Copy over all files in srcdir to tgtdir w/ native line endings
+
+    Creates .upgrade_report in tgtdir that stores md5sums of all files
+    to notice changed files b/w upgrades.
+    """
+
+    def pr(s):
+        print s
+    junk = ['.svn','ipythonrc*','*.pyc', '*.pyo', '*~', '.hg']
+    
+    def ignorable(p):
+        for pat in junk:
+            if p.startswith(pat) or p.fnmatch(pat):
+                return True
+        return False
+
+    modded = []
+    files = [path(srcdir).relpathto(p) for p in path(srcdir).walkfiles()]
+    #print files
+    rep = tgtdir / '.upgrade_report'
+    try:
+        rpt = pickle.load(rep.open())
+    except:
+        rpt = {}
+
+    for f in files:
+        if ignorable(f):
+            continue
+        src = srcdir / f
+        tgt = tgtdir / f
+        if not tgt.isfile():
+            pr("Creating %s" % str(tgt))
+
+            tgt.write_text(src.text())
+            rpt[str(tgt)] = md5.new(tgt.text()).hexdigest()
+        else:
+            cont = tgt.text()
+            sum = rpt.get(str(tgt), None)
+            #print sum
+            if sum and md5.new(cont).hexdigest() == sum:
+                pr("%s: Unedited, installing new version" % tgt)
+                tgt.write_text(src.text())
+                rpt[str(tgt)] = md5.new(tgt.text()).hexdigest()
+            else:
+                pr(' == Modified, skipping %s, diffs below == ' % tgt)
+                #rpt[str(tgt)] = md5.new(tgt.bytes()).hexdigest()
+                real = showdiff(tgt,src)
+                pr('') # empty line
+                if not real:
+                    pr("(Ok, it was identical, only upgrading checksum)")
+                    rpt[str(tgt)] = md5.new(tgt.text()).hexdigest()
+                else:
+                    modded.append(tgt)
+
+        #print rpt
+    pickle.dump(rpt, rep.open('w'))
+    if modded:
+        print "\n\nDelete the following files manually (and rerun %upgrade)\nif you need a full upgrade:"
+        for m in modded:
+            print m
+
+
+import sys
+if __name__ == "__main__":
+    upgrade_dir(path(sys.argv[1]), path(sys.argv[2]))
diff --git a/IPython/usage.py b/IPython/usage.py
new file mode 100644
index 0000000..ebcb052
--- /dev/null
+++ b/IPython/usage.py
@@ -0,0 +1,654 @@
+# -*- coding: utf-8 -*-
+#*****************************************************************************
+#       Copyright (C) 2001-2004 Fernando Perez. <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+# $Id: usage.py 2723 2007-09-07 07:44:16Z fperez $
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+__version__ = Release.version
+
+__doc__ = """
+IPython -- An enhanced Interactive Python
+=========================================
+
+A Python shell with automatic history (input and output), dynamic object
+introspection, easier configuration, command completion, access to the system
+shell and more.
+
+IPython can also be embedded in running programs. See EMBEDDING below.
+
+
+USAGE
+       ipython [options] files
+
+       If invoked with no options, it executes all the files listed in
+       sequence and drops you into the interpreter while still acknowledging
+       any options you may have set in your ipythonrc file. This behavior is
+       different from standard Python, which when called as python -i will
+       only execute one file and will ignore your configuration setup.
+
+       Please note that some of the configuration options are not available at
+       the command line, simply because they are not practical here. Look into
+       your ipythonrc configuration file for details on those. This file
+       typically installed in the $HOME/.ipython directory.
+
+       For Windows users, $HOME resolves to C:\\Documents and
+       Settings\\YourUserName in most instances, and _ipython is used instead
+       of .ipython, since some Win32 programs have problems with dotted names
+       in directories.
+
+       In the rest of this text, we will refer to this directory as
+       IPYTHONDIR.
+
+
+SPECIAL THREADING OPTIONS
+       The following special options are ONLY valid at the  beginning  of  the
+       command line, and not later.  This is because they control the initial-
+       ization of ipython itself, before the normal option-handling  mechanism
+       is active.
+
+       -gthread, -qthread, -q4thread, -wthread, -pylab
+
+              Only ONE of these can be given, and it can only be given as the
+              first option passed to IPython (it will have no effect in any
+              other position).  They provide threading support for the GTK, QT
+              and WXWidgets toolkits, and for the matplotlib library.
+
+              With any of the first four options, IPython starts running a
+              separate thread for the graphical toolkit's operation, so that
+              you can open and control graphical elements from within an
+              IPython command line, without blocking.  All four provide
+              essentially the same functionality, respectively for GTK, QT3,
+              QT4 and WXWidgets (via their Python interfaces).
+
+              Note that with -wthread, you can additionally use the -wxversion
+              option to request a specific version of wx to be used.  This
+              requires that you have the 'wxversion' Python module installed,
+              which is part of recent wxPython distributions.
+
+              If -pylab is given, IPython loads special support for the mat-
+              plotlib library (http://matplotlib.sourceforge.net), allowing
+              interactive usage of any of its backends as defined in the
+              user's .matplotlibrc file.  It automatically activates GTK, QT
+              or WX threading for IPyhton if the choice of matplotlib backend
+              requires it.  It also modifies the %run command to correctly
+              execute (without blocking) any matplotlib-based script which
+              calls show() at the end.
+
+       -tk    The -g/q/q4/wthread options, and -pylab (if matplotlib is
+              configured to use GTK, QT or WX), will normally block Tk
+              graphical interfaces.  This means that when GTK, QT or WX
+              threading is active, any attempt to open a Tk GUI will result in
+              a dead window, and possibly cause the Python interpreter to
+              crash.  An extra option, -tk, is available to address this
+              issue.  It can ONLY be given as a SECOND option after any of the
+              above (-gthread, -qthread, q4thread, -wthread or -pylab).
+
+              If -tk is given, IPython will try to coordinate Tk threading
+              with GTK, QT or WX.  This is however potentially unreliable, and
+              you will have to test on your platform and Python configuration
+              to determine whether it works for you.  Debian users have
+              reported success, apparently due to the fact that Debian builds
+              all of Tcl, Tk, Tkinter and Python with pthreads support.  Under
+              other Linux environments (such as Fedora Core 2/3), this option
+              has caused random crashes and lockups of the Python interpreter.
+              Under other operating systems (Mac OSX and Windows), you'll need
+              to try it to find out, since currently no user reports are
+              available.
+
+              There is unfortunately no way for IPython to determine  at  run-
+              time  whether -tk will work reliably or not, so you will need to
+              do some experiments before relying on it for regular work.
+
+A WARNING ABOUT SIGNALS AND THREADS
+
+       When any of the thread systems (GTK, QT or WX) are active, either
+       directly or via -pylab with a threaded backend, it is impossible to
+       interrupt long-running Python code via Ctrl-C.  IPython can not pass
+       the KeyboardInterrupt exception (or the underlying SIGINT) across
+       threads, so any long-running process started from IPython will run to
+       completion, or will have to be killed via an external (OS-based)
+       mechanism.
+
+       To the best of my knowledge, this limitation is imposed by the Python
+       interpreter itself, and it comes from the difficulty of writing
+       portable signal/threaded code.  If any user is an expert on this topic
+       and can suggest a better solution, I would love to hear about it.  In
+       the IPython sources, look at the Shell.py module, and in particular at
+       the runcode() method.
+
+REGULAR OPTIONS
+       After the above threading options have been given, regular options  can
+       follow  in any order.  All options can be abbreviated to their shortest
+       non-ambiguous form and are case-sensitive.  One or two  dashes  can  be
+       used.   Some options have an alternate short form, indicated after a |.
+
+       Most options can also be set from your  ipythonrc  configuration  file.
+       See the provided examples for assistance.  Options given on the comman-
+       dline override the values set in the ipythonrc file.
+
+       All options with a [no] prepended can be specified in negated form
+       (using -nooption instead of -option) to turn the feature off.
+
+       -h, --help
+              Show summary of options.
+
+       -pylab This can only be given as the first option passed to IPython (it
+              will have no effect in any other position). It adds special sup-
+              port   for  the  matplotlib  library  (http://matplotlib.source-
+              forge.net), allowing interactive usage of any of its backends as
+              defined  in  the  user's  .matplotlibrc  file.  It automatically
+              activates GTK or WX threading for IPyhton if the choice of  mat-
+              plotlib  backend requires it.  It also modifies the @run command
+              to correctly execute  (without  blocking)  any  matplotlib-based
+              script which calls show() at the end.
+
+       -autocall <val>
+              Make IPython automatically call any callable object even if you
+              didn't type explicit parentheses. For example, 'str 43' becomes
+              'str(43)' automatically.  The value can be '0' to disable the
+              feature, '1' for 'smart' autocall, where it is not applied if
+              there are no more arguments on the line, and '2' for 'full'
+              autocall, where all callable objects are automatically called
+              (even if no arguments are present).  The default is '1'.
+
+       -[no]autoindent
+              Turn automatic indentation on/off.
+
+       -[no]automagic
+              Make magic commands automatic (without needing their first char-
+              acter to be %).  Type %magic at  the  IPython  prompt  for  more
+              information.
+
+       -[no]autoedit_syntax
+              When a syntax error occurs after editing a file, automatically
+              open the file to the trouble causing line for convenient fixing.
+
+       -[no]banner
+              Print the intial information banner (default on).
+
+       -c <command>
+              Execute  the  given  command  string, and set sys.argv to ['c'].
+              This is similar to the -c option in  the  normal  Python  inter-
+              preter.
+
+       -cache_size|cs <n>
+              Size  of  the output cache (maximum number of entries to hold in
+              memory).  The default is 1000, you can change it permanently  in
+              your  config  file.   Setting  it  to  0 completely disables the
+              caching system, and the minimum value accepted  is  20  (if  you
+              provide  a value less than 20, it is reset to 0 and a warning is
+              issued).  This limit is defined because otherwise  you'll  spend
+              more time re-flushing a too small cache than working.
+
+       -classic|cl
+              Gives IPython a similar feel to the classic Python prompt.
+
+       -colors <scheme>
+              Color  scheme  for  prompts  and exception reporting.  Currently
+              implemented: NoColor, Linux, and LightBG.
+
+       -[no]color_info
+              IPython can display information about objects via a set of func-
+              tions, and optionally can use colors for this, syntax highlight-
+              ing source code and various other  elements.   However,  because
+              this  information  is  passed  through a pager (like 'less') and
+              many pagers get confused with color codes, this option is off by
+              default.   You  can  test  it and turn it on permanently in your
+              ipythonrc file if it works for you.  As a reference, the  'less'
+              pager  supplied  with  Mandrake 8.2 works ok, but that in RedHat
+              7.2 doesn't.
+
+              Test it and turn it on permanently if it works with your system.
+              The  magic function @color_info allows you to toggle this inter-
+              actively for testing.
+
+       -[no]confirm_exit
+              Set to confirm when you try to exit IPython with  an  EOF  (Con-
+              trol-D in Unix, Control-Z/Enter in Windows). Note that using the
+              magic functions @Exit or @Quit you  can  force  a  direct  exit,
+              bypassing any confirmation.
+
+       -[no]debug
+              Show  information  about the loading process. Very useful to pin
+              down problems with your configuration files or  to  get  details
+              about session restores.
+
+       -[no]deep_reload
+              IPython  can use the deep_reload module which reloads changes in
+              modules recursively (it replaces the reload() function,  so  you
+              don't need to change anything to use it). deep_reload() forces a
+              full reload of modules whose code may have  changed,  which  the
+              default reload() function does not.
+
+              When  deep_reload  is off, IPython will use the normal reload(),
+              but deep_reload will still be available as dreload(). This  fea-
+              ture  is  off  by default [which means that you have both normal
+              reload() and dreload()].
+
+       -editor <name>
+              Which editor to use with the @edit command. By default,  IPython
+              will  honor  your EDITOR environment variable (if not set, vi is
+              the Unix default and notepad the Windows one). Since this editor
+              is  invoked on the fly by IPython and is meant for editing small
+              code snippets, you may want to use a small,  lightweight  editor
+              here (in case your default EDITOR is something like Emacs).
+
+       -ipythondir <name>
+              The  name  of  your  IPython configuration directory IPYTHONDIR.
+              This can also be  specified  through  the  environment  variable
+              IPYTHONDIR.
+
+       -log|l Generate  a log file of all input. The file is named
+              ipython_log.py in your current directory (which prevents logs
+              from multiple IPython sessions from trampling each other). You
+              can use this to later restore a session by loading your logfile
+              as a file to be executed with option -logplay (see below).
+
+       -logfile|lf
+              Specify the name of your logfile.
+
+       -logplay|lp
+              Replay  a previous log. For restoring a session as close as pos-
+              sible to the state you left it in, use this option  (don't  just
+              run the logfile). With -logplay, IPython will try to reconstruct
+              the previous working environment in full, not just  execute  the
+              commands in the logfile.
+              When  a  session is restored, logging is automatically turned on
+              again with the name of the logfile it was invoked  with  (it  is
+              read  from the log header). So once you've turned logging on for
+              a session, you can quit IPython and reload it as many  times  as
+              you  want  and  it  will continue to log its history and restore
+              from the beginning every time.
+
+              Caveats: there are limitations in this option. The history vari-
+              ables  _i*,_* and _dh don't get restored properly. In the future
+              we will try to implement full  session  saving  by  writing  and
+              retrieving  a failed because of inherent limitations of Python's
+              Pickle module, so this may have to wait.
+
+       -[no]messages
+              Print messages which IPython collects about its startup  process
+              (default on).
+
+       -[no]pdb
+              Automatically  call the pdb debugger after every uncaught excep-
+              tion. If you are used to debugging  using  pdb,  this  puts  you
+              automatically  inside of it after any call (either in IPython or
+              in code called by it) which triggers  an  exception  which  goes
+              uncaught.
+
+       -[no]pprint
+              IPython  can  optionally  use the pprint (pretty printer) module
+              for displaying results. pprint tends to give a nicer display  of
+              nested  data structures. If you like it, you can turn it on per-
+              manently in your config file (default off).
+
+       -profile|p <name>
+              Assume that your config file is ipythonrc-<name> (looks in  cur-
+              rent dir first, then in IPYTHONDIR). This is a quick way to keep
+              and load multiple config files for different  tasks,  especially
+              if  you  use  the include option of config files. You can keep a
+              basic IPYTHONDIR/ipythonrc file and then have  other  'profiles'
+              which  include  this  one  and  load extra things for particular
+              tasks. For example:
+
+              1) $HOME/.ipython/ipythonrc : load basic things you always want.
+              2)  $HOME/.ipython/ipythonrc-math  :  load  (1)  and basic math-
+              related modules.
+              3) $HOME/.ipython/ipythonrc-numeric : load (1) and  Numeric  and
+              plotting modules.
+
+              Since  it is possible to create an endless loop by having circu-
+              lar file inclusions, IPython will stop if it reaches  15  recur-
+              sive inclusions.
+
+       -prompt_in1|pi1 <string>
+              Specify  the string used for input prompts. Note that if you are
+              using numbered prompts, the number is represented with a '\#' in
+              the  string.  Don't forget to quote strings with spaces embedded
+              in them. Default: 'In [\#]: '.
+
+              Most bash-like  escapes  can  be  used  to  customize  IPython's
+              prompts, as well as a few additional ones which are IPython-spe-
+              cific.  All valid prompt escapes are described in detail in  the
+              Customization section of the IPython HTML/PDF manual.
+
+       -prompt_in2|pi2 <string>
+              Similar to the previous option, but used for the continuation
+              prompts. The special sequence '\D' is similar to '\#', but with
+              all digits replaced dots (so you can have your continuation
+              prompt aligned with your input prompt).  Default: ' .\D.: '
+              (note three spaces at the start for alignment with 'In [\#]').
+
+       -prompt_out|po <string>
+              String   used   for  output  prompts,  also  uses  numbers  like
+              prompt_in1.  Default: 'Out[\#]:'.
+
+       -quick Start in bare bones mode (no config file loaded).
+
+       -rcfile <name>
+              Name of your  IPython  resource  configuration  file.   normally
+              IPython    loads   ipythonrc   (from   current   directory)   or
+              IPYTHONDIR/ipythonrc.  If the loading of your config file fails,
+              IPython  starts  with  a  bare  bones  configuration (no modules
+              loaded at all).
+
+       -[no]readline
+              Use the readline library, which is needed to support  name  com-
+              pletion  and  command history, among other things. It is enabled
+              by default, but may cause  problems  for  users  of  X/Emacs  in
+              Python comint or shell buffers.
+
+              Note  that  emacs 'eterm' buffers (opened with M-x term) support
+              IPython's readline and syntax coloring fine, only  'emacs'  (M-x
+              shell and C-c !)  buffers do not.
+
+       -screen_length|sl <n>
+              Number  of lines of your screen.  This is used to control print-
+              ing of very long strings.  Strings longer than  this  number  of
+              lines  will be sent through a pager instead of directly printed.
+
+              The default value for this is 0, which means IPython will  auto-
+              detect  your  screen  size  every time it needs to print certain
+              potentially long strings (this doesn't change  the  behavior  of
+              the  'print'  keyword,  it's  only triggered internally). If for
+              some reason this isn't working well (it needs  curses  support),
+              specify it yourself. Otherwise don't change the default.
+
+       -separate_in|si <string>
+              Separator before input prompts.  Default '0.
+
+       -separate_out|so <string>
+              Separator before output prompts.  Default: 0 (nothing).
+
+       -separate_out2|so2 <string>
+              Separator after output prompts.  Default: 0 (nothing).
+
+       -nosep Shorthand for '-separate_in 0 -separate_out 0 -separate_out2 0'.
+              Simply removes all input/output separators.
+
+       -upgrade
+              Allows you to upgrade your  IPYTHONDIR  configuration  when  you
+              install  a  new  version  of  IPython.   Since  new versions may
+              include new command lines options or example files, this  copies
+              updated ipythonrc-type files.  However, it backs up (with a .old
+              extension) all files which it overwrites so that you  can  merge
+              back any custimizations you might have in your personal files.
+
+       -Version
+              Print version information and exit.
+
+       -wxversion <string>
+              Select a specific version of wxPython (used in conjunction with
+              -wthread). Requires the wxversion module, part of recent
+              wxPython distributions.
+
+       -xmode <modename>
+              Mode  for  exception reporting.  The valid modes are Plain, Con-
+              text, and Verbose.
+
+              - Plain: similar to python's normal traceback printing.
+
+              - Context: prints 5 lines of context  source  code  around  each
+              line in the traceback.
+
+              - Verbose: similar to Context, but additionally prints the vari-
+              ables 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  repre-
+              sentation  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).
+
+
+EMBEDDING
+       It is possible to start an IPython instance inside your own Python pro-
+       grams.  In the documentation example files there are some illustrations
+       on how to do this.
+
+       This feature allows you to evalutate  dynamically  the  state  of  your
+       code,  operate  with  your  variables, analyze them, etc.  Note however
+       that any changes you make to values while in the shell do NOT propagate
+       back  to  the running code, so it is safe to modify your values because
+       you won't break your code in bizarre ways by doing so.
+"""
+
+cmd_line_usage = __doc__
+
+#---------------------------------------------------------------------------
+interactive_usage = """
+IPython -- An enhanced Interactive Python
+=========================================
+
+IPython offers a combination of convenient shell features, special commands
+and a history mechanism for both input (command history) and output (results
+caching, similar to Mathematica). It is intended to be a fully compatible
+replacement for the standard Python interpreter, while offering vastly
+improved functionality and flexibility.
+
+At your system command line, type 'ipython -help' to see the command line
+options available. This document only describes interactive features.
+
+Warning: IPython relies on the existence of a global variable called __IP which
+controls the shell itself. If you redefine __IP to anything, bizarre behavior
+will quickly occur.
+
+MAIN FEATURES
+
+* Access to the standard Python help. As of Python 2.1, a help system is
+  available with access to object docstrings and the Python manuals. Simply
+  type 'help' (no quotes) to access it.
+
+* Magic commands: type %magic for information on the magic subsystem.
+
+* System command aliases, via the %alias command or the ipythonrc config file.
+
+* Dynamic object information:
+
+  Typing ?word or word? prints detailed information about an object.  If
+  certain strings in the object are too long (docstrings, code, etc.) they get
+  snipped in the center for brevity.
+
+  Typing ??word or word?? gives access to the full information without
+  snipping long strings. Long strings are sent to the screen through the less
+  pager if longer than the screen, printed otherwise.
+
+  The ?/?? system gives access to the full source code for any object (if
+  available), shows function prototypes and other useful information.
+
+  If you just want to see an object's docstring, type '%pdoc object' (without
+  quotes, and without % if you have automagic on).
+
+  Both %pdoc and ?/?? give you access to documentation even on things which are
+  not explicitely defined. Try for example typing {}.get? or after import os,
+  type os.path.abspath??. The magic functions %pdef, %source and %file operate
+  similarly.
+
+* Completion in the local namespace, by typing TAB at the prompt.
+
+  At any time, hitting tab will complete any available python commands or
+  variable names, and show you a list of the possible completions if there's
+  no unambiguous one. It will also complete filenames in the current directory.
+
+  This feature requires the readline and rlcomplete modules, so it won't work
+  if your Python lacks readline support (such as under Windows).
+
+* Search previous command history in two ways (also requires readline):
+
+  - Start typing, and then use Ctrl-p (previous,up) and Ctrl-n (next,down) to
+  search through only the history items that match what you've typed so
+  far. If you use Ctrl-p/Ctrl-n at a blank prompt, they just behave like
+  normal arrow keys.
+
+  - Hit Ctrl-r: opens a search prompt. Begin typing and the system searches
+  your history for lines that match what you've typed so far, completing as
+  much as it can.
+
+* Persistent command history across sessions (readline required).
+
+* Logging of input with the ability to save and restore a working session.
+  
+* System escape with !. Typing !ls will run 'ls' in the current directory.
+
+* The reload command does a 'deep' reload of a module: changes made to the
+  module since you imported will actually be available without having to exit.
+
+* Verbose and colored exception traceback printouts. See the magic xmode and
+  xcolor functions for details (just type %magic).
+
+* Input caching system:
+
+  IPython offers numbered prompts (In/Out) with input and output caching. All
+  input is saved and can be retrieved as variables (besides the usual arrow
+  key recall).
+
+  The following GLOBAL variables always exist (so don't overwrite them!):
+  _i: stores previous input.
+  _ii: next previous.
+  _iii: next-next previous.
+  _ih : a list of all input _ih[n] is the input from line n.
+
+  Additionally, global variables named _i<n> are dynamically created (<n>
+  being the prompt counter), such that _i<n> == _ih[<n>]
+
+  For example, what you typed at prompt 14 is available as _i14 and _ih[14].
+
+  You can create macros which contain multiple input lines from this history,
+  for later re-execution, with the %macro function.
+
+  The history function %hist allows you to see any part of your input history
+  by printing a range of the _i variables. Note that inputs which contain
+  magic functions (%) appear in the history with a prepended comment. This is
+  because they aren't really valid Python code, so you can't exec them.
+
+* Output caching system:
+
+  For output that is returned from actions, a system similar to the input
+  cache exists but using _ instead of _i. Only actions that produce a result
+  (NOT assignments, for example) are cached. If you are familiar with
+  Mathematica, IPython's _ variables behave exactly like Mathematica's %
+  variables.
+
+  The following GLOBAL variables always exist (so don't overwrite them!):
+  _ (one underscore): previous output.
+  __ (two underscores): next previous.
+  ___ (three underscores): next-next previous.
+
+  Global variables named _<n> are dynamically created (<n> being the prompt
+  counter), such that the result of output <n> is always available as _<n>.
+
+  Finally, a global dictionary named _oh exists with entries for all lines
+  which generated output.
+
+* Directory history:
+
+  Your history of visited directories is kept in the global list _dh, and the
+  magic %cd command can be used to go to any entry in that list.
+
+* Auto-parentheses and auto-quotes (adapted from Nathan Gray's LazyPython)
+
+    1. Auto-parentheses
+        Callable objects (i.e. functions, methods, etc) can be invoked like
+        this (notice the commas between the arguments):
+            >>> callable_ob arg1, arg2, arg3
+        and the input will be translated to this:
+            --> callable_ob(arg1, arg2, arg3)
+        You can force auto-parentheses by using '/' as the first character
+        of a line.  For example:
+            >>> /globals             # becomes 'globals()'
+        Note that the '/' MUST be the first character on the line!  This
+        won't work:
+            >>> print /globals    # syntax error
+            
+        In most cases the automatic algorithm should work, so you should
+        rarely need to explicitly invoke /. One notable exception is if you
+        are trying to call a function with a list of tuples as arguments (the
+        parenthesis will confuse IPython):
+            In [1]: zip (1,2,3),(4,5,6)  # won't work
+        but this will work:
+            In [2]: /zip (1,2,3),(4,5,6)
+            ------> zip ((1,2,3),(4,5,6))
+            Out[2]= [(1, 4), (2, 5), (3, 6)]        
+
+        IPython tells you that it has altered your command line by
+        displaying the new command line preceded by -->.  e.g.:
+            In [18]: callable list
+            -------> callable (list) 
+
+    2. Auto-Quoting
+        You can force auto-quoting of a function's arguments by using ',' as
+        the first character of a line.  For example:
+            >>> ,my_function /home/me   # becomes my_function("/home/me")
+
+        If you use ';' instead, the whole argument is quoted as a single
+        string (while ',' splits on whitespace):
+            >>> ,my_function a b c   # becomes my_function("a","b","c")
+            >>> ;my_function a b c   # becomes my_function("a b c")
+
+        Note that the ',' MUST be the first character on the line!  This
+        won't work:
+            >>> x = ,my_function /home/me    # syntax error
+"""
+
+quick_reference = r"""
+IPython -- An enhanced Interactive Python - Quick Reference Card
+================================================================
+
+obj?, obj??      : Get help, or more help for object (also works as
+                   ?obj, ??obj).
+?foo.*abc*       : List names in 'foo' containing 'abc' in them.
+%magic           : Information about IPython's 'magic' % functions.
+
+Magic functions are prefixed by %, and typically take their arguments without
+parentheses, quotes or even commas for convenience.
+ 
+Example magic function calls:
+
+%alias d ls -F   : 'd' is now an alias for 'ls -F'
+alias d ls -F    : Works if 'alias' not a python name
+alist = %alias   : Get list of aliases to 'alist'
+cd /usr/share    : Obvious. cd -<tab> to choose from visited dirs.
+%cd??            : See help AND source for magic %cd
+
+System commands:
+    
+!cp a.txt b/     : System command escape, calls os.system()
+cp a.txt b/      : after %rehashx, most system commands work without !
+cp ${f}.txt $bar : Variable expansion in magics and system commands
+files = !ls /usr : Capture sytem command output
+files.s, files.l, files.n: "a b c", ['a','b','c'], 'a\nb\nc'
+
+History:
+
+_i, _ii, _iii    : Previous, next previous, next next previous input
+_i4, _ih[2:5]    : Input history line 4, lines 2-4
+exec _i81        : Execute input history line #81 again
+%rep 81          : Edit input history line #81        
+_, __, ___       : previous, next previous, next next previous output
+_dh              : Directory history
+_oh              : Output history
+%hist            : Command history. '%hist -g foo' search history for 'foo'
+
+Autocall:
+
+f 1,2            : f(1,2)
+/f 1,2           : f(1,2) (forced autoparen)
+,f 1 2           : f("1","2")
+;f 1 2           : f("1 2")
+
+Remember: TAB completion works in many contexts, not just file names
+or python names.
+
+The following magic functions are currently available:
+
+"""
+
+
diff --git a/IPython/wildcard.py b/IPython/wildcard.py
new file mode 100644
index 0000000..b92ab5f
--- /dev/null
+++ b/IPython/wildcard.py
@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+"""Support for wildcard pattern matching in object inspection.
+
+$Id: OInspect.py 608 2005-07-06 17:52:32Z fperez $
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2005 Jörgen Stenarson <jorgen.stenarson@bostream.nu>
+#
+#  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__  = "Jörgen Stenarson <jorgen.stenarson@bostream.nu>"
+__license__ = Release.license
+
+import __builtin__
+import exceptions
+import pdb
+import pprint
+import re
+import types
+
+from IPython.genutils import dir2
+
+def create_typestr2type_dicts(dont_include_in_type2type2str=["lambda"]):
+    """Return dictionaries mapping lower case typename to type objects, from
+    the types package, and vice versa."""
+    typenamelist=[]
+    for tname in dir(types):
+        if tname[-4:]=="Type":
+            typenamelist.append(tname)
+    typestr2type={}
+    type2typestr={}
+    for tname in typenamelist:
+        name=tname[:-4].lower()
+        obj=getattr(types,tname)
+        typestr2type[name]=getattr(types,tname)
+        if name in dont_include_in_type2type2str:
+            type2typestr[obj]=name
+    return typestr2type,type2typestr
+
+typestr2type,type2typestr=create_typestr2type_dicts()
+
+def is_type(obj,typestr_or_type):
+    """is_type(obj,typestr_or_type) verifies if obj is of a certain type or
+    group of types takes strings as parameters of the for 'tuple'<->TupleType
+    'all' matches all types.  TODO: Should be extended for choosing more than
+    one type
+    """
+    if typestr_or_type=="all":
+        return True
+    if type(typestr_or_type)==types.TypeType:
+        test_type=typestr_or_type
+    else:
+        test_type=typestr2type.get(typestr_or_type,False)
+    if test_type:
+        return isinstance(obj,test_type)
+    else:
+        return False
+
+def show_hidden(str,show_all=False):
+    """Return true for strings starting with single _ if show_all is true."""
+    return show_all or str.startswith("__") or not str.startswith("_")
+
+class NameSpace(object):
+    """NameSpace holds the dictionary for a namespace and implements filtering
+    on name and types"""
+    def __init__(self,obj,name_pattern="*",type_pattern="all",ignore_case=True,
+                 show_all=True):
+       self.show_all = show_all #Hide names beginning with single _
+       self.object = obj
+       self.name_pattern = name_pattern
+       self.type_pattern = type_pattern
+       self.ignore_case = ignore_case
+       
+       # We should only match EXACT dicts here, so DON'T use isinstance()
+       if type(obj) == types.DictType:
+           self._ns = obj
+       else:
+           kv = []
+           for key in dir2(obj):
+               if isinstance(key, basestring):
+                   # This seemingly unnecessary try/except is actually needed
+                   # because there is code out there with metaclasses that
+                   # create 'write only' attributes, where a getattr() call
+                   # will fail even if the attribute appears listed in the
+                   # object's dictionary.  Properties can actually do the same
+                   # thing.  In particular, Traits use this pattern
+                   try:
+                       kv.append((key,getattr(obj,key)))
+                   except AttributeError:
+                       pass
+           self._ns = dict(kv)
+               
+    def get_ns(self):
+        """Return name space dictionary with objects matching type and name patterns."""
+        return self.filter(self.name_pattern,self.type_pattern)
+    ns=property(get_ns)
+
+    def get_ns_names(self):
+        """Return list of object names in namespace that match the patterns."""
+        return self.ns.keys()
+    ns_names=property(get_ns_names,doc="List of objects in name space that "
+                      "match the type and name patterns.")
+        
+    def filter(self,name_pattern,type_pattern):
+        """Return dictionary of filtered namespace."""
+        def glob_filter(lista,name_pattern,hidehidden,ignore_case):
+            """Return list of elements in lista that match pattern."""
+            pattern=name_pattern.replace("*",".*").replace("?",".")
+            if ignore_case:
+                reg=re.compile(pattern+"$",re.I)
+            else:
+                reg=re.compile(pattern+"$")
+            result=[x for x in lista if reg.match(x) and show_hidden(x,hidehidden)]
+            return result
+        ns=self._ns
+        #Filter namespace by the name_pattern
+        all=[(x,ns[x]) for x in glob_filter(ns.keys(),name_pattern,
+                                            self.show_all,self.ignore_case)]
+        #Filter namespace by type_pattern
+        all=[(key,obj) for key,obj in all if is_type(obj,type_pattern)]
+        all=dict(all)
+        return all
+
+    #TODO: Implement dictionary like access to filtered name space?
+
+def list_namespace(namespace,type_pattern,filter,ignore_case=False,show_all=False):
+    """Return dictionary of all objects in namespace that matches type_pattern
+    and filter."""
+    pattern_list=filter.split(".")
+    if len(pattern_list)==1:
+        ns=NameSpace(namespace,name_pattern=pattern_list[0],type_pattern=type_pattern,
+                     ignore_case=ignore_case,show_all=show_all)
+        return ns.ns
+    else:
+        # This is where we can change if all objects should be searched or
+        # only modules. Just change the type_pattern to module to search only
+        # modules
+        ns=NameSpace(namespace,name_pattern=pattern_list[0],type_pattern="all",
+                     ignore_case=ignore_case,show_all=show_all)
+        res={}
+        nsdict=ns.ns
+        for name,obj in nsdict.iteritems():
+            ns=list_namespace(obj,type_pattern,".".join(pattern_list[1:]),
+                              ignore_case=ignore_case,show_all=show_all)
+            for inner_name,inner_obj in ns.iteritems():
+                res["%s.%s"%(name,inner_name)]=inner_obj
+        return res
diff --git a/IPython/winconsole.py b/IPython/winconsole.py
new file mode 100644
index 0000000..91cb26c
--- /dev/null
+++ b/IPython/winconsole.py
@@ -0,0 +1,46 @@
+"""Set of functions to work with console on Windows.
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2005 Alexander Belchenko <bialix@ukr.net>
+#
+#                This file is placed in the public domain.
+#
+#*****************************************************************************
+
+__author__  = 'Alexander Belchenko (e-mail: bialix AT ukr.net)'
+__license__ = 'Public domain'
+
+import struct
+
+try:
+    import ctypes
+except ImportError:
+    ctypes = None
+
+def get_console_size(defaultx=80, defaulty=25):
+    """ Return size of current console.
+
+    This function try to determine actual size of current working
+    console window and return tuple (sizex, sizey) if success,
+    or default size (defaultx, defaulty) otherwise.
+
+    Dependencies: ctypes should be installed.
+    """
+    if ctypes is None:
+        # no ctypes is found
+        return (defaultx, defaulty)
+
+    h = ctypes.windll.kernel32.GetStdHandle(-11)
+    csbi = ctypes.create_string_buffer(22)
+    res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
+    
+    if res:
+        (bufx, bufy, curx, cury, wattr,
+         left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh",
+                                                               csbi.raw)
+        sizex = right - left + 1
+        sizey = bottom - top + 1
+        return (sizex, sizey)
+    else:
+        return (defaultx, defaulty)
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 0000000..01b1313
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,30 @@
+include README_Windows.txt
+include win32_manual_post_install.py
+include ipython.py
+
+graft scripts
+
+graft setupext
+
+graft IPython/UserConfig
+
+graft doc
+exclude doc/*.1
+exclude doc/manual_base*
+exclude doc/ChangeLog.*
+exclude doc/\#*
+exclude doc/update_magic.sh
+exclude doc/update_version.sh
+exclude doc/manual_base*
+exclude doc/manual/WARNINGS
+exclude doc/manual/*.aux
+exclude doc/manual/*.log
+exclude doc/manual/*.out
+exclude doc/manual/*.pl
+exclude doc/manual/*.tex
+
+global-exclude *~
+global-exclude *.flc
+global-exclude *.pyc
+global-exclude .dircopy.log
+global-exclude .svn
diff --git a/README b/README
new file mode 100644
index 0000000..57ab77e
--- /dev/null
+++ b/README
@@ -0,0 +1,11 @@
+Please see the doc/ directory for full manuals and other documents. The manual is
+prepared using the LyX system (www.lyx.org), but in the doc/manual directory
+you'll find HTML and PDF versions.
+
+These manuals normally get installed to $PREFIX/share/doc/ipython-VERSION, unless you
+redirect the installer via a --prefix/--home option.  Normally, $PREFIX is
+/usr, but your Python may be installed elsewhere.  You can see its value by
+running:
+
+python -c "import sys;print sys.prefix"
+
diff --git a/README_Windows.txt b/README_Windows.txt
new file mode 100644
index 0000000..65965e3
--- /dev/null
+++ b/README_Windows.txt
@@ -0,0 +1,50 @@
+Notes for Windows Users
+=======================
+
+See http://ipython.scipy.org/moin/IpythonOnWindows for up-to-date information
+about running IPython on Windows.
+
+
+Requirements
+------------
+
+IPython runs under (as far as the Windows family is concerned):
+
+- Windows XP, 2000 (and probably WinNT): works well.  It needs:
+
+  * PyWin32: http://sourceforge.net/projects/pywin32/
+
+  * PyReadline: http://ipython.scipy.org/moin/PyReadline/Intro
+    
+  * If you are using Python2.4, this in turn requires Tomas Heller's ctypes
+    from: http://starship.python.net/crew/theller/ctypes (not needed for Python
+    2.5 users, since 2.5 already ships with ctypes).
+
+- Windows 95/98/ME: I have no idea. It should work, but I can't test.
+
+- CygWin environments should work, they are basically Posix.
+
+It needs Python 2.3 or newer.
+
+
+Installation
+------------
+
+Double-click the supplied .exe installer file. If all goes well, that's all
+you need to do. You should now have an IPython entry in your Start Menu.
+
+
+Installation from source distribution
+-------------------------------------
+
+In case the automatic installer does not work for some reason, you can
+download the ipython-XXX.tar.gz file, which contains the full IPython source
+distribution (the popular WinZip can read .tar.gz files). 
+
+After uncompressing the archive, you can install it at a command terminal just 
+like any other Python module, by using python setup.py install'. After this 
+completes, you can run the supplied win32_manual_post_install.py script which 
+will add the relevant shortcuts to your startup menu.
+
+Optionally, you may skip installation altogether and just launch "ipython.py" 
+from the root folder of the extracted source distribution.
diff --git a/debian/changelog b/debian/changelog
new file mode 100644
index 0000000..23fa75c
--- /dev/null
+++ b/debian/changelog
@@ -0,0 +1,70 @@
+ipython (0.6.4-1) unstable; urgency=low
+
+  * Fix dpatch dependency (Closes: #280505)
+
+ -- Fernando Perez <fperez@colorado.edu> Wed Nov 17 22:54:23 MST 2004
+
+ipython (0.6.3-1) unstable; urgency=low
+
+  * New upstream release (Closes: #262244, #252525)
+
+ -- Jack Moffitt <jack@xiph.org>  Wed, 22 Sep 2004 21:39:38 -0600
+
+ipython (0.6.0-1) unstable; urgency=low
+
+  * New upstream release
+
+ -- Jack Moffitt <jack@xiph.org>  Sun,  9 May 2004 17:38:00 +0200
+
+ipython (0.4.0-1.1) unstable; urgency=low
+
+  * Non maintainer upload with maintainer consensus.
+  * Updated buil-dep to depend on python-2.3 (Closes: #206653)
+  * Included encoding comment string in modules under IPython to 
+    avoid python2.3 Warnigs (upstream noticed).
+
+ -- Marco Presi (Zufus) <zufus@debian.org>  Mon, 25 Aug 2003 19:02:20 +0200
+
+ipython (0.4.0-1) unstable; urgency=low
+
+  * New upstream release (Closes #195215)
+  * Updated Build-Depends (Closes #200021)
+
+ -- Jack Moffitt <jack@xiph.org>  Fri, 25 Jul 2003 10:16:12 -0600
+
+ipython (0.2.15pre3-4) unstable; urgency=low
+
+  * Add python-dev Build-Depends (Closes: #189901)
+
+ -- Jack Moffitt <jack@babyjesus.cantcode.com>  Mon, 12 May 2003 23:33:43 -0600
+
+ipython (0.2.15pre3-3) unstable; urgency=low
+
+  * Fix for accidently converting home directory files' line ends
+    instead of just the appropriate ipython configuration files
+    (Closes: #189042)
+
+ -- Jack Moffitt <jack@xiph.org>  Mon, 14 Apr 2003 21:18:18 -0600
+
+ipython (0.2.15pre3-2) unstable; urgency=low
+
+  * Added text of the PSF license to debian/copyright.
+
+ -- Jack Moffitt <jack@xiph.org>  Sat,  5 Apr 2003 11:41:31 -0700
+
+ipython (0.2.15pre3-1) unstable; urgency=low
+
+  * Updated documentation to point to the new homepage -
+    http://ipython.scipy.org
+  * Removed doc/COPYING and doc/GNU-LGPL to fix lintian warnings
+  * Public release ready (Closes: #185789)
+
+ -- Jack Moffitt <jack@xiph.org>  Tue,  1 Apr 2003 20:53:31 -0700
+
+ipython (0.2.15pre3-0a) unstable; urgency=low
+
+  * Initial Release.
+  * This is my first Debian package
+
+ -- Jack Moffitt <jack@xiph.org>  Wed, 12 Mar 2003 21:04:22 -0700
+
diff --git a/debian/compat b/debian/compat
new file mode 100644
index 0000000..e0e1028
--- /dev/null
+++ b/debian/compat
@@ -0,0 +1 @@
+4
diff --git a/debian/control b/debian/control
new file mode 100644
index 0000000..fc2bd82
--- /dev/null
+++ b/debian/control
@@ -0,0 +1,21 @@
+Source: ipython
+Section: devel
+Priority: optional
+Maintainer: Jack Moffitt <jack@xiph.org>
+Build-Depends-Indep: debhelper (>> 4.1.65), dpatch, python-dev
+Standards-Version: 3.6.1
+
+Package: ipython
+Architecture: all
+Depends: ${python:Depends}
+Recommends: python-numeric, python-numeric-ext
+Description: An enhanced interactive Python shell
+ IPython is an enhanced interactive Python shell.  It can be used as a
+ replacement for the standard Python shell, or it can be used as a
+ complete working environment for scientific computing (like Matlab or
+ Mathematica) when paired with the standard Python scientific and
+ numerical tools.  It supports dynamic object introspections, numbered
+ input/output prompts, a macro system, session logging, session
+ restoring, complete system shell access, verbose and colored
+ traceback reports, auto-parentheses, auto-quoting, and is
+ embeddedable in other Python programs.
diff --git a/debian/copyright b/debian/copyright
new file mode 100644
index 0000000..b59b21a
--- /dev/null
+++ b/debian/copyright
@@ -0,0 +1,204 @@
+This package was debianized by Jack Moffitt <jack@xiph.org> on
+Wed, 12 Mar 2003 20:38:14 -0700.
+
+It was downloaded from http://ipython.scipy.org/
+
+Upstream Author: Fernando Perez <fperez@colorado.edu>,
+		 Janko Hauser <jhauser@zscout.de>,
+		 Nathaniel Gray <n8gray@caltech.edu>
+
+Copyright:
+
+Most IPython code is copyright (C) 2001-2004 by Fernando Perez, Janko Hauser,
+and Nathaniel Gray.  All code is licensed under a BSD-type License except as
+explicitly mentioned below.  The full IPython license is:
+
+IPython is released under a BSD-type license.
+
+Copyright (c) 2001, 2002, 2003, 2004 Fernando Perez <fperez@colorado.edu>.
+
+Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray
+<n8gray@caltech.edu>.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+  c. Neither the name of the copyright holders nor the names of any
+     contributors to this software may be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+
+DPyGetOpt.py is copyright (C) 2001 by Bill Bumgarner <bbum@friday.com>
+and is licensed under the MIT license, reproduced below:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+
+FlexCompleter.py is copyright (C) 2001 by the Python Software
+Foundation and licensed under the terms of the Python Software
+Foundation License, reproduced below:
+
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI) in the Netherlands as a successor of a
+language called ABC.  Guido is Python's principal author, although it
+includes many contributions from others.  The last version released
+from CWI was Python 1.2.  In 1995, Guido continued his work on Python
+at the Corporation for National Research Initiatives (CNRI) in Reston,
+Virginia where he released several versions of the software.  Python
+1.6 was the last of the versions released by CNRI.  In 2000, Guido and
+the Python core development team moved to BeOpen.com to form the
+BeOpen PythonLabs team.  Python 2.0 was the first and only release
+from BeOpen.com.
+
+Following the release of Python 1.6, and after Guido van Rossum left
+CNRI to work with commercial software developers, it became clear that
+the ability to use Python with software available under the GNU Public
+License (GPL) was very desirable.  CNRI and the Free Software
+Foundation (FSF) interacted to develop enabling wording changes to the
+Python license.  Python 1.6.1 is essentially the same as Python 1.6,
+with a few minor bug fixes, and with a different license that enables
+later versions to be GPL-compatible.  Python 2.1 is a derivative work
+of Python 1.6.1, as well as of Python 2.0.
+
+After Python 2.0 was released by BeOpen.com, Guido van Rossum and the
+other PythonLabs developers joined Digital Creations.  All
+intellectual property added from this point on, starting with Python
+2.1 and its alpha and beta releases, is owned by the Python Software
+Foundation (PSF), a non-profit modeled after the Apache Software
+Foundation.  See http://www.python.org/psf/ for more information about
+the PSF.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+PSF LICENSE AGREEMENT
+---------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using Python 2.1 software in source or binary form and its
+associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 2.1
+alone or in any derivative version, provided, however, that PSF's
+License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
+2001 Python Software Foundation; All Rights Reserved" are retained in
+Python 2.1 alone or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 2.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 2.1.
+
+4. PSF is making Python 2.1 available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+2.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A
+RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.1, OR
+ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI PERMISSIONS STATEMENT AND DISCLAIMER
+----------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Itpl.py is copyright (C) 2001 Ka-Ping Yee <ping@lfw.org> and licensed
+under the MIT license reproduced above.
diff --git a/debian/ipython.doc-base b/debian/ipython.doc-base
new file mode 100644
index 0000000..9c85f57
--- /dev/null
+++ b/debian/ipython.doc-base
@@ -0,0 +1,14 @@
+Document: ipython
+Title: IPython Manual
+Author: Fernando Perez <fperez@colorado.edu>
+Abstract: Full documentation on all features of IPython.
+Section: devel
+
+Format: pdf
+Files: /usr/share/doc/ipython/ipython.pdf
+
+Format: HTML
+Index: /usr/share/doc/ipython/manual/index.html
+Files: /usr/share/doc/ipython/manual/*.html
+
+  
diff --git a/debian/postinst b/debian/postinst
new file mode 100644
index 0000000..26ef964
--- /dev/null
+++ b/debian/postinst
@@ -0,0 +1,13 @@
+#!/bin/sh
+set -e
+
+OLD_MODDIR=/usr/lib/python2.2/site-packages/IPython
+
+if [ $1 = "configure" ]; then
+    if [ -d $OLD_MODDIR ];then
+	echo "Removing old python2.2 modules"
+	rm -fr $OLD_MODDIR >&2 
+    fi
+fi
+
+#DEBHELPER#
diff --git a/debian/rules b/debian/rules
new file mode 100644
index 0000000..743f297
--- /dev/null
+++ b/debian/rules
@@ -0,0 +1,98 @@
+#!/usr/bin/make -f
+# Sample debian/rules that uses debhelper.
+# GNU copyright 1997 to 1999 by Joey Hess.
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+
+
+
+CFLAGS = -Wall -g
+
+ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
+	CFLAGS += -O0
+else
+	CFLAGS += -O2
+endif
+ifeq (,$(findstring nostrip,$(DEB_BUILD_OPTIONS)))
+	INSTALL_PROGRAM += -s
+endif
+
+configure: configure-stamp
+configure-stamp:
+	dh_testdir
+
+	python setup.py config
+
+	touch configure-stamp
+
+
+build: build-stamp
+
+build-stamp: configure-stamp 
+	dh_testdir
+
+	python setup.py build
+
+	touch build-stamp
+
+clean:
+	dh_testdir
+	dh_testroot
+	rm -f build-stamp configure-stamp
+
+	-python setup.py clean --all
+	rm -f setupext/*.pyc
+
+	dh_clean
+
+install: build
+	dh_testdir
+	dh_testroot
+	dh_clean -k
+	dh_installdirs
+
+	python setup.py install --prefix $(CURDIR)/debian/ipython/usr
+
+	# remove extra license docs that get installed
+	rm -f $(CURDIR)/debian/ipython/usr/share/doc/ipython/COPYING
+	#rm -f $(CURDIR)/debian/ipython/usr/share/doc/ipython/GNU-LGPL
+
+	# change permission on scripts
+	chmod 755 $(CURDIR)/debian/ipython/usr/share/doc/ipython/examples/example-embed.py	
+	chmod 755 $(CURDIR)/debian/ipython/usr/share/doc/ipython/examples/example-gnuplot.py
+
+binary-indep: build install
+	dh_testdir
+	dh_testroot
+	dh_installchangelogs doc/ChangeLog
+	dh_installdocs
+#	dh_installexamples
+	dh_install
+#	dh_installmenu
+#	dh_installdebconf	
+#	dh_installlogrotate
+#	dh_installemacsen
+#	dh_installpam
+#	dh_installmime
+#	dh_installinit
+#	dh_installcron
+#	dh_installinfo
+	dh_installman doc/ipython.1.gz doc/pycolor.1.gz
+	dh_compress
+	dh_fixperms
+	dh_python
+#	dh_makeshlibs
+	dh_installdeb
+#	dh_shlibdeps
+	dh_gencontrol
+	dh_md5sums
+	dh_builddeb
+
+# Build architecture-dependent files here.
+binary-arch: build install
+# We have nothing to do by default.
+
+binary: binary-indep binary-arch
+.PHONY: build clean binary-indep binary-arch binary install configure
diff --git a/doc/COPYING b/doc/COPYING
new file mode 100644
index 0000000..932d849
--- /dev/null
+++ b/doc/COPYING
@@ -0,0 +1,52 @@
+IPython copyright and licensing notes
+=====================================
+
+Unless indicated otherwise, files in this project are covered by a BSD-type
+license, included below.
+
+Individual authors are the holders of the copyright for their code and are
+listed in each file.
+
+Some files (DPyGetOpt.py, for example) may be licensed under different
+conditions. Ultimately each file indicates clearly the conditions under which
+its author/authors have decided to publish the code.
+
+
+IPython license
+---------------
+
+IPython is released under a BSD-type license.
+
+Copyright (c) 2001, 2002, 2003, 2004 Fernando Perez <fperez@colorado.edu>.
+
+Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray
+<n8gray@caltech.edu>.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+  c. Neither the name of the copyright holders nor the names of any
+     contributors to this software may be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
diff --git a/doc/ChangeLog b/doc/ChangeLog
new file mode 100644
index 0000000..e8ebaf3
--- /dev/null
+++ b/doc/ChangeLog
@@ -0,0 +1,7433 @@
+2008-02-07  Darren Dale <darren.dale@cornell.edu>
+
+        * IPython/Shell.py: Call QtCore.pyqtRemoveInputHook() when creating
+        an IPShellQt4. PyQt4-4.2.1 and later uses PyOS_InputHook to improve 
+        interaction in the interpreter (like Tkinter does), but it seems to 
+        partially interfere with the IPython implementation and exec_()
+        still seems to block. So we disable the PyQt implementation and
+        stick with the IPython one for now.
+
+2008-02-02  Walter Doerwald  <walter@livinglogic.de>
+
+	* ipipe.py: A new ipipe table has been added: ialias produces all
+	entries from IPython's alias table.
+	
+2008-02-01  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Shell.py (MTInteractiveShell.runcode): Improve handling
+	of KBINT in threaded shells.  After code provided by Marc in #212.
+
+2008-01-30  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Shell.py (MTInteractiveShell.__init__): Fixed deadlock
+	that could occur due to a race condition in threaded shells.
+	Thanks to code provided by Marc, as #210.
+
+2008-01-29  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Magic.py (magic_doctest_mode): respect the user's
+	settings for input separators rather than overriding them.  After
+	a report by Jeff Kowalczyk <jtk-AT-yahoo.com>
+
+	* IPython/history.py (magic_history): Add support for declaring an
+	output file directly from the history command.
+
+2008-01-21  Walter Doerwald  <walter@livinglogic.de>
+
+	* ipipe.py: Register ipipe's displayhooks via the generic function
+	generics.result_display() instead of using ipapi.set_hook().
+	
+2008-01-19  Walter Doerwald  <walter@livinglogic.de>
+
+	* ibrowse.py, igrid.py, ipipe.py:
+	The input object can now be passed to the constructor of the display classes.
+	This makes it possible to use them with objects that implement __or__.
+	Use this constructor in the displayhook instead of piping.
+
+	* ipipe.py: Importing astyle.py is done as late as possible to
+	avoid problems with circular imports.
+	
+2008-01-19 Ville Vainio  <vivainio@gmail.com>
+
+	* hooks.py, iplib.py: Added 'shell_hook' to customize how
+	IPython calls shell.
+
+	* hooks.py, iplib.py: Added 'show_in_pager' hook to specify
+	how IPython pages text (%page, %pycat, %pdoc etc.)
+
+	* Extensions/jobctrl.py: Use shell_hook. New magics: '%tasks'
+	and '%kill' to kill hanging processes that won't obey ctrl+C.
+
+2008-01-16 Ville Vainio  <vivainio@gmail.com>
+
+	* ipy_completers.py: pyw extension support for %run completer.
+
+2008-01-11 Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py, ipmaker.py: new rc option - autoexec. It's a list 
+	of ipython commands to be run when IPython has started up
+	(just before running the scripts and -c arg on command line).
+	
+	* ipy_user_conf.py: Added an example on how to change term 
+	colors in config file (through using autoexec).
+
+	* completer.py, test_completer.py: Ability to specify custom
+	get_endidx to replace readline.get_endidx. For emacs users.
+	
+2008-01-10 Ville Vainio  <vivainio@gmail.com>
+
+	* Prompts.py (set_p_str): do not crash on illegal prompt strings
+
+2008-01-08 Ville Vainio  <vivainio@gmail.com>
+
+	* '%macro -r' (raw mode) is now default in sh profile.
+
+2007-12-31  Ville Vainio  <vivainio@gmail.com>
+
+	* completer.py: custom completer matching is now case sensitive
+	(#207).
+	
+	* ultraTB.py, iplib.py: Add some KeyboardInterrupt catching in
+	an attempt to prevent occasional crashes.
+	
+	* CrashHandler.py: Crash log dump now asks user to press enter
+	before exiting.
+	
+	* Store _ip in user_ns instead of __builtin__, enabling safer
+	coexistence of multiple IPython instances in the same python
+	interpreter (#197).
+	
+	* Debugger.py, ipmaker.py: Need to add '-pydb' command line
+	switch to enable pydb in post-mortem debugging and %run -d.
+
+2007-12-28  Ville Vainio  <vivainio@gmail.com>
+
+	* ipy_server.py: TCP socket server for "remote control" of an IPython 
+	instance.
+	
+	* Debugger.py: Change to PSF license
+	
+	* simplegeneric.py: Add license & author notes.
+	
+	* ipy_fsops.py: Added PathObj and FileObj, an object-oriented way 
+	to navigate file system with a custom completer. Run 
+	ipy_fsops.test_pathobj() to play with it.
+
+2007-12-28  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/dtutils.py: Add utilities for interactively running
+	doctests.  Still needs work to more easily handle the namespace of
+	the package one may be working on, but the basics are in place.
+
+2007-12-27  Ville Vainio  <vivainio@gmail.com>
+
+	* ipy_completers.py: Applied arno's patch to get proper list of 
+	packages in import completer. Closes #196.
+
+2007-12-20  Ville Vainio  <vivainio@gmail.com>
+
+	* completer.py, generics.py(complete_object): Allow 
+	custom complers based on python objects via simplegeneric.
+	See generics.py / my_demo_complete_object
+
+2007-12-13  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Prompts.py (BasePrompt.__nonzero__): add proper boolean
+	behavior to prompt objects, useful for display hooks to adjust
+	themselves depending on whether prompts will be there or not.
+
+2007-12-13  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py(raw_input): unix readline does not allow unicode in
+	history, encode to normal string. After patch by Tiago.
+	Close #201
+
+2007-12-12  Ville Vainio  <vivainio@gmail.com>
+
+	* genutils.py (abbrev_cwd): Terminal title now shows 2 levels of 
+	current directory.
+	
+2007-12-12  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Shell.py (_select_shell): add support for controlling
+	the pylab threading mode directly at the command line, without
+	having to modify MPL config files.  Added unit tests for this
+	feature, though manual/docs update is still pending, will do later.
+
+2007-12-11  Ville Vainio  <vivainio@gmail.com>
+
+	* ext_rescapture.py: var = !cmd is no longer verbose (to facilitate
+	use in scripts)
+
+2007-12-07  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py, ipy_profile_sh.py: Do not escape # on command lines 
+	anymore (to \#) - even if it is a comment char that is implicitly 
+	escaped in some unix shells in interactive mode, it is ok to leave
+	it in IPython as such.
+
+
+2007-12-01  Robert Kern  <robert.kern@gmail.com>
+
+	* IPython/ultraTB.py (findsource): Improve the monkeypatch to
+	inspect.findsource(). It can now find source lines inside zipped
+	packages.
+	
+	* IPython/ultraTB.py: When constructing tracebacks, try to use __file__
+	in the frame's namespace before trusting the filename in the code object
+	which created the frame.
+
+2007-11-29  *** Released version 0.8.2
+
+2007-11-25  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Logger.py (Logger.logstop): add a proper logstop()
+	method to fully stop the logger, along with a corresponding
+	%logstop magic for interactive use.
+
+	* IPython/Extensions/ipy_host_completers.py: added new host
+	completers functionality, contributed by Gael Pasgrimaud
+	<gawel-AT-afpy.org>.
+
+2007-11-24  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/DPyGetOpt.py (ArgumentError): Apply patch by Paul Mueller
+	<gakusei-AT-dakotacom.net>, to fix deprecated string exceptions in
+	options handling.  Unicode fix in %whos (committed a while ago)
+	was also contributed by Paul.
+
+2007-11-23  Darren Dale <darren.dale@cornell.edu>
+        * ipy_traits_completer.py: let traits_completer respect the user's
+        readline_omit__names setting.
+
+2007-11-08  Ville Vainio  <vivainio@gmail.com>
+
+	* ipy_completers.py (import completer): assume 'xml' module exists.
+	Do not add every module twice anymore. Closes #196.
+
+	* ipy_completers.py, ipy_app_completers.py: Add proper apt-get
+	completer that uses apt-cache to search for existing packages.
+
+2007-11-06  Ville Vainio  <vivainio@gmail.com>
+
+	* Prompts.py: Do not update _oh and _123 when do_full_cache is not
+	true. Closes #194.
+
+2007-11-01  Brian Granger <ellisonbg@gmail.com>
+
+	* iplib.py, rlineimpl.py: Applied Body Water's patches to get IPython
+	working with OS X 10.5 libedit implementation of readline.
+
+2007-10-24  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py(user_setup): To route around buggy installations where
+	UserConfig is not available, create a minimal _ipython.
+
+	* iplib.py: Unicode fixes from Jorgen.
+
+	* genutils.py: Slist now has new method 'fields()' for extraction of
+	whitespace-separated fields from line-oriented data.
+
+2007-10-15  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/OInspect.py (Inspector.pinfo): fix bug that could arise
+	when querying objects with no __class__ attribute (such as
+	f2py-generated modules).
+
+2007-10-09  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Magic.py (magic_time): track compilation time and report
+	it if longer than 0.1s (fix done to %time and %timeit).  After a
+	SAGE bug report: http://trac.sagemath.org/sage_trac/ticket/632.
+
+2007-09-18  Ville Vainio  <vivainio@gmail.com>
+
+	* genutils.py(make_quoted_expr): Do not use Itpl, it does
+        not support unicode at the moment. Fixes (many) magic calls with
+        special characters.
+
+2007-09-14  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/genutils.py (doctest_reload): expose the doctest
+	reloader to the user so that people can easily reset doctest while
+	using it interactively.  Fixes a problem reported by Jorgen.
+
+	* IPython/iplib.py (InteractiveShell.__init__): protect the
+	FakeModule instances used for __main__ in %run calls from
+	deletion, so that user code defined in them isn't left with
+	dangling references due to the Python module deletion machinery.
+	This should fix the problems reported by Darren.
+
+2007-09-10  Darren Dale  <dd55@cornell.edu>
+
+        * Cleanup of IPShellQt and IPShellQt4
+
+2007-09-09  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/FakeModule.py (FakeModule.__init__): further fixes for
+	doctest support.  
+
+	* IPython/iplib.py (safe_execfile): minor docstring improvements.
+
+2007-09-08  Ville Vainio  <vivainio@gmail.com>
+
+	* Magic.py (%pushd, %popd, %dirs): Fix dir stack - push *current*
+	directory, not the target directory.
+
+	* ipapi.py, Magic.py, iplib.py: Add ipapi.UsageError, a lighter weight
+	exception that won't print the tracebacks. Switched many magics to
+	raise them on error situations, also GetoptError is not printed
+	anymore.
+
+2007-09-07  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py: do not auto-alias "dir", it screws up other dir auto
+        aliases.
+
+	* genutils.py: SList.grep() implemented.
+        
+	* ipy_editors.py, UserConfig/ipy_user_conf.py: Add some editors
+	for easy "out of the box" setup of several common editors, so that
+	e.g. '%edit os.path.isfile' will jump to the correct line
+	automatically. Contributions for command lines of your favourite
+	editors welcome.
+        
+2007-09-07  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/OInspect.py (Inspector.pinfo): fixed bug that was
+	preventing source display in certain cases.  In reality I think
+	the problem is with Ubuntu's Python build, but this change works
+	around the issue in some cases (not in all, unfortunately).  I'd
+	filed a Python bug on this with more details, but in the change of
+	bug trackers it seems to have been lost.
+
+	* IPython/Magic.py (magic_dhist): restore %dhist. No, cd -TAB is
+	not the same, it's not self-documenting, doesn't allow range
+	selection, and sorts alphabetically instead of numerically.
+	(magic_r): restore %r.  No, "up + enter. One char magic" is not
+	the same thing, since %r takes parameters to allow fast retrieval
+	of old commands.  I've received emails from users who use this a
+	LOT, so it stays.
+	(magic_automagic): restore %automagic.  "use _ip.option.automagic"
+	is not a valid replacement b/c it doesn't provide an complete
+	explanation (which the automagic docstring does).
+	(magic_autocall): restore %autocall, with improved docstring.
+	Same argument as for others, "use _ip.options.autocall" is not a
+	valid replacement.
+	(magic_pdef): restore %pdef & friends.  Used widely, mentioned in
+	tutorials and online docs.
+
+2007-09-06  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/usage.py (quick_reference): mention magics in quickref,
+	modified main banner to mention %quickref.
+
+	* IPython/FakeModule.py (FakeModule): fixes for doctest compatibility.
+
+2007-09-06  Ville Vainio  <vivainio@gmail.com>
+
+	* ipy_rehashdir.py, ipy_workdir.py, ipy_fsops.py, iplib.py:
+	Callable aliases now pass the _ip as first arg. This breaks 
+	compatibility with earlier 0.8.2.svn series! (though they should
+	not have been in use yet outside these few extensions)
+
+2007-09-05  Ville Vainio  <vivainio@gmail.com>
+
+	* external/mglob.py: expand('dirname') => ['dirname'], instead
+	of ['dirname/foo','dirname/bar', ...].
+        
+	* Extensions/ipy_fsops.py: added, has usefull shell utils for plain
+	win32 installations: icp, imv, imkdir, igrep, irm, collect (collect
+	is useful for others as well).
+
+	* iplib.py: on callable aliases (as opposed to old style aliases),
+	do var_expand() immediately, and use make_quoted_expr instead
+	of hardcoded r"""
+
+	* Extensions/ipy_profile_sh.py: Try to detect cygwin on win32,
+	if not available load ipy_fsops.py for cp, mv, etc. replacements
+
+	* OInspect.py, ipy_which.py: improve %which and obj? for callable
+	aliases
+        
+2007-09-04  Ville Vainio  <vivainio@gmail.com>
+
+	* ipy_profile_zope.py: add zope profile, by Stefan Eletzhofer.
+	Relicensed under BSD with the authors approval.
+        
+	* ipmaker.py, usage.py: Remove %magic from default banner, improve
+	%quickref        
+
+2007-09-03  Ville Vainio  <vivainio@gmail.com>
+
+	* Magic.py: %time now passes expression through prefilter,
+	allowing IPython syntax.
+
+2007-09-01  Ville Vainio  <vivainio@gmail.com>
+
+	* ipmaker.py: Always show full traceback when newstyle config fails
+
+2007-08-27  Ville Vainio  <vivainio@gmail.com>
+
+	* Magic.py: fix %cd for nonexistent dir when dhist is empty, close #180
+
+2007-08-26  Ville Vainio  <vivainio@gmail.com>
+
+	* ipmaker.py: Command line args have the highest priority again
+	
+	* iplib.py, ipmaker.py: -i command line argument now behaves as in
+	normal python, i.e. leaves the IPython session running after -c
+	command or running a batch file from command line.
+    
+2007-08-22  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py: no extra empty (last) line in raw hist w/ multiline
+	statements
+	
+	* logger.py: Fix bug where blank lines in history were not
+	added until AFTER adding the current line; translated and raw
+	history should finally be in sync with prompt now.
+	
+	* ipy_completers.py: quick_completer now makes it easy to create
+	trivial custom completers
+	
+	* clearcmd.py: shadow history compression & erasing, fixed input hist
+	clearing.
+	
+	* envpersist.py, history.py: %env (sh profile only), %hist completers
+	
+	* genutils.py, Prompts.py, Magic.py: win32 - prompt (with \yDEPTH) and
+	term title now include the drive letter, and always use / instead of
+	os.sep (as per recommended approach for win32 ipython in general).
+	
+	* ipykit.py, ipy_kitcfg.py: special launcher for ipykit. Allows running
+	plain python scripts from ipykit command line by running
+	"py myscript.py", even w/o installed python.
+
+2007-08-21  Ville Vainio  <vivainio@gmail.com>
+
+	* ipmaker.py: finding ipythonrc-PROF now skips ipy_profile_PROF.
+	(for backwards compatibility)
+	
+	* history.py: switch back to %hist -t from %hist -r as default.
+	At least until raw history is fixed for good.
+
+2007-08-20  Ville Vainio  <vivainio@gmail.com>
+
+	* ipapi.py, iplib.py: DebugTools accessible via _ip.dbg, to catch &
+	locate alias redeclarations etc. Also, avoid handling
+	_ip.IP.alias_table directly, prefer using _ip.defalias.
+	
+
+2007-08-15  Ville Vainio  <vivainio@gmail.com>
+
+	* prefilter.py: ! is now always served first
+
+2007-08-15  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (safe_execfile): fix the SystemExit
+	auto-suppression code to work in Python2.4 (the internal structure
+	of that exception changed and I'd only tested the code with 2.5).
+	Bug reported by a SciPy attendee.
+
+2007-08-13  Ville Vainio  <vivainio@gmail.com>
+
+	* prefilter.py: reverted !c:/bin/foo fix, made % in
+        multiline specials work again
+
+2007-08-13  Ville Vainio  <vivainio@gmail.com>
+
+	* prefilter.py: Take more care to special-case !, so that
+        !c:/bin/foo.exe works.
+        
+        * setup.py: if we are building eggs, strip all docs and
+        examples (it doesn't make sense to bytecompile examples,
+        and docs would be in an awkward place anyway).
+        
+        * Ryan Krauss' patch fixes start menu shortcuts when IPython
+        is installed into a directory that has spaces in the name.
+
+2007-08-13  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Magic.py (magic_doctest_mode): fix prompt separators in
+	doctest profile and %doctest_mode, so they actually generate the
+	blank lines needed by doctest to separate individual tests.
+
+	* IPython/iplib.py (safe_execfile): modify so that running code
+	which calls sys.exit(0) (or equivalently, raise SystemExit(0))
+	doesn't get a printed traceback.  Any other value in sys.exit(),
+	including the empty call, still generates a traceback.  This
+	enables use of %run without having to pass '-e' for codes that
+	correctly set the exit status flag.
+
+2007-08-12  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (InteractiveShell.post_config_initialization):
+	fix problems with doctests failing when run inside IPython due to
+	IPython's modifications of sys.displayhook.
+
+2007-8-9  Fernando Perez  <fperez@planck.colorado.edu>
+
+        * IPython/ipapi.py (to_user_ns): update to accept a dict as well as
+          a string with names.
+
+2007-08-09  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Magic.py (magic_doctest_mode): added new %doctest_mode
+	magic to toggle on/off the doctest pasting support without having
+	to leave a session to switch to a separate profile.
+
+2007-08-08  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Extensions/ipy_profile_doctest.py (main): fix prompt to
+	introduce a blank line between inputs, to conform to doctest
+	requirements.
+
+	* IPython/OInspect.py (Inspector.pinfo): fix another part where
+	auto-generated docstrings for new-style classes were showing up.
+
+2007-08-07  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* api_changes: Add new file to track backward-incompatible
+	user-visible changes.
+
+2007-08-06  Ville Vainio  <vivainio@gmail.com>
+
+	* ipmaker.py: fix bug where user_config_ns didn't exist at all
+	before all the config files were handled.
+
+2007-08-04  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/irunner.py (RunnerFactory): Add new factory class for
+	creating reusable runners based on filenames.
+
+	* IPython/Extensions/ipy_profile_doctest.py: New profile for
+	doctest support.  It sets prompts/exceptions as similar to
+	standard Python as possible, so that ipython sessions in this
+	profile can be easily pasted as doctests with minimal
+	modifications.  It also enables pasting of doctests from external
+	sources (even if they have leading whitespace), so that you can
+	rerun doctests from existing sources.
+
+	* IPython/iplib.py (_prefilter): fix a buglet where after entering
+	some whitespace, the prompt would become a continuation prompt
+	with no way of exiting it other than Ctrl-C.  This fix brings us
+	into conformity with how the default python prompt works.
+
+	* IPython/Extensions/InterpreterPasteInput.py (prefilter_paste):
+	Add support for pasting not only lines that start with '>>>', but
+	also with ' >>>'.  That is, arbitrary whitespace can now precede
+	the prompts.  This makes the system useful for pasting doctests
+	from docstrings back into a normal session.
+
+2007-08-02  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Shell.py (IPShellEmbed.__call__): fix bug introduced in
+	r1357, which had killed multiple invocations of an embedded
+	ipython (this means that example-embed has been broken for over 1
+	year!!!).  Rather than possibly breaking the batch stuff for which
+	the code in iplib.py/interact was introduced, I worked around the
+	problem in the embedding class in Shell.py.  We really need a
+	bloody test suite for this code, I'm sick of finding stuff that
+	used to work breaking left and right every time I use an old
+	feature I hadn't touched in a few months.
+	(kill_embedded): Add a new magic that only shows up in embedded
+	mode, to allow users to permanently deactivate an embedded instance.
+
+2007-08-01  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py, ipy_profile_sh.py (runlines): Fix the bug where raw
+        history gets out of sync on runlines (e.g. when running macros).
+
+2007-07-31  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Magic.py (magic_colors): fix win32-related error message
+	that could appear under *nix when readline was missing.  Patch by
+	Scott Jackson, closes #175.
+
+2007-07-29  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Extensions/ipy_traits_completer.py: Add a new custom
+	completer that it traits-aware, so that traits objects don't show
+	all of their internal attributes all the time.
+
+	* IPython/genutils.py (dir2): moved this code from inside
+	completer.py to expose it publicly, so I could use it in the
+	wildcards bugfix.
+
+	* IPython/wildcard.py (NameSpace.__init__): fix a bug reported by
+	Stefan with Traits.
+
+	* IPython/completer.py (Completer.attr_matches): change internal
+	var name from 'object' to 'obj', since 'object' is now a builtin
+	and this can lead to weird bugs if reusing this code elsewhere.
+
+2007-07-25  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/OInspect.py (Inspector.pinfo): fix small glitches in
+	'foo?' and update the code to prevent printing of default
+	docstrings that started appearing after I added support for
+	new-style classes.  The approach I'm using isn't ideal (I just
+	special-case those strings) but I'm not sure how to more robustly
+	differentiate between truly user-written strings and Python's
+	automatic ones.
+
+2007-07-09  Ville Vainio  <vivainio@gmail.com>
+
+	* completer.py: Applied Matthew Neeley's patch:
+        Dynamic attributes from trait_names and _getAttributeNames are added
+        to the list of tab completions, but when this happens, the attribute
+        list is turned into a set, so the attributes are unordered when
+        printed, which makes it hard to find the right completion. This patch
+        turns this set back into a list and sort it.
+
+2007-07-06  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/OInspect.py (Inspector.pinfo): Add support for new-style
+	classes in various inspector functions.
+
+2007-06-28  Ville Vainio  <vivainio@gmail.com>
+
+	* shadowns.py, iplib.py, ipapi.py, OInspect.py:
+        Implement "shadow" namespace, and callable aliases that reside there.
+        Use them by:
+        
+        _ip.defalias('foo',myfunc) # creates _sh.foo that points to myfunc
+        
+        foo hello world
+         (gets translated to:)
+        _sh.foo(r"""hello world""")
+
+        In practice, this kind of alias can take the role of a magic function        
+
+        * New generic inspect_object, called on obj? and obj??
+
+2007-06-15  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/ultraTB.py (findsource): fix a problem with
+	inspect.getfile that can cause crashes during traceback construction.
+
+2007-06-14  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py (handle_auto): Try to use ascii for printing "--->"
+        autocall rewrite indication, becausesometimes unicode fails to print
+        properly (and you get ' - - - '). Use plain uncoloured ---> for
+        unicode.
+        
+        * shadow history. Usable through "%hist -g <pat>" and "%rep 0123".
+        
+        . pickleshare 'hash' commands (hget, hset, hcompress,
+        hdict) for efficient shadow history storage.
+
+2007-06-13  Ville Vainio  <vivainio@gmail.com>
+
+	* ipapi.py: _ip.to_user_ns(vars, interactive = True).
+        Added kw arg 'interactive', tell whether vars should be visible
+        with %whos.
+
+2007-06-11  Ville Vainio  <vivainio@gmail.com>
+
+	* pspersistence.py, Magic.py, iplib.py: directory history now saved 
+	to db
+    
+	* iplib.py: "ipython -c <cmd>" now passes the command through prefilter.
+	Also, it exits IPython immediately after evaluating the command (just like 
+	std python)
+
+2007-06-05  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py: Added a new table icap, which executes a
+	Python string and captures the output. (Idea and original patch by
+	Stefan van der Walt)
+
+2007-06-01  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/ultraTB.py (VerboseTB.text): update printing of
+	exception types for Python 2.5 (now all exceptions in the stdlib
+	are new-style classes).
+
+2007-05-31  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/igrid.py: Add new commands refresh and
+	refresh_timer (mapped to "R"/"F5" and to the menu) which restarts
+	the iterator once (refresh) or after every x seconds (refresh_timer).
+	Add a working implementation of "searchexpression", where the text
+	entered is not the text to search for, but an expression that must
+	be true. Added display of shortcuts to the menu. Added commands "pickinput"
+	and "pickinputattr" that put the object or attribute under the cursor
+	in the input line. Split the statusbar to be able to display the currently
+	active refresh interval. (Patch by Nik Tautenhahn)
+
+2007-05-29  Jorgen Stenarson  <jorgen.stenarson@bostream.nu>
+	
+	* fixing set_term_title to use ctypes as default
+
+	* fixing set_term_title fallback to work when curent dir 
+	  is on a windows network share
+
+2007-05-28  Ville Vainio  <vivainio@gmail.com>
+
+	* %cpaste: strip + with > from left (diffs).
+        
+        * iplib.py: Fix crash when readline not installed
+
+2007-05-26  Ville Vainio  <vivainio@gmail.com>
+
+	* generics.py: introduce easy to extend result_display generic
+        function (using simplegeneric.py).
+        
+        * Fixed the append functionality of %set.
+
+2007-05-25  Ville Vainio  <vivainio@gmail.com>
+
+	* New magic: %rep (fetch / run old commands from history)
+        
+        * New extension: mglob (%mglob magic), for powerful glob / find /filter
+        like functionality
+        
+        % maghistory.py: %hist -g PATTERM greps the history for pattern
+
+2007-05-24  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py: Added a Table ihist that can be used to
+	browse the IPython input history
+
+	* IPython/Extensions/ibrowse.py: Added two command to ibrowse: pickinput
+	(mapped to "i") can be used to put the object under the curser in the input
+	line. pickinputattr (mapped to "I") does the same for the attribute under
+	the cursor.
+
+2007-05-24  Ville Vainio  <vivainio@gmail.com>
+
+	* Grand magic cleansing (changeset [2380]):
+        
+        * Introduce ipy_legacy.py where the following magics were
+        moved:
+        
+        pdef pdoc psource pfile rehash dhist Quit p r automagic autocall
+        
+        If you need them, either use default profile or "import ipy_legacy"
+        in your ipy_user_conf.py
+        
+        * Move sh and scipy profile to Extensions from UserConfig. this implies
+        you should not edit them, but you don't need to run %upgrade when
+        upgrading IPython anymore.
+        
+        * %hist/%history now operates in "raw" mode by default. To get the old
+        behaviour, run '%hist -n' (native mode).
+        
+        * split ipy_stock_completers.py to ipy_stock_completers.py and
+        ipy_app_completers.py. Stock completers (%cd, import, %run) are now
+        installed as default.
+        
+        * sh profile now installs ipy_signals.py, for (hopefully) better ctrl+c
+        handling.
+        
+        * iplib.py, ipapi.py: _ip.set_next_input(s) sets the next ("default")
+        input if readline is available.
+	
+2007-05-23  Ville Vainio  <vivainio@gmail.com>
+
+	* macro.py: %store uses __getstate__ properly
+	
+	* exesetup.py: added new setup script for creating
+	standalone IPython executables with py2exe (i.e.
+	no python installation required).
+	
+	* Removed ipythonrc-scipy, ipy_profile_scipy.py takes
+	its place.
+        
+        * rlineimpl.py, genutils.py (get_home_dir): py2exe support
+	
+2007-05-21  Ville Vainio  <vivainio@gmail.com>
+
+	* platutil_win32.py (set_term_title): handle
+	failure of 'title' system call properly.
+
+2007-05-17  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py: Fix xrepr for ifiles.
+	(Bug detected by Paul Mueller).
+
+2007-05-16  Ville Vainio  <vivainio@gmail.com>
+
+	* ipy_profile_sci.py, ipython_win_post_install.py: Create
+	new "sci" profile, effectively a modern version of the old
+	"scipy" profile (which is now slated for deprecation).
+
+2007-05-15  Ville Vainio  <vivainio@gmail.com>
+
+	* pycolorize.py, pycolor.1: Paul Mueller's patches that
+	make pycolorize read input from stdin when run without arguments.
+	
+	* Magic.py: do not require 'PATH' in %rehash/%rehashx. Closes #155
+	
+	* ipy_rehashdir.py: rename ext_rehashdir to ipy_rehashdir, import
+	it in sh profile (instead of ipy_system_conf.py).
+
+	* Magic.py, ipy_rehashdir.py, ipy_profile_sh.py: System command
+	aliases are now lower case on windows (MyCommand.exe => mycommand).
+	
+	* macro.py, ipapi.py, iplib.py, Prompts.py: Macro system rehaul.
+	Macros are now callable objects that inherit from ipapi.IPyAutocall,
+	i.e. get autocalled regardless of system autocall setting.
+
+2007-05-10  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/rlineimpl.py: check for clear_history in readline and
+	make it a dummy no-op if not available.  This function isn't
+	guaranteed to be in the API and appeared in Python 2.4, so we need
+	to check it ourselves.  Also, clean up this file quite a bit.
+
+	* ipython.1: update man page and full manual with information
+	about threads (remove outdated warning).  Closes #151.
+
+2007-05-09  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Extensions/ipy_constants.py: Add Gael's constants module
+	in trunk (note that this made it into the 0.8.1 release already,
+	but the changelogs didn't get coordinated).  Many thanks to Gael
+	Varoquaux <gael.varoquaux-AT-normalesup.org>
+
+2007-05-09  *** Released version 0.8.1
+
+2007-05-10  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/igrid.py: Incorporate html help into
+	the module, so we don't have to search for the file.
+
+2007-05-02  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* test/test_irunner.py (RunnerTestCase._test_runner): Close #147.
+
+2007-04-30  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py: (pre_config_initialization) Catch UnicodeDecodeError if the
+	user has illegal (non-ascii) home directory name
+
+2007-04-27  Ville Vainio  <vivainio@gmail.com>
+
+	* platutils_win32.py: implement set_term_title for windows
+	
+	* Update version number
+	
+	* ipy_profile_sh.py: more informative prompt (2 dir levels)
+
+2007-04-26  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/igrid.py: (igrid) Fix bug that surfaced
+	when the igrid input raised an exception. (Patch by Nik Tautenhahn,
+	bug discovered by Ville).
+
+2007-04-26  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/ipy_completers.py: Olivier's module completer now
+	saves the list of root modules if it takes > 4 secs on the first run.
+	
+	* Magic.py (%rehashx): %rehashx now clears the completer cache
+	
+
+2007-04-26  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* ipython.el: fix incorrect color scheme, reported by Stefan.
+	Closes #149.
+
+	* IPython/PyColorize.py (Parser.format2): fix state-handling
+	logic.  I still don't like how that code handles state, but at
+	least now it should be correct, if inelegant.  Closes #146.
+
+2007-04-25  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/ipy_which.py: added extension for %which magic, works
+	a lot like unix 'which' but also finds and expands aliases, and
+	allows wildcards.
+
+	* ipapi.py (expand_alias): Now actually *return* the expanded alias,
+	as opposed to returning nothing.
+	
+	* UserConfig/ipy_user_conf.py, ipy_profile_sh.py: do not import
+	ipy_stock_completers on default profile, do import on sh profile.
+
+2007-04-22  Jorgen Stenarson  <jorgen.stenarson@bostream.nu>
+
+	* Fix bug in iplib.py/safe_execfile when launching ipython with a script
+	like ipython.py foo.py which raised a IndexError.
+
+2007-04-21  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/ipy_extutil.py: added extension to manage other ipython
+	extensions. Now only supports 'ls' == list extensions.
+
+2007-04-20  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Debugger.py (BdbQuit_excepthook): fix small bug that
+	would prevent use of the exception system outside of a running
+	IPython instance.
+
+2007-04-20  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/ipy_render.py: added extension for easy
+	interactive text template rendering (to clipboard). Uses Ka-Ping Yee's
+	'Iptl' template notation, 
+	
+	* Extensions/ipy_completers.py: introduced Olivier Lauzanne's
+	safer & faster 'import' completer.
+	
+	* ipapi.py: Introduced new ipapi methods, _ip.defmacro(name, value)
+	and _ip.defalias(name, command).
+	
+	* Extensions/ipy_exportdb.py: New extension for exporting all the
+	%store'd data in a portable format (normal ipapi calls like
+	defmacro() etc.)
+	
+2007-04-19  Ville Vainio  <vivainio@gmail.com>
+
+	* upgrade_dir.py: skip junk files like *.pyc
+	
+	* Release.py: version number to 0.8.1
+
+2007-04-18  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py (safe_execfile): make "ipython foo.py" work with 2.5.1c1
+	and later on win32.
+
+2007-04-16  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py (showtraceback): Do not crash when running w/o readline.
+
+2007-04-12  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py: (ils) Directoy listings are now
+	sorted (case sensitive with files and dirs mixed).
+
+2007-04-10  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Release.py (version): Open trunk for 0.8.1 development.
+
+2007-04-10  *** Released version 0.8.0
+
+2007-04-07  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* Tag 0.8.0 for release.
+	
+	* IPython/iplib.py (reloadhist): add API function to cleanly
+	reload the readline history, which was growing inappropriately on
+	every %run call.
+
+	* win32_manual_post_install.py (run): apply last part of Nicolas
+	Pernetty's patch (I'd accidentally applied it in a different
+	directory and this particular file didn't get patched).
+
+2007-04-05  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Shell.py (MAIN_THREAD_ID): get rid of my stupid hack to
+	find the main thread id and use the proper API call.  Thanks to
+	Stefan for the fix.
+
+	* test/test_prefilter.py (esc_handler_tests): udpate one of Dan's
+	unit tests to reflect fixed ticket #52, and add more tests sent by
+	him.
+
+	* IPython/iplib.py (raw_input): restore the readline completer
+	state on every input, in case third-party code messed it up.
+	(_prefilter): revert recent addition of early-escape checks which
+	prevent many valid alias calls from working.
+
+	* IPython/Shell.py (MTInteractiveShell.runcode): add a tracking
+	flag for sigint handler so we don't run a full signal() call on
+	each runcode access.
+
+	* IPython/Magic.py (magic_whos): small improvement to diagnostic
+	message.
+
+2007-04-04  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Shell.py (sigint_handler): I *THINK* I finally got
+	asynchronous exceptions working, i.e., Ctrl-C can actually
+	interrupt long-running code in the multithreaded shells.
+
+	This is using Tomer Filiba's great ctypes-based trick:
+	http://sebulba.wikispaces.com/recipe+thread2.  I'd already tried
+	this in the past, but hadn't been able to make it work before.  So
+	far it looks like it's actually running, but this needs more
+	testing.  If it really works, I'll be *very* happy, and we'll owe
+	a huge thank you to Tomer.  My current implementation is ugly,
+	hackish and uses nasty globals, but I don't want to try and clean
+	anything up until we know if it actually works.
+
+	NOTE: this feature needs ctypes to work.  ctypes is included in
+	Python2.5, but 2.4 users will need to manually install it.  This
+	feature makes multi-threaded shells so much more usable that it's
+	a minor price to pay (ctypes is very easy to install, already a
+	requirement for win32 and available in major linux distros).
+
+2007-04-04  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/ipy_completers.py, ipy_stock_completers.py:
+	Moved implementations of 'bundled' completers to ipy_completers.py,
+	they are only enabled in ipy_stock_completers.py.
+
+2007-04-04  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/PyColorize.py (Parser.format2): Fix identation of
+	colorzied output and return early if color scheme is NoColor, to
+	avoid unnecessary and expensive tokenization.  Closes #131.
+
+2007-04-03  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Debugger.py: disable the use of pydb version 1.17.  It
+	has a critical bug (a missing import that makes post-mortem not
+	work at all).  Unfortunately as of this time, this is the version
+	shipped with Ubuntu Edgy, so quite a few people have this one.  I
+	hope Edgy will update to a more recent package.
+
+2007-04-02  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (_prefilter): close #52, second part of a patch
+	set by Stefan (only the first part had been applied before).
+
+	* IPython/Extensions/ipy_stock_completers.py (module_completer):
+	remove usage of the dangerous pkgutil.walk_packages().  See
+	details in comments left in the code.
+
+	* IPython/Magic.py (magic_whos): add support for numpy arrays
+	similar to what we had for Numeric.
+
+	* IPython/completer.py (IPCompleter.complete): extend the
+	complete() call API to support completions by other mechanisms
+	than readline.  Closes #109.
+
+	* IPython/iplib.py (safe_execfile): add a safeguard under Win32 to
+	protect against a bug in Python's execfile().  Closes #123.
+
+2007-04-01  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (split_user_input): ensure that when splitting
+	user input, the part that can be treated as a python name is pure
+	ascii (Python identifiers MUST be pure ascii).  Part of the
+	ongoing Unicode support work.
+
+	* IPython/Prompts.py (prompt_specials_color): Add \N for the
+	actual prompt number, without any coloring.  This allows users to
+	produce numbered prompts with their own colors.  Added after a
+	report/request by Thorsten Kampe <thorsten-AT-thorstenkampe.de>.
+
+2007-03-31  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/igrid.py: Map the return key
+	to enter() and shift-return to enterattr().
+
+2007-03-30  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Magic.py (magic_psearch): add unicode support by
+	encoding to ascii the input, since this routine also only deals
+	with valid Python names.  Fixes a bug reported by Stefan.
+
+2007-03-29  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Magic.py (_inspect): convert unicode input into ascii
+	before trying to evaluate it as a Python identifier.  This fixes a
+	problem that the new unicode support had introduced when analyzing
+	long definition lines for functions.
+
+2007-03-24  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/igrid.py: Fix picking. Using
+	igrid with wxPython 2.6 and -wthread should work now.
+	igrid.display() simply tries to create a frame without
+	an application. Only if this fails an application is created.
+
+2007-03-23  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/path.py: Updated to version 2.2.
+
+2007-03-23  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py: recursive alias expansion now works better, so that
+	cases like 'top' -> 'd:/cygwin/top' -> 'ls :/cygwin/top'
+	doesn't trip up the process, if 'd' has been aliased to 'ls'.
+	
+	* Extensions/ipy_gnuglobal.py added, provides %global magic
+	for users of http://www.gnu.org/software/global
+	
+	* iplib.py: '!command /?' now doesn't invoke IPython's help system.
+	Closes #52. Patch by Stefan van der Walt.
+
+2007-03-23  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/FakeModule.py (FakeModule.__init__): Small fix to
+	respect the __file__ attribute when using %run.  Thanks to a bug
+	report by Sebastian Rooks <sebastian.rooks-AT-free.fr>.
+
+2007-03-22  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (raw_input): Fix mishandling of unicode at
+	input.  Patch sent by Stefan.
+
+2007-03-20  Jorgen Stenarson  <jorgen.stenarson@bostream.nu>
+	* IPython/Extensions/ipy_stock_completer.py
+	shlex_split, fix bug in shlex_split. len function
+	call was missing an if statement. Caused shlex_split to
+	sometimes return "" as last element.
+
+2007-03-18  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/completer.py
+	(IPCompleter.file_matches.single_dir_expand): fix a problem
+	reported by Stefan, where directories containign a single subdir
+	would be completed too early.
+
+	* IPython/Shell.py (_load_pylab): Make the execution of 'from
+	pylab import *' when -pylab is given be optional.  A new flag,
+	pylab_import_all controls this behavior, the default is True for
+	backwards compatibility.
+
+	* IPython/ultraTB.py (_formatTracebackLines): Added (slightly
+	modified) R. Bernstein's patch for fully syntax highlighted
+	tracebacks.  The functionality is also available under ultraTB for
+	non-ipython users (someone using ultraTB but outside an ipython
+	session).  They can select the color scheme by setting the
+	module-level global DEFAULT_SCHEME.  The highlight functionality
+	also works when debugging.
+
+	* IPython/genutils.py (IOStream.close): small patch by
+	R. Bernstein for improved pydb support.
+
+	* IPython/Debugger.py (Pdb.format_stack_entry): Added patch by
+	DaveS <davls@telus.net> to improve support of debugging under
+	NTEmacs, including improved pydb behavior.
+
+	* IPython/Magic.py (magic_prun): Fix saving of profile info for
+	Python 2.5, where the stats object API changed a little.  Thanks
+	to a bug report by Paul Smith <paul.smith-AT-catugmt.com>.
+	
+	* IPython/ColorANSI.py (InputTermColors.Normal): applied Nicolas
+	Pernetty's patch to improve support for (X)Emacs under Win32.
+
+2007-03-17  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Shell.py (hijack_wx): ipmort WX with current semantics
+	to quiet a deprecation warning that fires with Wx 2.8.  Thanks to
+	a report by Nik Tautenhahn.
+
+2007-03-16  Walter Doerwald  <walter@livinglogic.de>
+
+	* setup.py: Add the igrid help files to the list of data files
+	to be installed alongside igrid.
+	* IPython/Extensions/igrid.py: (Patch by Nik Tautenhahn)
+	Show the input object of the igrid browser as the window tile.
+	Show the object the cursor is on in the statusbar.
+
+2007-03-15  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/ipy_stock_completers.py: Fixed exception
+        on mismatching quotes in %run completer. Patch by
+        Jorgen Stenarson. Closes #127.
+
+2007-03-14  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/ext_rehashdir.py: Do not do auto_alias
+        in %rehashdir, it clobbers %store'd aliases.
+        
+        * UserConfig/ipy_profile_sh.py: envpersist.py extension
+        (beefed up %env) imported for sh profile.
+
+2007-03-10  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py: Prefer ibrowse over igrid
+	as the default browser.
+	* IPython/Extensions/igrid.py: Make a few igrid attributes private.
+	As igrid displays all attributes it ever encounters, fetch() (which has
+	been renamed to _fetch()) doesn't have to recalculate the display attributes
+	every time a new item is fetched. This should speed up scrolling.
+
+2007-03-10  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (InteractiveShell.__init__): fix for Alex
+	Schmolck's recently reported tab-completion bug (my previous one
+	had a problem).  Patch by Dan Milstein <danmil-AT-comcast.net>.
+
+2007-03-09  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/igrid.py: Patch by Nik Tautenhahn:
+	Close help window if exiting igrid.
+
+2007-03-02  Jorgen Stenarson  <jorgen.stenarson@bostream.nu>
+
+	* IPython/Extensions/ipy_defaults.py: Check if readline is available
+	before calling functions from readline.
+
+2007-03-02  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/igrid.py: Add Nik Tautenhahns igrid extension.
+	igrid is a wxPython-based display object for ipipe. If your system has
+	wx installed igrid will be the default display. Without wx ipipe falls
+	back to ibrowse (which needs curses). If no curses is installed ipipe
+	falls back to idump.
+
+2007-03-01  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (split_user_inputBROKEN): temporarily disable
+	my changes from yesterday, they introduced bugs.  Will reactivate
+	once I get a correct solution, which will be much easier thanks to
+	Dan Milstein's new prefilter test suite.
+
+2007-02-28  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (split_user_input): fix input splitting so we
+	don't attempt attribute accesses on things that can't possibly be
+	valid Python attributes.  After a bug report by Alex Schmolck.
+	(InteractiveShell.__init__): brown-paper bag fix; regexp broke
+	%magic with explicit % prefix.
+
+2007-02-27  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Shell.py (IPShellGTK.mainloop): update threads calls to
+	avoid a DeprecationWarning from GTK.
+
+2007-02-22  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/genutils.py (clock): I modified clock() to return total
+	time, user+system.  This is a more commonly needed metric.  I also
+	introduced the new clocku/clocks to get only user/system time if
+	one wants those instead.
+	
+	***WARNING: API CHANGE*** clock() used to return only user time,
+	so if you want exactly the same results as before, use clocku
+	instead.
+
+2007-02-22  Ville Vainio  <vivainio@gmail.com>
+
+	* IPython/Extensions/ipy_p4.py: Extension for improved
+        p4 (perforce version control system) experience.
+        Adds %p4 magic with p4 command completion and
+        automatic -G argument (marshall output as python dict)
+
+2007-02-19  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/demo.py (Demo.re_stop): make dashes optional in demo
+	stop marks. 
+	(ClearingMixin): a simple mixin to easily make a Demo class clear
+	the screen in between blocks and have empty marquees. The
+	ClearDemo and ClearIPDemo classes that use it are included.
+
+2007-02-18  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/irunner.py (pexpect_monkeypatch): patch pexpect to
+	protect against exceptions at Python shutdown time.  Patch
+	sumbmitted to upstream.
+
+2007-02-14  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ibrowse.py: If entering the first object level
+	(i.e. the object for which the browser has been started) fails,
+	now the error is raised directly (aborting the browser) instead of
+	running into an empty levels list later.
+
+2007-02-03  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py: Add an xrepr implementation
+	for the noitem object.
+
+2007-01-31  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/completer.py (Completer.attr_matches): Fix small
+	tab-completion bug with Enthought Traits objects with units.
+	Thanks to a bug report by Tom Denniston
+	<tom.denniston-AT-alum.dartmouth.org>.
+
+2007-01-27  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Extensions/ipy_stock_completers.py (runlistpy): fix a
+	bug where only .ipy or .py would be completed.  Once the first
+	argument to %run has been given, all completions are valid because
+	they are the arguments to the script, which may well be non-python
+	filenames.
+
+	* IPython/irunner.py (InteractiveRunner.run_source): major updates
+	to irunner to allow it to correctly support real doctesting of
+	out-of-process ipython code.
+
+	* IPython/Magic.py (magic_cd): Make the setting of the terminal
+	title an option (-noterm_title) because it completely breaks
+	doctesting.
+
+	* IPython/demo.py: fix IPythonDemo class that was not actually working.
+
+2007-01-24  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/irunner.py (main): fix small bug where extensions were
+	not being correctly recognized.
+
+2007-01-23  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py (xiter): Make sure that iterating
+	a string containing a single line yields the string itself as the
+	only item.
+
+	* IPython/Extensions/ibrowse.py (ibrowse): Avoid entering an
+	object if it's the same as the one on the last level (This avoids
+	infinite recursion for one line strings).
+
+2007-01-17  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/ultraTB.py (AutoFormattedTB.__call__): properly flush
+	all output streams before printing tracebacks.  This ensures that
+	user output doesn't end up interleaved with traceback output.
+
+2007-01-10  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/envpersist.py: Turbocharged %env that remembers
+	env vars across sessions; e.g. "%env PATH+=;/opt/scripts" or
+	"%env VISUAL=jed".
+
+2007-01-05  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (showtraceback): ensure that we correctly call
+	custom handlers in all cases (some with pdb were slipping through,
+	but I'm not exactly sure why).
+
+	* IPython/Debugger.py (Tracer.__init__): added new class to
+	support set_trace-like usage of IPython's enhanced debugger.
+
+2006-12-24  Ville Vainio  <vivainio@gmail.com>
+
+	* ipmaker.py: more informative message when ipy_user_conf
+	import fails (suggest running %upgrade).
+	
+	* tools/run_ipy_in_profiler.py: Utility to see where
+	the time during IPython startup is spent.
+	
+2006-12-20  Ville Vainio  <vivainio@gmail.com>
+
+	* 0.7.3 is out - merge all from 0.7.3 branch to trunk
+
+	* ipapi.py: Add new ipapi method, expand_alias.
+	
+	* Release.py: Bump up version to 0.7.4.svn
+
+2006-12-17  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/jobctrl.py: Fixed &cmd arg arg... 
+	to work properly on posix too
+	
+	* Release.py: Update revnum (version is still just 0.7.3).
+
+2006-12-15  Ville Vainio  <vivainio@gmail.com>
+
+	* scripts/ipython_win_post_install: create ipython.py in
+	prefix + "/scripts".
+	
+	* Release.py: Update version to 0.7.3.
+    
+2006-12-14  Ville Vainio  <vivainio@gmail.com>
+
+	* scripts/ipython_win_post_install: Overwrite old shortcuts
+	if they already exist
+
+	* Release.py: release 0.7.3rc2
+    
+2006-12-13  Ville Vainio  <vivainio@gmail.com>
+
+	* Branch and update Release.py for 0.7.3rc1
+
+2006-12-13  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Shell.py (IPShellWX): update for current WX naming
+	conventions, to avoid a deprecation warning with current WX
+	versions.  Thanks to a report by Danny Shevitz.
+
+2006-12-12  Ville Vainio  <vivainio@gmail.com>
+
+	* ipmaker.py: apply david cournapeau's patch to make
+	import_some work properly even when ipythonrc does 
+	import_some on empty list (it was an old bug!).
+
+	* UserConfig/ipy_user_conf.py, UserConfig/ipythonrc:
+	Add deprecation note to ipythonrc and a url to wiki
+	in ipy_user_conf.py
+
+		 
+	* Magic.py (%run): %run myscript.ipy now runs myscript.ipy
+	as if it was typed on IPython command prompt, i.e.
+	as IPython script.
+	
+	* example-magic.py, magic_grepl.py: remove outdated examples
+
+2006-12-11  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+        * IPython/iplib.py (debugger): prevent a nasty traceback if %debug
+        is called before any exception has occurred.
+	
+2006-12-08  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/ipy_stock_completers.py: fix cd completer 
+	to translate /'s to \'s again.
+	
+	* completer.py: prevent traceback on file completions w/ 
+	backslash.
+	
+	* Release.py: Update release number to 0.7.3b3 for release
+
+2006-12-07  Ville Vainio  <vivainio@gmail.com>
+
+	* Extensions/ipy_signals.py: Ignore ctrl+C in IPython process
+	while executing external code. Provides more shell-like behaviour
+	and overall better response to ctrl + C / ctrl + break.
+
+	* tools/make_tarball.py: new script to create tarball straight from svn
+	(setup.py sdist doesn't work on win32).
+
+	* Extensions/ipy_stock_completers.py: fix cd completer to give up
+	on dirnames with spaces and use the default completer instead.
+
+	* Revision.py: Change version to 0.7.3b2 for release.
+
+2006-12-05  Ville Vainio  <vivainio@gmail.com>
+
+	* Magic.py, iplib.py, completer.py: Apply R. Bernstein's
+	pydb patch 4 (rm debug printing, py 2.5 checking)
+
+2006-11-30  Walter Doerwald  <walter@livinglogic.de>
+	* IPython/Extensions/ibrowse.py: Add two new commands to ibrowse:
+	"refresh" (mapped to "r") refreshes the screen by restarting the iterator.
+	"refreshfind" (mapped to "R") does the same but tries to go back to the same
+	object the cursor was on before the refresh. The command "markrange" is
+	mapped to "%" now.
+	* IPython/Extensions/ibrowse.py: Make igrpentry and ipwdentry comparable.
+
+2006-11-29  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Magic.py (magic_debug): new %debug magic to activate the
+	interactive debugger on the last traceback, without having to call
+	%pdb and rerun your code.  Made minor changes in various modules,
+	should automatically recognize pydb if available.
+
+2006-11-28  Ville Vainio  <vivainio@gmail.com>
+
+	* completer.py: If the text start with !, show file completions
+	properly. This helps when trying to complete command name
+	for shell escapes.
+
+2006-11-27  Ville Vainio  <vivainio@gmail.com>
+
+	* ipy_stock_completers.py: bzr completer submitted by Stefan van 
+	der Walt. Clean up svn and hg completers by using a common 
+	vcs_completer. 
+	
+2006-11-26  Ville Vainio  <vivainio@gmail.com>
+
+	* Remove ipconfig and %config; you should use _ip.options structure
+	directly instead!
+	
+	* genutils.py: add wrap_deprecated function for deprecating callables
+	
+	* iplib.py: deprecate ipmagic, ipsystem, ipalias. Use _ip.magic and
+	_ip.system instead. ipalias is redundant.
+	
+	* Magic.py: %rehashdir no longer aliases 'cmdname' to 'cmdname.exe' on 
+	win32, but just 'cmdname'. Other extensions (non-'exe') are still made 
+	explicit.
+
+	* ipy_stock_completers.py: 'hg' (mercurial VCS) now has a custom 
+	completer. Try it by entering 'hg ' and pressing tab.
+
+	* macro.py: Give Macro a useful __repr__ method
+	
+	* Magic.py: %whos abbreviates the typename of Macro for brevity.
+	
+2006-11-24  Walter Doerwald  <walter@livinglogic.de>
+	* IPython/Extensions/astyle.py: Do a relative import of ipipe, so that
+	we don't get a duplicate ipipe module, where registration of the xrepr
+	implementation for Text is useless.
+
+	* IPython/Extensions/ipipe.py: Fix __xrepr__() implementation for ils.
+
+	* IPython/Extensions/ibrowse.py: Fix keymapping for the enter command.
+
+2006-11-24  Ville Vainio  <vivainio@gmail.com>
+
+	* Magic.py, manual_base.lyx: Kirill Smelkov patch: 
+	try to use "cProfile" instead of the slower pure python
+	"profile"
+
+2006-11-23  Ville Vainio  <vivainio@gmail.com>
+
+	* manual_base.lyx: Kirill Smelkov patch: Fix wrong 
+	Qt+IPython+Designer link in documentation.
+	
+	* Extensions/ipy_pydb.py: R. Bernstein's patch for passing 
+	correct Pdb object to %pydb.
+
+
+2006-11-22  Walter Doerwald  <walter@livinglogic.de>
+	* IPython/Extensions/astyle.py: Text needs it's own implemenation of the
+	generic xrepr(), otherwise the list implementation would kick in.
+
+2006-11-21  Ville Vainio  <vivainio@gmail.com>
+
+	* upgrade_dir.py: Now actually overwrites a nonmodified user file
+	with one from UserConfig.
+	
+	* ipy_profile_sh.py: Add dummy "depth" to var_expand lambda, 
+	it was missing which broke the sh profile.
+	
+	* completer.py: file completer now uses explicit '/' instead
+	of os.path.join, expansion of 'foo' was broken on win32 
+	if there was one directory with name 'foobar'. 
+
+	* A bunch of patches from Kirill Smelkov:
+	
+	* [patch 9/9] doc: point bug-tracker URL to IPythons trac-tickets.
+
+	* [patch 7/9] Implement %page -r (page in raw mode) - 
+
+	* [patch 5/9] ScientificPython webpage has moved
+
+	* [patch 4/9] The manual mentions %ds, should be %dhist
+
+	* [patch 3/9] Kill old bits from %prun doc.
+
+	* [patch 1/9] Fix typos here and there.
+
+2006-11-08  Ville Vainio  <vivainio@gmail.com>
+
+	* completer.py (attr_matches): catch all exceptions raised 
+	by eval of expr with dots.
+
+2006-11-07  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (runsource): Prepend an 'if 1:' to the user
+	input if it starts with whitespace.  This allows you to paste
+	indented input from any editor without manually having to type in
+	the 'if 1:', which is convenient when working interactively.
+	Slightly modifed version of a patch by Bo Peng
+	<bpeng-AT-rice.edu>.
+
+2006-11-03  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/irunner.py (main): modified irunner so it automatically
+	recognizes the right runner to use based on the extension (.py for
+	python, .ipy for ipython and .sage for sage).
+
+	* IPython/iplib.py (InteractiveShell.ipconfig): new builtin, also
+	visible in ipapi as ip.config(), to programatically control the
+	internal rc object.  There's an accompanying %config magic for
+	interactive use, which has been enhanced to match the
+	funtionality in ipconfig.
+
+	* IPython/Magic.py (magic_system_verbose): Change %system_verbose
+	so it's not just a toggle, it now takes an argument.  Add support
+	for a customizable header when making system calls, as the new
+	system_header variable in the ipythonrc file.
+
+2006-11-03  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py: xrepr(), xiter() and xattrs() are now
+	generic functions (using Philip J. Eby's simplegeneric package).
+	This makes it possible to customize the display of third-party classes
+	without having to monkeypatch them. xiter() no longer supports a mode
+	argument and the XMode class has been removed. The same functionality can
+	be implemented via IterAttributeDescriptor and IterMethodDescriptor.
+	One consequence of the switch to generic functions is that xrepr() and
+	xattrs() implementation must define the default value for the mode
+	argument themselves and xattrs() implementations must return real
+	descriptors.
+
+	* IPython/external: This new subpackage will contain all third-party
+	packages that are bundled with IPython. (The first one is simplegeneric).
+
+	* IPython/Extensions/ipipe.py (ifile/ils): Readd output of the parent
+	directory which as been dropped in r1703.
+
+	* IPython/Extensions/ipipe.py (iless): Fixed.
+
+	* IPython/Extensions/ibrowse: Fixed sorting under Python 2.3.
+
+2006-11-03  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (InteractiveShell.var_expand): fix stack
+	handling in variable expansion so that shells and magics recognize
+	function local scopes correctly.  Bug reported by Brian.
+
+	* scripts/ipython: remove the very first entry in sys.path which
+	Python auto-inserts for scripts, so that sys.path under IPython is
+	as similar as possible to that under plain Python.
+
+	* IPython/completer.py (IPCompleter.file_matches): Fix
+	tab-completion so that quotes are not closed unless the completion
+	is unambiguous.  After a request by Stefan.  Minor cleanups in
+	ipy_stock_completers.
+
+2006-11-02  Ville Vainio  <vivainio@gmail.com>
+
+	* ipy_stock_completers.py: Add %run and %cd completers.
+	
+	* completer.py: Try running custom completer for both 
+	"foo" and "%foo" if the command is just "foo". Ignore case
+	when filtering possible completions.
+	
+	* UserConfig/ipy_user_conf.py: install stock completers as default	
+	
+	* iplib.py (history_saving_wrapper), debugger(), ipy_pydb.py:
+	simplified readline history save / restore through a wrapper 
+	function
+	
+	
+2006-10-31  Ville Vainio  <vivainio@gmail.com>
+
+	* strdispatch.py, completer.py, ipy_stock_completers.py:
+	Allow str_key ("command") in completer hooks. Implement 
+	trivial completer for 'import' (stdlib modules only). Rename 
+	ipy_linux_package_managers.py to ipy_stock_completers.py.
+	SVN completer.
+	
+	* Extensions/ledit.py: %magic line editor for easily and
+	incrementally manipulating lists of strings. The magic command
+	name is %led.
+
+2006-10-30  Ville Vainio  <vivainio@gmail.com>
+
+	* Debugger.py, iplib.py (debugger()): Add last set of Rocky 
+	Bernsteins's patches for pydb integration.
+	http://bashdb.sourceforge.net/pydb/
+	
+	* strdispatch.py, iplib.py, completer.py, IPython/__init__.py,
+	Extensions/ipy_linux_package_managers.py, hooks.py: Implement 
+	custom completer hook to allow the users to implement their own 
+	completers. See ipy_linux_package_managers.py for example. The 
+	hook name is 'complete_command'. 
+
+2006-10-28  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/UserConfig/ipythonrc-scipy: minor cleanups to remove old
+	Numeric leftovers.
+
+	* ipython.el (py-execute-region): apply Stefan's patch to fix
+	garbled results if the python shell hasn't been previously started.
+
+	* IPython/genutils.py (arg_split): moved to genutils, since it's a
+	pretty generic function and useful for other things.
+
+	* IPython/OInspect.py (getsource): Add customizable source
+	extractor.  After a request/patch form W. Stein (SAGE).
+
+	* IPython/irunner.py (InteractiveRunner.run_source): reset tty
+	window size to a more reasonable value from what pexpect does,
+	since their choice causes wrapping bugs with long input lines.
+
+2006-10-28  Ville Vainio  <vivainio@gmail.com>
+
+	* Magic.py (%run): Save and restore the readline history from 
+	file around %run commands to prevent side effects from 
+	%runned programs that might use readline (e.g. pydb).
+
+	* extensions/ipy_pydb.py: Adds %pydb magic when imported, for 
+	invoking the pydb enhanced debugger.
+
+2006-10-23  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py (ifile): Remove all methods that
+	call the base class method and propagate the return value to
+	ifile. This is now done by path itself.
+
+2006-10-15  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/ipapi.py (IPApi.__init__): Added new entry to public
+	api: set_crash_handler(), to expose the ability to change the
+	internal crash handler.
+
+	* IPython/CrashHandler.py (CrashHandler.__init__): abstract out
+	the various parameters of the crash handler so that apps using
+	IPython as their engine can customize crash handling.  Ipmlemented
+	at the request of SAGE.
+
+2006-10-14  Ville Vainio  <vivainio@gmail.com>
+
+	* Magic.py, ipython.el: applied first "safe" part of Rocky 
+	Bernstein's patch set for pydb integration.
+
+	* Magic.py (%unalias, %alias): %store'd aliases can now be
+	removed with '%unalias'. %alias w/o args now shows most 
+	interesting (stored / manually defined) aliases last
+	where they catch the eye w/o scrolling.
+
+	* Magic.py (%rehashx), ext_rehashdir.py: files with
+	'py' extension are always considered executable, even
+	when not in PATHEXT environment variable.
+
+2006-10-12  Ville Vainio  <vivainio@gmail.com>
+
+	* jobctrl.py: Add new "jobctrl" extension for spawning background
+	processes with "&find /". 'import jobctrl' to try it out. Requires
+	'subprocess' module, standard in python 2.4+.
+	
+	* iplib.py (expand_aliases, handle_alias): Aliases expand transitively, 
+	so if foo -> bar and bar -> baz, then foo -> baz.
+
+2006-10-09  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Magic.py (Magic.parse_options): add a new posix option
+	to allow parsing of input args in magics that doesn't strip quotes
+	(if posix=False).  This also closes %timeit bug reported by
+	Stefan.
+
+2006-10-03  Ville Vainio  <vivainio@gmail.com>
+
+	* iplib.py (raw_input, interact): Return ValueError catching for 
+	raw_input. Fixes infinite loop for sys.stdin.close() or 
+	sys.stdout.close().
+
+2006-09-27  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <walter@livinglogic.de>
+
+	* 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  <vivainio@gmail.com>
+
+	* Fakemodule.py, OInspect.py: Reverted 2006-08-11 mods,
+	they broke unittest 
+
+2006-08-11  Ville Vainio  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <walter@livinglogic.de>
+
+	* IPython/Extensions/ibrowse.py: Fixed the help message in the footer
+	(which was displaying "quit" twice).
+
+2006-07-28  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py: Fix isort.__iter__() (was still using
+	the mode argument).
+
+2006-07-27  Walter Doerwald  <walter@livinglogic.de>
+
+	* 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  <vivainio@gmail.com>
+
+	* iplib.py: history now stores multiline input as single
+	history entries. Patch by Jorgen Cederlof.
+
+2006-07-18  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ibrowse.py: Make cursor visible over
+	non existing attributes.
+
+2006-07-14  Walter Doerwald  <walter@livinglogic.de>
+
+	* 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  <walter@livinglogic.de>
+
+	* IPython/Extensions/ipipe.py (isort): Make isort usable without
+	argument. This sorts the items themselves.
+
+2006-07-12  Walter Doerwald  <walter@livinglogic.de>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <vivainio@gmail.com>
+
+	* ipmaker.py, Shell.py: qt4agg matplotlib backend support for pylab
+	mode, patch contributed by Darren Dale. NEEDS TESTING! 
+
+2006-06-28  Walter Doerwald  <walter@livinglogic.de>
+
+	* 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  <vivainio@gmail.com>
+
+	* Magic.py (_inspect, _ofind) Apply David Huard's 
+	patch for displaying the correct docstring for 'property' 
+	attributes.
+
+2006-06-23  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ibrowse.py: Put the documentation of the keyboard
+	commands into the methods implementing them.
+
+2006-06-22  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* 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  <walter@livinglogic.de>
+
+	* IPython/Extensions/ibrowse.py: Replace the plain dictionaries used
+	for keymaps with a custom class that simplifies handling.
+
+2006-06-19  Walter Doerwald  <walter@livinglogic.de>
+
+	* IPython/Extensions/ibrowse.py: ibrowse now properly handles terminal
+	resizing. This requires Python 2.5 to work.
+
+2006-06-16  Walter Doerwald  <walter@livinglogic.de>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <walter@livinglogic.de>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <walter@livinglogic.de>
+
+	* 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  <walter@livinglogic.de>
+
+	* 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  <vivainio@gmail.com>
+
+	* iplib.py: ipython mybatch.ipy exits ipython immediately after
+	running the batch files instead of leaving the session open.
+
+2006-06-07  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (InteractiveShell.__init__): update BSD fix, as
+	the original fix was incomplete.  Patch submitted by W. Maier.
+
+2006-06-07  Ville Vainio  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* IPython/Release.py (version): Made 0.7.2 final for release.
+	Repo tagged and release cut.
+
+2006-06-05  Ville Vainio  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* Oinspect.py: Only show docstring for nonexisting/binary files
+	when doing object??, closing ticket #62
+
+2006-05-13  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* IPython/Release.py (version): put out 0.7.2.rc1 for testing.
+
+2006-04-11  Ville Vainio  <vivainio@gmail.com>
+
+	* 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  <vivainio@gmail.com>
+
+	* iplib.py: Fix quoting of aliases so that only argless ones
+	are quoted
+
+2006-03-28  Ville Vainio  <vivainio@gmail.com>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* IPython/Gnuplot2.py (_FileClass): update for current Gnuplot.py
+	from SVN, thanks to a patch by Ryan Woodard <rywo@bas.ac.uk>.
+
+2006-03-12  Ville Vainio  <vivainio@gmail.com>
+
+	* Magic.py (magic_timeit): Added %timeit magic, contributed by
+	Torsten Marek.
+
+2006-03-12  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* IPython/Magic.py (magic_macro): fix so that the n1-n2 syntax for
+	line ranges works again.
+
+2006-03-11  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* Extensions/ipipe.py: Added Walter Doerwald's "ipipe" module.
+	To use, do "from ipipe import *".
+
+2006-02-24  Ville Vainio  <vivainio@gmail.com>
+
+	* Magic.py, upgrade_dir.py: %upgrade magic added. Does things more
+	"cleanly" and safely than the older upgrade mechanism.
+
+2006-02-21  Ville Vainio  <vivainio@gmail.com>
+
+	* Magic.py: %save works again.
+
+2006-02-15  Ville Vainio  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* iplib.py: Try to import pyreadline on Windows.
+
+2006-01-27  Ville Vainio  <vivainio@gmail.com>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* Added %cpaste magic for pasting python code
+
+2006-01-22  Ville Vainio  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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 <walter@livinglogic.de>. Walter also
+	requested configurable display hook, which is now implemented.
+
+2006-01-13  Ville Vainio  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <vivainio@gmail.com>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* setup_bdist_egg.py: little script to build an egg.  Added
+	support in the release tools as well.
+
+2006-01-08  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* IPython/iplib.py (_should_recompile): Small fix, closes
+	http://www.scipy.net/roundup/ipython/issue48.  Patch by Scott.
+
+2006-01-04  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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   <Fernando.Perez@colorado.edu>
+
+	* 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   <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* IPython/Extensions/numeric_formats.py: fix missing import,
+	reported by Stephen Walton.
+
+2005-09-24  Fernando Perez  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* tools/ipsvnc: Minor improvements, to add changeset info.
+
+2005-08-12  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <Fernando.Perez@colorado.edu>
+
+	* IPython/genutils.py: fix 2.2 compatibility (generators)
+
+2005-07-18  Fernando Perez  <fperez@colorado.edu>
+
+	* IPython/genutils.py (get_home_dir): fix to help users with
+	invalid $HOME under win32.
+
+2005-07-17  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/ultraTB.py (VerboseTB.text): Fix crash for tracebacks
+	with files not on the filesystem.  Reported by Eliyahu Sandler
+	<eli@gondolin.net>
+
+2005-05-22  Fernando Perez  <fperez@colorado.edu>
+
+	* IPython/iplib.py: Fix a few crashes in the --upgrade option.
+	After an initial report by LUK ShunTim <shuntim.luk@polyu.edu.hk>.
+
+2005-05-19  Fernando Perez  <fperez@colorado.edu>
+
+	* 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 <dbrown2@yahoo.com>.
+
+2005-05-18  Fernando Perez  <fperez@colorado.edu>
+
+	* IPython/Shell.py (MatplotlibShellBase.mplot_exec): pass all
+	keyword arguments correctly to safe_execfile().
+
+2005-05-13  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Shell.py (hijack_wx): Fix to work with WX v.2.6.
+
+2005-04-29  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Prompts.py (BasePrompt.cwd_filt): a few more fixes for
+	prompt namespace handling.
+
+2005-03-16  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Shell.py (MTInteractiveShell.runcode): Trap a crash with
+	signal handling for win32 users in multithreaded mode.
+
+2005-01-17  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Shell.py (IPShellGTK.__init__): Patch by Andrew Straw
+	<astraw-AT-caltech.edu>, to fix gtk deprecation warnings.
+
+2004-12-19  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/iplib.py (MagicCompleter.complete): Remove annoying
+	warnings when tab-completion fails and triggers an exception.
+
+2004-12-03  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Logger.py (Logger.log): Fix bug in syncing the input
+	cache when empty lines were present.
+
+2004-11-24  Fernando Perez  <fperez@colorado.edu>
+
+	* IPython/usage.py (__doc__): document the re-activated threading
+	options for WX and GTK.
+
+2004-11-23  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/genutils.py (page): Add a trap for OSError exceptions,
+	sometimes seen by win2k/cygwin users.
+
+2004-11-06  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Extensions/InterpreterExec.py (prefilter_shell): Fix @
+	to % for pysh syntax extensions.
+
+2004-10-09  Fernando Perez  <fperez@colorado.edu>
+
+	* 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
+	<Kristian.Sandberg@colorado.edu>.
+	(Magic.__init__): fix bug in global magic escapes not being
+	correctly set.
+
+2004-10-08  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Shell.py (IPShellGTK.mainloop): reorder to avoid
+	blocking problems in win32 and osx.  Fix by John.
+
+2004-09-08  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* setup.py (isfile): Add manpages to list of dependent files to be
+	updated.
+
+2004-08-27  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* setup.py (isfile): Fix build so documentation gets updated for
+	rpms (it was only done for .tgz builds).
+
+2004-08-10  Fernando Perez  <fperez@colorado.edu>
+
+	* genutils.py (Term): Fix misspell of stdin stream (sin->cin).
+
+	* iplib.py : Silence syntax error exceptions in tab-completion.
+	
+2004-08-05  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/iplib.py (__init__): Add better handling of '\' under
+	Win32 for filenames.  After a patch by Ville.
+
+2004-07-17  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Gnuplot2.py (Gnuplot.hardcopy): add automatic generation
+	of EPS if the requested filename ends in '.eps'.
+
+2004-07-04  Fernando Perez  <fperez@colorado.edu>
+
+	* IPython/iplib.py (InteractiveShell.handle_shell_escape): Fix
+	escaping of quotes when calling the shell.
+
+2004-07-02  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/iplib.py (file_matches): escape whitespace correctly in
+	filename completions.  Bug reported by Ville.
+
+2004-06-28  Fernando Perez  <fperez@colorado.edu>
+
+	* 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 <vivainio@kolumbus.fi>.  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 <travis_caldwell2000@yahoo.com>.
+
+2004-06-26  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Magic.py (Magic.magic_rehash): Fix crash when
+	non-existent items are found in $PATH.  Reported by Thorsten.
+
+2004-06-20  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/iplib.py (InteractiveShell.__init__): add 'cp' to the
+	list of auto-defined aliases.
+
+2004-06-13  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Logger.py (Logger.create_log): fix bug for logging
+	with no filename (previous fix was incomplete).
+
+2004-05-25  Fernando Perez  <fperez@colorado.edu>
+
+	* IPython/Magic.py (Magic.parse_options): fix bug where naked
+	parens would get passed to the shell.
+
+2004-05-20  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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
+	<rhh@StructureLABS.com> for the report and fixes.
+	
+2004-02-26  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/genutils.py (page): patch for the pager to work across
+	various versions of Windows.  By Gary Bishop.
+
+2003-12-04  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/numutils.py (amap): Added amap() fn.  Simple shorthand
+	for Numeric.array(map(...)), but often convenient.
+
+2003-11-05  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/iplib.py (InteractiveShell._prefilter): significant
+	simplifications to the logic for handling user escapes.  Faster
+	and simpler code.
+
+2003-08-14  Fernando Perez  <fperez@colorado.edu>
+
+        * 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/numutils.py (identity): new function, for building
+	arbitrary rank Kronecker deltas (mostly backwards compatible with
+	Numeric.identity)
+
+2003-06-03  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/iplib.py (InteractiveShell.user_setup): Fix crash when
+	installing for a new user under Windows.
+
+2003-05-12  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/genutils.py (timings_out): modified it to reduce its
+	overhead in the common reps==1 case.
+
+2003-04-29  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/genutils.py (error): added error() and fatal()
+	functions.
+
+2003-03-18  *** Released version 0.2.15pre3
+
+2003-03-18  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/iplib.py (InteractiveShell.interact): fixed default (y)
+	value of exit question to be acknowledged.
+
+2002-12-03  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Gnuplot2.py (PlotItem): Added 'index' option for
+	Gnuplot.File objects.
+	      
+2002-07-23  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/iplib.py (InteractiveShell.__init__): fixed reference to
+	__IPYTHON__ in __builtins__ to show up in user_ns.
+
+2002-07-03  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/genutils.py (timing): new function like
+	Mathematica's. Similar to time_test, but returns more info.
+
+2002-06-18  Fernando Perez  <fperez@colorado.edu>
+
+	* IPython/Magic.py (Magic.magic_save): modified @save and @r
+	according to Mike Heeter's suggestions.
+
+2002-06-16  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/Magic.py (Macro.__init__): fixed magics embedded in
+	macros having broken.
+
+2002-05-21  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/__init__.py (__all__): removed FlexCompleter from
+	__all__ so that things don't fail in platforms without readline.
+
+2002-05-10  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* Released 0.2.12
+
+2002-05-06  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* Added information about pdb in the docs.
+
+2002-04-17  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* IPython/genutils.py (get_home_dir): Try to make it work under
+	win9x also.
+
+2002-03-20  Fernando Perez  <fperez@colorado.edu>
+
+	* IPython/Shell.py (IPythonShellEmbed.__init__): leave
+	sys.displayhook untouched upon __init__.
+
+2002-03-19  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* setup.py: Merged setup and setup_windows into a single script
+	which properly handles things for windows users.
+
+2002-03-15  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* Released 0.2.5.
+
+2002-02-11  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* Released 0.2.3 (contacted R.Singh at CU about biopython course,
+	so I wanted an updated release).
+
+2001-12-27  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* setup.py: added check for 'MANIFEST' before trying to remove
+	it. Thanks to Sean Reifschneider.
+
+2001-12-22  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* Added .ipython/ directory to sys.path. This way users can keep
+	customizations there and access them via import.
+
+2001-11-03  Fernando Perez  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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  <fperez@colorado.edu>
+
+	* 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.
diff --git a/doc/README.txt b/doc/README.txt
new file mode 100644
index 0000000..d296d3e
--- /dev/null
+++ b/doc/README.txt
@@ -0,0 +1,14 @@
+Current version information
+---------------------------
+
+Please open manual.pdf for a PDF version of IPython's user manual, or go to
+the manual/ directory for an HTML version.
+
+
+Bugs and future developments
+----------------------------
+
+The new_design.pdf document is a description of the goals for IPython's future
+development.  It includes a TODO/bugs section listing all currently known bugs
+in IPython.  Please report any bug you encounter if it is not already listed
+there.
diff --git a/doc/README_Windows.txt b/doc/README_Windows.txt
new file mode 100644
index 0000000..9ec714f
--- /dev/null
+++ b/doc/README_Windows.txt
@@ -0,0 +1,39 @@
+Notes for Windows Users
+=======================
+
+These are just minimal notes.  The manual contains more detailed
+information.
+
+Requirements
+------------
+
+IPython runs under (as far as the Windows family is concerned):
+
+- Windows XP (I think WinNT/2000 are ok): works well.  It needs:
+
+  * Gary Bishop's readline from 
+    http://sourceforge.net/projects/uncpythontools.
+    
+  * This in turn requires Tomas Heller's ctypes from
+    http://starship.python.net/crew/theller/ctypes.
+
+- Windows 95/98/ME: I have no idea. It should work, but I can't test.
+
+- CygWin environments should work, they are basically Posix.
+
+It needs Python 2.2 or newer.
+
+
+Installation
+------------
+
+Double-click the supplied .exe installer file.  If all goes well, that's all
+you need to do. You should now have an IPython entry in your Start Menu.
+
+In case the automatic installer does not work for some reason, you can
+download the ipython-XXX.tar.gz file, which contains the full IPython source
+distribution (the popular WinZip can read .tar.gz files). After uncompressing
+the archive, you can install it at a command terminal just like any other
+Python module, by using python setup.py install'. After this completes, you
+can run the supplied win32_manual_post_install.py script which will add
+the relevant shortcuts to your startup menu.
diff --git a/doc/api_changes.txt b/doc/api_changes.txt
new file mode 100644
index 0000000..dc81fce
--- /dev/null
+++ b/doc/api_changes.txt
@@ -0,0 +1,35 @@
+=============
+ API Changes
+=============
+
+.. contents::
+..
+    1  Purpose
+    2  Version 0.8.2
+
+
+Purpose
+=======
+
+This file documents backwards-incompatible changes to the IPython API,
+including user-visible changes of commands, magics, etc.
+
+It should be filled in reverse chronological order, with one section for each
+release (which means changes since the previous release).
+
+
+Version 0.8.2
+=============
+
+Changes made since version 0.8.1 was released:
+
+* %pushd/%popd behave differently; now "pushd /foo" pushes CURRENT directory 
+  and jumps to /foo. The current behaviour is closer to the documented 
+  behaviour, and should not trip anyone.
+  
+Version 0.8.3
+=============
+  
+* pydb is now disabled by default (due to %run -d problems). You can enable
+it by passing -pydb command line argument to IPython. Note that setting
+it in config file won't work.
\ No newline at end of file
diff --git a/doc/build_doc_instruction.txt b/doc/build_doc_instruction.txt
new file mode 100644
index 0000000..b546509
--- /dev/null
+++ b/doc/build_doc_instruction.txt
@@ -0,0 +1,28 @@
+How to generate IPython documentation
+=====================================
+
+The doc is written using lyx http://www.lyx.org, which is a gui for latex
+documents. LyX also requires a latex installation.
+
+The file manual_base.lyx is the template file that should be edited if you
+want to do changes to the docs.
+
+A final version is generated by running 
+
+./update_manual.py
+
+or 
+
+ipython update_manual.py
+
+(note that "python update_manual.py" won't work, it's an ipython script!)
+
+The script update_manual.py will insert the current version number into the
+template and also generate magic.tex, a file containing documentation for
+the doc strings of the magic commands.
+
+The script creates manual.lyx which can be opened by lyx to generate pdf or
+postscript versions of the docs.
+
+update_magic.sh and update_version.sh work too, but are slated for
+deprecation.
diff --git a/doc/examples/example-demo.py b/doc/examples/example-demo.py
new file mode 100644
index 0000000..9128018
--- /dev/null
+++ b/doc/examples/example-demo.py
@@ -0,0 +1,40 @@
+"""A simple interactive demo to illustrate the use of IPython's Demo class.
+
+Any python script can be run as a demo, but that does little more than showing
+it on-screen, syntax-highlighted in one shot.  If you add a little simple
+markup, you can stop at specified intervals and return to the ipython prompt,
+resuming execution later.
+"""
+
+print 'Hello, welcome to an interactive IPython demo.'
+print 'Executing this block should require confirmation before proceeding,'
+print 'unless auto_all has been set to true in the demo object'
+
+# The mark below defines a block boundary, which is a point where IPython will
+# stop execution and return to the interactive prompt.
+# Note that in actual interactive execution, 
+# <demo> --- stop ---
+
+x = 1
+y = 2
+
+# <demo> --- stop ---
+
+# the mark below makes this block as silent
+# <demo> silent
+
+print 'This is a silent block, which gets executed but not printed.'
+
+# <demo> --- stop ---
+# <demo> auto
+print 'This is an automatic block.'
+print 'It is executed without asking for confirmation, but printed.'
+z = x+y
+
+print 'z=',x
+
+# <demo> --- stop ---
+# This is just another normal block.
+print 'z is now:', z
+
+print 'bye!'
diff --git a/doc/examples/example-embed-short.py b/doc/examples/example-embed-short.py
new file mode 100644
index 0000000..30999ef
--- /dev/null
+++ b/doc/examples/example-embed-short.py
@@ -0,0 +1,51 @@
+"""Quick code snippets for embedding IPython into other programs.
+
+See example-embed.py for full details, this file has the bare minimum code for
+cut and paste use once you understand how to use the system."""
+
+#---------------------------------------------------------------------------
+# This code loads IPython but modifies a few things if it detects it's running
+# embedded in another IPython session (helps avoid confusion)
+
+try:
+    __IPYTHON__
+except NameError:
+    argv = ['']
+    banner = exit_msg = ''
+else:
+    # Command-line options for IPython (a list like sys.argv)
+    argv = ['-pi1','In <\\#>:','-pi2','   .\\D.:','-po','Out<\\#>:']
+    banner = '*** Nested interpreter ***'
+    exit_msg = '*** Back in main IPython ***'
+
+# First import the embeddable shell class
+from IPython.Shell import IPShellEmbed
+# Now create the IPython shell instance. Put ipshell() anywhere in your code
+# where you want it to open.
+ipshell = IPShellEmbed(argv,banner=banner,exit_msg=exit_msg)
+                            
+#---------------------------------------------------------------------------
+# This code will load an embeddable IPython shell always with no changes for
+# nested embededings.
+
+from IPython.Shell import IPShellEmbed
+ipshell = IPShellEmbed()
+# Now ipshell() will open IPython anywhere in the code.
+
+#---------------------------------------------------------------------------
+# This code loads an embeddable shell only if NOT running inside
+# IPython. Inside IPython, the embeddable shell variable ipshell is just a
+# dummy function.
+
+try:
+    __IPYTHON__
+except NameError:
+    from IPython.Shell import IPShellEmbed
+    ipshell = IPShellEmbed()
+    # Now ipshell() will open IPython anywhere in the code
+else:
+    # Define a dummy ipshell() so the same code doesn't crash inside an
+    # interactive IPython
+    def ipshell(): pass
+
+#******************* End of file <example-embed-short.py> ********************
diff --git a/doc/examples/example-embed.py b/doc/examples/example-embed.py
new file mode 100644
index 0000000..3a0d907
--- /dev/null
+++ b/doc/examples/example-embed.py
@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+
+"""An example of how to embed an IPython shell into a running program.
+
+Please see the documentation in the IPython.Shell module for more details.
+
+The accompanying file example-embed-short.py has quick code fragments for
+embedding which you can cut and paste in your code once you understand how
+things work.
+
+The code in this file is deliberately extra-verbose, meant for learning."""
+
+# The basics to get you going:
+
+# IPython sets the __IPYTHON__ variable so you can know if you have nested
+# copies running.
+
+# Try running this code both at the command line and from inside IPython (with
+# %run example-embed.py)
+try:
+    __IPYTHON__
+except NameError:
+    nested = 0
+    args = ['']
+else:
+    print "Running nested copies of IPython."
+    print "The prompts for the nested copy have been modified"
+    nested = 1
+    # what the embedded instance will see as sys.argv:
+    args = ['-pi1','In <\\#>: ','-pi2','   .\\D.: ',
+            '-po','Out<\\#>: ','-nosep']
+
+# First import the embeddable shell class
+from IPython.Shell import IPShellEmbed
+
+# Now create an instance of the embeddable shell. The first argument is a
+# string with options exactly as you would type them if you were starting
+# IPython at the system command line. Any parameters you want to define for
+# configuration can thus be specified here.
+ipshell = IPShellEmbed(args,
+                       banner = 'Dropping into IPython',
+                       exit_msg = 'Leaving Interpreter, back to program.')
+
+# Make a second instance, you can have as many as you want.
+if nested:
+    args[1] = 'In2<\\#>'
+else:
+    args = ['-pi1','In2<\\#>: ','-pi2','   .\\D.: ',
+            '-po','Out<\\#>: ','-nosep']
+ipshell2 = IPShellEmbed(args,banner = 'Second IPython instance.')
+
+print '\nHello. This is printed from the main controller program.\n'
+
+# You can then call ipshell() anywhere you need it (with an optional
+# message):
+ipshell('***Called from top level. '
+        'Hit Ctrl-D to exit interpreter and continue program.\n'
+        'Note that if you use %kill_embedded, you can fully deactivate\n'
+        'This embedded instance so it will never turn on again')
+
+print '\nBack in caller program, moving along...\n'
+
+#---------------------------------------------------------------------------
+# More details:
+
+# IPShellEmbed instances don't print the standard system banner and
+# messages. The IPython banner (which actually may contain initialization
+# messages) is available as <instance>.IP.BANNER in case you want it.
+
+# IPShellEmbed instances print the following information everytime they
+# start:
+
+# - A global startup banner.
+
+# - A call-specific header string, which you can use to indicate where in the
+# execution flow the shell is starting.
+
+# They also print an exit message every time they exit.
+
+# Both the startup banner and the exit message default to None, and can be set
+# either at the instance constructor or at any other time with the
+# set_banner() and set_exit_msg() methods.
+
+# The shell instance can be also put in 'dummy' mode globally or on a per-call
+# basis. This gives you fine control for debugging without having to change
+# code all over the place.
+
+# The code below illustrates all this.
+
+
+# This is how the global banner and exit_msg can be reset at any point
+ipshell.set_banner('Entering interpreter - New Banner')
+ipshell.set_exit_msg('Leaving interpreter - New exit_msg')
+
+def foo(m):
+    s = 'spam'
+    ipshell('***In foo(). Try @whos, or print s or m:')
+    print 'foo says m = ',m
+
+def bar(n):
+    s = 'eggs'
+    ipshell('***In bar(). Try @whos, or print s or n:')
+    print 'bar says n = ',n
+    
+# Some calls to the above functions which will trigger IPython:
+print 'Main program calling foo("eggs")\n'
+foo('eggs')
+
+# The shell can be put in 'dummy' mode where calls to it silently return. This
+# allows you, for example, to globally turn off debugging for a program with a
+# single call.
+ipshell.set_dummy_mode(1)
+print '\nTrying to call IPython which is now "dummy":'
+ipshell()
+print 'Nothing happened...'
+# The global 'dummy' mode can still be overridden for a single call
+print '\nOverriding dummy mode manually:'
+ipshell(dummy=0)
+
+# Reactivate the IPython shell
+ipshell.set_dummy_mode(0)
+
+print 'You can even have multiple embedded instances:'
+ipshell2()
+
+print '\nMain program calling bar("spam")\n'
+bar('spam')
+
+print 'Main program finished. Bye!'
+
+#********************** End of file <example-embed.py> ***********************
diff --git a/doc/examples/example-gnuplot.py b/doc/examples/example-gnuplot.py
new file mode 100644
index 0000000..1fa9e12
--- /dev/null
+++ b/doc/examples/example-gnuplot.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+"""
+Example code showing how to use Gnuplot and an embedded IPython shell.
+"""
+
+from Numeric import *
+from IPython.numutils import *
+from IPython.Shell import IPShellEmbed
+
+# Arguments to start IPython shell with. Load numeric profile.
+ipargs = ['-profile','numeric']
+ipshell = IPShellEmbed(ipargs)
+
+# Compute sin(x) over the 0..2pi range at 200 points
+x = frange(0,2*pi,npts=200)
+y = sin(x)
+
+# In the 'numeric' profile, IPython has an internal gnuplot instance:
+g = ipshell.IP.gnuplot
+
+# Change some defaults
+g('set style data lines')
+
+# Or also call a multi-line set of gnuplot commands on it:
+g("""
+set xrange [0:pi]     # Set the visible range to half the data only
+set title 'Half sine' # Global gnuplot labels
+set xlabel 'theta'
+set ylabel 'sin(theta)'
+""")
+
+# Now start an embedded ipython.
+ipshell('Starting the embedded IPyhton.\n'
+        'Try calling plot(x,y), or @gpc for direct access to Gnuplot"\n')
+
+#********************** End of file <example-gnuplot.py> *********************
diff --git a/doc/examples/extension.py b/doc/examples/extension.py
new file mode 100644
index 0000000..9ac667f
--- /dev/null
+++ b/doc/examples/extension.py
@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+def ${name}_f(self, arg):
+    r""" Short explanation
+    
+    Long explanation, examples
+    
+    """
+    
+    # opts,args = self.parse_options(arg,'rx')
+    # if 'r' in opts: pass
+    
+    
+
+ip.expose_magic("${name}",${name}_f)        
+    
+    
diff --git a/doc/examples/ipython_here_shell_extension.reg b/doc/examples/ipython_here_shell_extension.reg
new file mode 100644
index 0000000..3ed6367
--- /dev/null
+++ b/doc/examples/ipython_here_shell_extension.reg
@@ -0,0 +1,6 @@
+ Windows Registry Editor Version 5.00
+
+[HKEY_CLASSES_ROOT\Directory\shell\IPython here]
+
+[HKEY_CLASSES_ROOT\Directory\shell\IPython here\Command]
+@="cmd.exe /C ipython.py -p sh -i -c \"%cd %1\""
\ No newline at end of file
diff --git a/doc/examples/seteditor.py b/doc/examples/seteditor.py
new file mode 100644
index 0000000..a2cde04
--- /dev/null
+++ b/doc/examples/seteditor.py
@@ -0,0 +1,15 @@
+import os
+
+
+editor = r'q:/opt/np/notepad++.exe'
+
+
+e = os.environ
+
+e['EDITOR'] = editor
+e['VISUAL'] = editor
+
+
+
+
+
diff --git a/doc/ipnb_google_soc.lyx b/doc/ipnb_google_soc.lyx
new file mode 100644
index 0000000..58c9df2
--- /dev/null
+++ b/doc/ipnb_google_soc.lyx
@@ -0,0 +1,645 @@
+#LyX 1.3 created this file. For more info see http://www.lyx.org/
+\lyxformat 221
+\textclass article
+\begin_preamble
+\usepackage{hyperref}
+
+\usepackage{color}
+\definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
+\definecolor{brown}{cmyk}{0,0.75,0.75,0.35}
+
+% Use and configure listings package for nicely formatted code
+\usepackage{listings}
+\lstset{
+  language=Python,
+  basicstyle=\small\ttfamily,
+  commentstyle=\ttfamily\color{blue},
+  stringstyle=\ttfamily\color{brown},
+  showstringspaces=false,
+  breaklines=true,
+  postbreak = \space\dots
+}
+\end_preamble
+\language english
+\inputencoding auto
+\fontscheme palatino
+\graphics default
+\paperfontsize 11
+\spacing single 
+\papersize Default
+\paperpackage a4
+\use_geometry 1
+\use_amsmath 0
+\use_natbib 0
+\use_numerical_citations 0
+\paperorientation portrait
+\leftmargin 1in
+\topmargin 0.9in
+\rightmargin 1in
+\bottommargin 0.9in
+\secnumdepth 3
+\tocdepth 3
+\paragraph_separation skip
+\defskip medskip
+\quotes_language english
+\quotes_times 2
+\papercolumns 1
+\papersides 1
+\paperpagestyle default
+
+\layout Title
+
+Interactive Notebooks for Python
+\newline 
+
+\size small 
+An IPython project for Google's Summer of Code 2005
+\layout Author
+
+Fernando P
+\begin_inset ERT
+status Collapsed
+
+\layout Standard
+
+\backslash 
+'{e}
+\end_inset 
+
+rez
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\family typewriter 
+\size small 
+Fernando.Perez@colorado.edu
+\end_inset 
+
+
+\layout Abstract
+
+This project aims to develop a file format and interactive support for documents
+ which can combine Python code with rich text and embedded graphics.
+ The initial requirements only aim at being able to edit such documents
+ with a normal programming editor, with final rendering to PDF or HTML being
+ done by calling an external program.
+ The editing component would have to be integrated with IPython.
+ 
+\layout Abstract
+
+This document was written by the IPython developer; it is made available
+ to students looking for projects of interest and for inclusion in their
+ application.
+\layout Section
+
+Project overview
+\layout Standard
+
+Python's interactive interpreter is one of the language's most appealing
+ features for certain types of usage, yet the basic shell which ships with
+ the language is very limited.
+ Over the last few years, IPython
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\begin_inset LatexCommand \htmlurl{http://ipython.scipy.org}
+
+\end_inset 
+
+
+\end_inset 
+
+ has become the de facto standard interactive shell in the scientific computing
+ community, and it enjoys wide popularity with general audiences.
+ All the major Linux distributions (Fedora Core via Extras, SUSE, Debian)
+ and OS X (via fink) carry IPython, and Windows users report using it as
+ a viable system shell.
+\layout Standard
+
+However, IPython is currently a command-line only application, based on
+ the readline library and hence with single-line editing capabilities.
+ While this kind of usage is sufficient for many contexts, there are usage
+ cases where integration in a graphical user interface (GUI) is desirable.
+ 
+\layout Standard
+
+In particular, we wish to have an interface where users can execute Python
+ code, input regular text (neither code nor comments) and keep inline graphics,
+ which we will call 
+\emph on 
+Python notebooks
+\emph default 
+.
+ This kind of system is very popular in scientific computing; well known
+ implementations can be found in Mathematica
+\begin_inset ERT
+status Collapsed
+
+\layout Standard
+
+\backslash 
+texttrademark
+\end_inset 
+
+\SpecialChar ~
+
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\begin_inset LatexCommand \htmlurl{http://www.wolfram.com/products/mathematica}
+
+\end_inset 
+
+
+\end_inset 
+
+ and Maple
+\begin_inset ERT
+status Collapsed
+
+\layout Standard
+
+\backslash 
+texttrademark
+\end_inset 
+
+\SpecialChar ~
+
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\begin_inset LatexCommand \htmlurl{http://www.maplesoft.com}
+
+\end_inset 
+
+
+\end_inset 
+
+, among others.
+ However, these are proprietary (and quite expensive) systems aimed at an
+ audience of mathematicians, scientists and engineers.
+\layout Standard
+
+The full-blown implementation of a graphical shell supporting this kind
+ of work model is probably too ambitious for a summer project.
+ Simultaneous support for rich-text editing, embedded graphics and syntax-highli
+ghted code is extremely complex, and likely to require far more effort than
+ can be mustered by an individual developer for a short-term project.
+\layout Standard
+
+This project will thus aim to build the necessary base infrastructure to
+ be able to edit such documents from a plain text editor, and to render
+ them to suitable formats for printing or online distribution, such as HTML,
+ PDF or PostScript.
+ This model follows that for the production of LaTeX documents, which can
+ be edited with any text editor.
+\layout Standard
+
+Such documents would be extremely useful for many audiences beyond scientists:
+ one can use them to produce additionally documented code, to explore a
+ problem with Python and maintain all relevant information in the same place,
+ as a way to distribute enhanced Python-based educational materials, etc.
+\layout Standard
+
+Demand for such a system exists, as evidenced by repeated requests made
+ to me by IPython users over the last few years.
+ Unfortunately IPython is only a spare-time project for me, and I have not
+ had the time to devote to this, despite being convinced of its long term
+ value and wide appeal.
+\layout Standard
+
+If this project is successful, the infrastructure laid out by it will be
+ immediately useful for Python users wishing to maintain `literate' programs
+ which include rich formatting.
+ In addition, this will open the door for the future development of graphical
+ shells which can render such documents in real time: this is exactly the
+ development model successfully followed by the LyX
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\begin_inset LatexCommand \htmlurl{http://www.lyx.org}
+
+\end_inset 
+
+
+\end_inset 
+
+ document processing system.
+\layout Section
+
+Implementation effort
+\layout Subsection
+
+Specific goals
+\layout Standard
+
+This is a brief outline of the main points of this project.
+ The next section provides details on all of them.
+ The student(s) working on the project would need to:
+\layout Enumerate
+
+Make design decisions for the internal file structure to enable valid Python
+ notebooks.
+ 
+\layout Enumerate
+
+Implement the rendering library, capable of processing an input notebook
+ through reST or LaTeX and producing HTML or PDF output, as well as exporting
+ a `pure-code' Python file stripped of all markup calls.
+\layout Enumerate
+
+Study existing programming editor widgets to find the most suitable one
+ for extending with an IPython connector for interactive execution of the
+ notebooks.
+\layout Subsection
+
+Complexity level
+\layout Standard
+
+This project is relatively complicated.
+ While I will gladly assist the student with design and implementation issues,
+ it will require a fair amount of thinking in terms of overall library architect
+ure.
+ The actual implementation does not require any sophisticated concepts,
+ but rather a reasonably broad knowledge of a wide set of topics (markup,
+ interaction with external programs and libraries, namespace tricks to provide
+ runtime changes in the effect of the markup calls, etc.)
+\layout Standard
+
+While raw novices are welcome to try, I suspect that it may be a bit too
+ much for them.
+ Students wanting to apply should keep in mind, if the money is an important
+ consideration, that Google only gives the $4500 reward upon 
+\emph on 
+successful completion
+\emph default 
+ of the project.
+ So don't bite more than you can chew.
+ Obviously if this doesn't matter, anyone is welcome to participate, since
+ the project can be a very interesting learning experience, and it will
+ provide a genuinely useful tool for many.
+\layout Section
+
+Technical details
+\layout Subsection
+
+The files
+\layout Standard
+
+A basic requirement of this project will be that the Python notebooks shall
+ be valid Python source files, typically with a 
+\family typewriter 
+.py
+\family default 
+ extension.
+ A renderer program can be used to process the markup calls in them and
+ generate output.
+ If run at a regular command line, these files should execute like normal
+ Python files.
+ But when run via a special rendering script, the result should be a properly
+ formatted file.
+ Output formats could be PDF or HTML depending on user-supplied options.
+\layout Standard
+
+A reST markup mode should be implemented, as reST is already widely used
+ in the Python community and is a very simple format to write.
+ The following is a sketch of what such files could look like using reST
+ markup:
+\layout Standard
+
+
+\begin_inset ERT
+status Open
+
+\layout Standard
+
+\backslash 
+lstinputlisting{nbexample.py}
+\end_inset 
+
+
+\layout Standard
+
+Additionally, a LaTeX markup mode should also be implemented.
+ Here's a mockup example of what code using the LaTeX mode could look like.
+\layout Standard
+
+
+\begin_inset ERT
+status Open
+
+\layout Standard
+
+\backslash 
+lstinputlisting{nbexample_latex.py}
+\end_inset 
+
+
+\layout Standard
+
+At this point, it must be noted that the code above is simply a sketch of
+ these ideas, not a finalized design.
+ An important part of this project will be to think about what the best
+ API and structure for this problem should be.
+\layout Subsection
+
+From notebooks to PDF, HTML or Python
+\layout Standard
+
+Once a clean API for markup has been specified, converters will be written
+ to take a python source file which uses notebook constructs, and generate
+ final output in printable formats, such as HTML or PDF.
+ For example, if 
+\family typewriter 
+nbfile.py
+\family default 
+ is a python notebook, then
+\layout LyX-Code
+
+$ pynb --export=pdf nbfile.py
+\layout Standard
+
+should produce 
+\family typewriter 
+nbfile.pdf
+\family default 
+, while
+\layout LyX-Code
+
+$ pynb --export=html nbfile.py
+\layout Standard
+
+would produce an HTML version.
+ The actual rendering will be done by calling appropriate utilities, such
+ as the reST toolchain or LaTeX, depending on the markup used by the file.
+\layout Standard
+
+Additionally, while the notebooks will be valid Python files, if executed
+ on their own, all the markup calls will still return their results, which
+ are not really needed when the file is being treated as pure code.
+ For this reason, a module to execute these files turning the markup calls
+ into no-ops should be written.
+ Using Python 2.4's -m switch, one can then use something like
+\layout LyX-Code
+
+$ python -m notebook nbfile.py
+\layout Standard
+
+and the notebook file 
+\family typewriter 
+nbfile.py
+\family default 
+ will be executed without any overhead introduced by the markup (other than
+ making calls to functions which return immediately).
+ Finally, an exporter to clean code can be trivially implemented, so that:
+\layout LyX-Code
+
+$ pynb --export=python nbfile.py nbcode.py
+\layout Standard
+
+would export only the code in 
+\family typewriter 
+nbfile.py
+\family default 
+ to 
+\family typewriter 
+nbcode.py
+\family default 
+, removing the markup completely.
+ This can be used to generate final production versions of large modules
+ implemented as notebooks, if one wants to eliminate the markup overhead.
+\layout Subsection
+
+The editing environment
+\layout Standard
+
+The first and most important part of the project should be the definition
+ of a clean API and the implementation of the exporter modules as indicated
+ above.
+ Ultimately, such files can be developed using any text editor, since they
+ are nothing more than regular Python code.
+\layout Standard
+
+But once these goals are reached, further integration with an editor will
+ be done, without the need for a full-blown GUI shell.
+ In fact, already today the (X)Emacs editors can provide for interactive
+ usage of such files.
+ Using python-mode in (X)Emacs, one can pass highlighted regions of a file
+ for execution to an underlying python process, and the results are printed
+ in the python window.
+ With recent versions of python-mode, IPython can be used instead of the
+ plain python interpreter, so that IPython's extended interactive capabilities
+ become available within (X)Emacs (improved tracebacks, automatic debugger
+ integration, variable information, easy filesystem access to Python, etc).
+\layout Standard
+
+But even with IPython integration, the usage within (X)Emacs is not ideal
+ for a notebook environment, since the python process buffer is separate
+ from the python file.
+ Therefore, the next stage of the project will be to enable tighter integration
+ between the editing and execution environments.
+ The basic idea is to provide an easy way to mark regions of the file to
+ be executed interactively, and to have the output inserted automatically
+ into the file.
+ The following listing is a mockup of what the resulting file could look
+ like
+\layout Standard
+
+
+\begin_inset ERT
+status Open
+
+\layout Standard
+
+\backslash 
+lstinputlisting{nbexample_output.py}
+\end_inset 
+
+
+\layout Standard
+
+Basically, the editor will execute 
+\family typewriter 
+add(2,3)
+\family default 
+ and insert the string representation of the output into the file, so it
+ can be used for rendering later.
+ 
+\layout Section
+
+Available resources
+\layout Standard
+
+IPython currently has all the necessary infrastructure for code execution,
+ albeit in a rather messy code base.
+ Most I/O is already abstracted out, a necessary condition for embedding
+ in a GUI (since you are not writing to stdout/err but to the GUI's text
+ area).
+ 
+\layout Standard
+
+For interaction with an editor, it will be necessary to identify a good
+ programming editor with a Python-compatible license, which can be extended
+ to communicate with the underlying IPython engine.
+ IDLE, the Tk-based IDE which ships with Python, should obviously be considered.
+ The Scintilla editing component
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\begin_inset LatexCommand \htmlurl{http://www.scintilla.org}
+
+\end_inset 
+
+
+\end_inset 
+
+ may also be a viable candidate.
+ 
+\layout Standard
+
+It will also be interesting to look at the LyX editor
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\begin_inset LatexCommand \htmlurl{http://www.lyx.org}
+
+\end_inset 
+
+
+\end_inset 
+
+, which already offers a Python client
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\begin_inset LatexCommand \htmlurl{http://wiki.lyx.org/Tools/PyClient}
+
+\end_inset 
+
+
+\end_inset 
+
+.
+ Since LyX has very sophisticated LaTeX support, this is a very interesting
+ direction to consider for the future (though LyX makes a poor programming
+ editor).
+\layout Section
+
+Support offered to the students
+\layout Standard
+
+The IPython project already has an established Open Source infrastructure,
+ including CVS repositories, a bug tracker and mailing lists.
+ As the main author and sole maintainer of IPython, I will personally assist
+ the student(s) funded with architectural and design guidance, preferably
+ on the public development mailing list.
+ I expect them to start working by submitting patches until they show, by
+ the quality of their work, that they can be granted CVS write access.
+ I expect most actual implementation work to be done by the students, though
+ I will provide assistance if they need it with a specific technical issue.
+\layout Standard
+
+If more than one applicant is accepted to work on this project, there is
+ more than enough work to be done which can be coordinated between them.
+\layout Section
+
+Licensing and copyright
+\layout Standard
+
+IPython is licensed under BSD terms, and copyright of all sources rests
+ with the original authors of the core modules.
+ Over the years, all external contributions have been small enough patches
+ that they have been simply folded into the main source tree without additional
+ copyright attributions, though explicit credit has always been given to
+ all contributors.
+\layout Standard
+
+I expect the students participating in this project to contribute enough
+ standalone code that they can retain the copyright to it if they so desire,
+ as long as they accept all their work to be licensed under BSD terms.
+\layout Section
+
+Acknowledgements
+\layout Standard
+
+I'd like to thank John D.
+ Hunter, the author of matplotlib
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\begin_inset LatexCommand \htmlurl{http://matplotlib.sf.net}
+
+\end_inset 
+
+
+\end_inset 
+
+, for lengthy discussions which helped clarify much of this project.
+ In particular, the important decision of embedding the notebook markup
+ calls in true Python functions instead of specially-tagged strings or comments
+ was an idea I thank him for pushing hard enough to convince me of using.
+ 
+\layout Standard
+
+My conversations with Brian Granger, the author of PyXG
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\begin_inset LatexCommand \htmlurl{http://hammonds.scu.edu/~classes/pyxg.html}
+
+\end_inset 
+
+
+\end_inset 
+
+ and braid
+\begin_inset Foot
+collapsed true
+
+\layout Standard
+
+
+\begin_inset LatexCommand \htmlurl{http://hammonds.scu.edu/~classes/braid.html}
+
+\end_inset 
+
+
+\end_inset 
+
+, have also been very useful in clarifying details of the necessary underlying
+ infrastructure and future evolution of IPython for this kind of system.
+\layout Standard
+
+Thank you also to the IPython users who have, in the past, discussed this
+ topic with me either in private or on the IPython or Scipy lists.
+\the_end
diff --git a/doc/ipython.1 b/doc/ipython.1
new file mode 100644
index 0000000..1c71480
--- /dev/null
+++ b/doc/ipython.1
@@ -0,0 +1,391 @@
+.\"                                      Hey, EMACS: -*- nroff -*-
+.\" First parameter, NAME, should be all caps
+.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
+.\" other parameters are allowed: see man(7), man(1)
+.TH IPYTHON 1 "November 30, 2004"
+.\" Please adjust this date whenever revising the manpage.
+.\"
+.\" Some roff macros, for reference:
+.\" .nh        disable hyphenation
+.\" .hy        enable hyphenation
+.\" .ad l      left justify
+.\" .ad b      justify to both left and right margins
+.\" .nf        disable filling
+.\" .fi        enable filling
+.\" .br        insert line break
+.\" .sp <n>    insert n+1 empty lines
+.\" for manpage-specific macros, see man(7) and groff_man(7)
+.\" .SH        section heading
+.\" .SS        secondary section heading
+.\"
+.\"
+.\" To preview this page as plain text: nroff -man ipython.1
+.\"
+.SH NAME
+ipython \- An Enhanced Interactive Python
+.SH SYNOPSIS
+.B ipython
+.RI [ options ] " files" ...
+.SH DESCRIPTION
+An interactive Python shell with automatic history (input and output),
+dynamic object introspection, easier configuration, command
+completion, access to the system shell, integration with numerical and
+scientific computing tools, and more.
+.SH SPECIAL THREADING OPTIONS
+The following special options are ONLY valid at the beginning of the command
+line, and not later.  This is because they control the initialization of
+ipython itself, before the normal option-handling mechanism is active.
+.TP
+.B \-gthread, \-qthread, \-q4thread, \-wthread, \-pylab
+Only ONE of these can be given, and it can only be given as the first option
+passed to IPython (it will have no effect in any other position).  They provide
+threading support for the GTK, QT3, QT4 and WXWidgets toolkits, and for the
+matplotlib library.
+.br
+.sp 1
+With any of the first four options, IPython starts running a separate thread
+for the graphical toolkit's operation, so that you can open and control
+graphical elements from within an IPython command line, without blocking.  All
+four provide essentially the same functionality, respectively for GTK, QT3, QT4
+and WXWidgets (via their Python interfaces).
+.br
+.sp 1
+Note that with \-wthread, you can additionally use the \-wxversion option to
+request a specific version of wx to be used.  This requires that you have the
+'wxversion' Python module installed, which is part of recent wxPython
+distributions.
+.br
+.sp 1
+If \-pylab is given, IPython loads special support for the matplotlib library
+(http://matplotlib.sourceforge.net), allowing interactive usage of any of its
+backends as defined in the user's .matplotlibrc file.  It automatically
+activates GTK, QT or WX threading for IPyhton if the choice of matplotlib
+backend requires it.  It also modifies the %run command to correctly execute
+(without blocking) any matplotlib-based script which calls show() at the end.
+.TP
+.B \-tk
+The \-g/q/q4/wthread options, and \-pylab (if matplotlib is configured to use
+GTK, QT or WX), will normally block Tk graphical interfaces.  This means that
+when GTK, QT or WX threading is active, any attempt to open a Tk GUI will
+result in a dead window, and possibly cause the Python interpreter to crash.
+An extra option, \-tk, is available to address this issue.  It can ONLY be
+given as a SECOND option after any of the above (\-gthread, \-qthread,
+\-wthread or \-pylab).
+.br
+.sp 1
+If \-tk is given, IPython will try to coordinate Tk threading with GTK, QT or
+WX.  This is however potentially unreliable, and you will have to test on your
+platform and Python configuration to determine whether it works for you.
+Debian users have reported success, apparently due to the fact that Debian
+builds all of Tcl, Tk, Tkinter and Python with pthreads support.  Under other
+Linux environments (such as Fedora Core 2), this option has caused random
+crashes and lockups of the Python interpreter.  Under other operating systems
+(Mac OSX and Windows), you'll need to try it to find out, since currently no
+user reports are available.
+.br
+.sp 1
+There is unfortunately no way for IPython to determine at runtime whether \-tk
+will work reliably or not, so you will need to do some experiments before
+relying on it for regular work.
+.
+.SH REGULAR OPTIONS
+After the above threading options have been given, regular options can follow
+in any order.  All options can be abbreviated to their shortest non-ambiguous
+form and are case-sensitive.  One or two dashes can be used.  Some options
+have an alternate short form, indicated after a |.
+.br
+.sp 1
+Most options can also be set from your ipythonrc configuration file.
+See the provided examples for assistance.  Options given on the
+commandline override the values set in the ipythonrc file.
+.br
+.sp 1
+All options with a [no] prepended can be specified in negated form
+(\-nooption instead of \-option) to turn the feature off.
+.TP
+.B \-h, \-\-help
+Show summary of options.
+.TP
+.B \-autocall <val>
+Make IPython automatically call any callable object even if you didn't type
+explicit parentheses. For example, 'str 43' becomes
+'str(43)' automatically.  The value can be '0' to disable the
+feature, '1' for 'smart' autocall, where it is not applied if
+there are no more arguments on the line, and '2' for 'full'
+autocall, where all callable objects are automatically called
+(even if no arguments are present).  The default is '1'.
+.TP
+.B \-[no]autoindent
+Turn automatic indentation on/off.
+.TP
+.B \-[no]automagic
+Make magic commands automatic (without needing their first character
+to be %).  Type %magic at the IPython prompt for more information.
+.TP
+.B \-[no]autoedit_syntax
+When a syntax error occurs after editing a file, automatically open the file
+to the trouble causing line for convenient fixing.
+.TP
+.B \-[no]banner
+Print the intial information banner (default on).
+.TP
+.B \-c <command>
+Execute the given command string, and set sys.argv to ['c'].  This is similar
+to the \-c option in the normal Python interpreter.
+.TP
+.B \-cache_size|cs <n>
+Size of the output cache (maximum number of entries to hold in
+memory).  The default is 1000, you can change it permanently in your
+config file.  Setting it to 0 completely disables the caching system,
+and the minimum value accepted is 20 (if you provide a value less than
+20, it is reset to 0 and a warning is issued).  This limit is defined
+because otherwise you'll spend more time re-flushing a too small cache
+than working.
+.TP
+.B \-classic|cl
+Gives IPython a similar feel to the classic Python prompt.
+.TP
+.B \-colors <scheme>
+Color scheme for prompts and exception reporting.  Currently
+implemented: NoColor, Linux, and LightBG.
+.TP
+.B \-[no]color_info
+IPython can display information about objects via a set of functions,
+and optionally can use colors for this, syntax highlighting source
+code and various other elements.  However, because this information is
+passed through a pager (like 'less') and many pagers get confused with
+color codes, this option is off by default.  You can test it and turn
+it on permanently in your ipythonrc file if it works for you.  As a
+reference, the 'less' pager supplied with Mandrake 8.2 works ok, but
+that in RedHat 7.2 doesn't.
+.br
+.sp 1
+Test it and turn it on permanently if it works with your system.  The
+magic function @color_info allows you to toggle this interactively for
+testing.
+.TP
+.B \-[no]confirm_exit
+Set to confirm when you try to exit IPython with an EOF (Control-D in
+Unix, Control-Z/Enter in Windows). Note that using the magic functions
+@Exit or @Quit you can force a direct exit, bypassing any
+confirmation.
+.TP
+.B \-[no]debug
+Show information about the loading process. Very useful to pin down
+problems with your configuration files or to get details about session
+restores.
+.TP
+.B \-[no]deep_reload
+IPython can use the deep_reload module which reloads changes in
+modules recursively (it replaces the reload() function, so you don't
+need to change anything to use it). deep_reload() forces a full reload
+of modules whose code may have changed, which the default reload()
+function does not.
+.br
+.sp 1
+When deep_reload is off, IPython will use the normal reload(), but
+deep_reload will still be available as dreload(). This feature is off
+by default [which means that you have both normal reload() and
+dreload()].
+.TP
+.B \-editor <name>
+Which editor to use with the @edit command. By default, IPython will
+honor your EDITOR environment variable (if not set, vi is the Unix
+default and notepad the Windows one). Since this editor is invoked on
+the fly by IPython and is meant for editing small code snippets, you
+may want to use a small, lightweight editor here (in case your default
+EDITOR is something like Emacs).
+.TP
+.B \-ipythondir <name>
+The name of your IPython configuration directory IPYTHONDIR.  This can
+also be specified through the environment variable IPYTHONDIR.
+.TP
+.B \-log|l
+Generate a log file of all input. The file is named ipython_log.py in your
+current directory (which prevents logs from multiple IPython sessions from
+trampling each other). You can use this to later restore a session by loading
+your logfile as a file to be executed with option -logplay (see below).
+.TP
+.B \-logfile|lf
+Specify the name of your logfile.
+.TP
+.B \-logplay|lp
+Replay a previous log. For restoring a session as close as possible to
+the state you left it in, use this option (don't just run the
+logfile). With \-logplay, IPython will try to reconstruct the previous
+working environment in full, not just execute the commands in the
+logfile.
+.br
+.sh 1
+When a session is restored, logging is automatically turned on again
+with the name of the logfile it was invoked with (it is read from the
+log header). So once you've turned logging on for a session, you can
+quit IPython and reload it as many times as you want and it will
+continue to log its history and restore from the beginning every time.
+.br
+.sp 1
+Caveats: there are limitations in this option. The history variables
+_i*,_* and _dh don't get restored properly. In the future we will try
+to implement full session saving by writing and retrieving a
+'snapshot' of the memory state of IPython. But our first attempts
+failed because of inherent limitations of Python's Pickle module, so
+this may have to wait.
+.TP
+.B \-[no]messages
+Print messages which IPython collects about its startup process
+(default on).
+.TP
+.B \-[no]pdb
+Automatically call the pdb debugger after every uncaught exception. If
+you are used to debugging using pdb, this puts you automatically
+inside of it after any call (either in IPython or in code called by
+it) which triggers an exception which goes uncaught.
+.TP
+.B \-[no]pprint
+IPython can optionally use the pprint (pretty printer) module for
+displaying results. pprint tends to give a nicer display of nested
+data structures. If you like it, you can turn it on permanently in
+your config file (default off).
+.TP
+.B \-profile|p <name>
+Assume that your config file is ipythonrc-<name> (looks in current dir
+first, then in IPYTHONDIR). This is a quick way to keep and load
+multiple config files for different tasks, especially if you use the
+include option of config files. You can keep a basic
+IPYTHONDIR/ipythonrc file and then have other 'profiles' which include
+this one and load extra things for particular tasks. For example:
+.br
+.sp 1
+1) $HOME/.ipython/ipythonrc : load basic things you always want.
+.br
+2) $HOME/.ipython/ipythonrc-math : load (1) and basic math-related
+modules.
+.br
+3) $HOME/.ipython/ipythonrc-numeric : load (1) and Numeric and
+plotting modules.
+.br
+.sp 1
+Since it is possible to create an endless loop by having circular file
+inclusions, IPython will stop if it reaches 15 recursive inclusions.
+.TP
+.B \-prompt_in1|pi1 <string>
+Specify the string used for input prompts. Note that if you are using
+numbered prompts, the number is represented with a '\\#' in the
+string. Don't forget to quote strings with spaces embedded in
+them. Default: 'In [\\#]: '.
+.br
+.sp 1
+Most bash-like escapes can be used to customize IPython's prompts, as well as
+a few additional ones which are IPython-specific.  All valid prompt escapes
+are described in detail in the Customization section of the IPython HTML/PDF
+manual.
+.TP
+.B \-prompt_in2|pi2 <string>
+Similar to the previous option, but used for the continuation prompts. The
+special sequence '\\D' is similar to '\\#', but with all digits replaced dots
+(so you can have your continuation prompt aligned with your input
+prompt). Default: '   .\\D.: ' (note three spaces at the start for alignment
+with 'In [\\#]').
+.TP
+.B \-prompt_out|po <string>
+String used for output prompts, also uses numbers like prompt_in1.
+Default: 'Out[\\#]:'.
+.TP
+.B \-quick
+Start in bare bones mode (no config file loaded).
+.TP
+.B \-rcfile <name>
+Name of your IPython resource configuration file.  normally IPython
+loads ipythonrc (from current directory) or IPYTHONDIR/ipythonrc.  If
+the loading of your config file fails, IPython starts with a bare
+bones configuration (no modules loaded at all).
+.TP
+.B \-[no]readline
+Use the readline library, which is needed to support name completion
+and command history, among other things. It is enabled by default, but
+may cause problems for users of X/Emacs in Python comint or shell
+buffers.
+.br
+.sp 1
+Note that emacs 'eterm' buffers (opened with M-x term) support
+IPython's readline and syntax coloring fine, only 'emacs' (M-x shell
+and C-c !)  buffers do not.
+.TP
+.B \-screen_length|sl <n>
+Number of lines of your screen.  This is used to control printing of
+very long strings.  Strings longer than this number of lines will be
+sent through a pager instead of directly printed.
+.br
+.sp 1
+The default value for this is 0, which means IPython will auto-detect
+your screen size every time it needs to print certain potentially long
+strings (this doesn't change the behavior of the 'print' keyword, it's
+only triggered internally). If for some reason this isn't working well
+(it needs curses support), specify it yourself. Otherwise don't change
+the default.
+.TP
+.B \-separate_in|si <string>
+Separator before input prompts.  Default '\n'.
+.TP
+.B \-separate_out|so <string>
+Separator before output prompts.  Default: 0 (nothing).
+.TP
+.B \-separate_out2|so2 <string>
+Separator after output prompts.  Default: 0 (nothing).
+.TP
+.B \-nosep
+Shorthand for '\-separate_in 0 \-separate_out 0 \-separate_out2 0'.
+Simply removes all input/output separators.
+.TP
+.B \-upgrade
+Allows you to upgrade your IPYTHONDIR configuration when you install a
+new version of IPython.  Since new versions may include new command
+lines options or example files, this copies updated ipythonrc-type
+files.  However, it backs up (with a .old extension) all files which
+it overwrites so that you can merge back any custimizations you might
+have in your personal files.
+.TP
+.B \-Version
+Print version information and exit.
+.TP
+.B -wxversion <string>
+Select a specific version of wxPython (used in conjunction with
+\-wthread). Requires the wxversion module, part of recent wxPython
+distributions.
+.TP
+.B \-xmode <modename>
+Mode for exception reporting.  The valid modes are Plain, Context, and
+Verbose.
+.br
+.sp 1
+\- Plain: similar to python's normal traceback printing.
+.br
+.sp 1
+\- Context: prints 5 lines of context source code around each line in the
+traceback.
+.br
+.sp 1
+\- Verbose: similar to Context, but additionally 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).
+.
+.SH EMBEDDING
+It is possible to start an IPython instance inside your own Python
+programs.  In the documentation example files there are some
+illustrations on how to do this.
+.br
+.sp 1
+This feature allows you to evalutate dynamically the state of your
+code, operate with your variables, analyze them, etc.  Note however
+that any changes you make to values while in the shell do NOT
+propagate back to the running code, so it is safe to modify your
+values because you won't break your code in bizarre ways by doing so.
+.SH AUTHOR
+IPython was written by Fernando Perez <fperez@colorado.edu>, based on earlier
+code by Janko Hauser <jh@comunit.de> and Nathaniel Gray
+<n8gray@caltech.edu>.  This manual page was written by Jack Moffitt
+<jack@xiph.org>, for the Debian project (but may be used by others).
diff --git a/doc/ipython.el b/doc/ipython.el
new file mode 100644
index 0000000..4dc714c
--- /dev/null
+++ b/doc/ipython.el
@@ -0,0 +1,483 @@
+;;; ipython.el --- Adds support for IPython to python-mode.el
+
+;; Copyright (C) 2002, 2003, 2004, 2005 Alexander Schmolck
+;; Author:        Alexander Schmolck
+;; Keywords:      ipython python languages oop
+;; URL:           http://ipython.scipy.org
+;; Compatibility: Emacs21, XEmacs21
+;; FIXME: #$@! INPUT RING
+(defconst ipython-version "$Revision: 2927 $"
+  "VC version number.")
+
+;;; Commentary 
+;; This library makes all the functionality python-mode has when running with
+;; the normal python-interpreter available for ipython, too. It also enables a
+;; persistent py-shell command history across sessions (if you exit python
+;; with C-d in py-shell) and defines the command `ipython-to-doctest', which
+;; can be used to convert bits of a ipython session into something that can be
+;; used for doctests. To install, put this file somewhere in your emacs
+;; `load-path' [1] and add the following line to your ~/.emacs file (the first
+;; line only needed if the default (``"ipython"``) is wrong)::
+;;
+;;   (setq ipython-command "/SOME-PATH/ipython")
+;;   (require 'ipython)
+;;
+;; Ipython will be set as the default python shell, but only if the ipython
+;; executable is in the path. For ipython sessions autocompletion with <tab>
+;; is also enabled (experimental feature!). Please also note that all the
+;; terminal functions in py-shell are handled by emacs's comint, **not** by
+;; (i)python, so importing readline etc. will have 0 effect.
+;;
+;; To start an interactive ipython session run `py-shell' with ``M-x py-shell``
+;; (or the default keybinding ``C-c C-!``).
+;;
+;; NOTE: This mode is currently somewhat alpha and although I hope that it
+;; will work fine for most cases, doing certain things (like the
+;; autocompletion and a decent scheme to switch between python interpreters)
+;; properly will also require changes to ipython that will likely have to wait
+;; for a larger rewrite scheduled some time in the future.
+;; 
+;; Also note that you currently NEED THE CVS VERSION OF PYTHON.EL.
+;;
+;; Further note that I don't know whether this runs under windows or not and
+;; that if it doesn't I can't really help much, not being afflicted myself.
+;;
+;;
+;; Hints for effective usage
+;; -------------------------
+;;
+;; - IMO the best feature by far of the ipython/emacs combo is how much easier it
+;;   makes it to find and fix bugs thanks to the ``%pdb on``/ pdbtrack combo. Try
+;;   it: first in the ipython to shell do ``%pdb on`` then do something that will
+;;   raise an exception (FIXME nice example) -- and be amazed how easy it is to
+;;   inspect the live objects in each stack frames and to jump to the
+;;   corresponding sourcecode locations as you walk up and down the stack trace
+;;   (even without ``%pdb on`` you can always use ``C-c -`` (`py-up-exception')
+;;   to jump to the corresponding source code locations).
+;;
+;; - emacs gives you much more powerful commandline editing and output searching
+;;   capabilities than ipython-standalone -- isearch is your friend if you
+;;   quickly want to print 'DEBUG ...' to stdout out etc.
+;;
+;; - This is not really specific to ipython, but for more convenient history
+;;   access you might want to add something like the following to *the beggining*
+;;   of your ``.emacs`` (if you want behavior that's more similar to stand-alone
+;;   ipython, you can change ``meta p`` etc. for ``control p``)::
+;;
+;;         (require 'comint)
+;;         (define-key comint-mode-map [(meta p)] 
+;;           'comint-previous-matching-input-from-input)
+;;         (define-key comint-mode-map [(meta n)] 
+;;           'comint-next-matching-input-from-input)
+;;         (define-key comint-mode-map [(control meta n)]
+;;            'comint-next-input)
+;;         (define-key comint-mode-map [(control meta p)]
+;;            'comint-previous-input)
+;;
+;; - Be aware that if you customize py-python-command previously, this value
+;;   will override what ipython.el does (because loading the customization
+;;   variables comes later).
+;;
+;; Please send comments and feedback to the ipython-list
+;; (<ipython-user@scipy.net>) where I (a.s.) or someone else will try to
+;; answer them (it helps if you specify your emacs version, OS etc; 
+;; familiarity with <http://www.catb.org/~esr/faqs/smart-questions.html> might
+;; speed up things further).
+;;
+;; Footnotes:
+;;
+;;     [1] If you don't know what `load-path' is, C-h v load-path will tell
+;;     you; if required you can also add a new directory. So assuming that
+;;     ipython.el resides in ~/el/, put this in your emacs:
+;;
+;;
+;;           (add-to-list 'load-path "~/el")
+;;           (setq ipython-command "/some-path/ipython")
+;;           (require 'ipython)
+;;
+;;
+;;
+;;
+;; TODO:
+;;      - do autocompletion properly
+;;      - implement a proper switching between python interpreters
+;;
+;; BUGS:
+;;      - neither::
+;;
+;;         (py-shell "-c print 'FOOBAR'")
+;;       
+;;        nor::
+;;       
+;;         (let ((py-python-command-args (append py-python-command-args 
+;;                                              '("-c" "print 'FOOBAR'"))))
+;;           (py-shell))
+;;
+;;        seem to print anything as they should
+;;
+;;      - look into init priority issues with `py-python-command' (if it's set
+;;        via custom)
+
+
+;;; Code
+(require 'cl)
+(require 'shell)
+(require 'executable)
+(require 'ansi-color)
+
+(defcustom ipython-command "ipython"
+  "*Shell command used to start ipython."
+  :type 'string 
+  :group 'python)
+
+;; Users can set this to nil
+(defvar py-shell-initial-switch-buffers t
+  "If nil, don't switch to the *Python* buffer on the first call to
+  `py-shell'.")
+
+(defvar ipython-backup-of-py-python-command nil
+  "HACK")
+
+  
+(defvar ipython-de-input-prompt-regexp "\\(?:
+In \\[[0-9]+\\]: *.*
+----+> \\(.*
+\\)[\n]?\\)\\|\\(?:
+In \\[[0-9]+\\]: *\\(.*
+\\)\\)\\|^[ ]\\{3\\}[.]\\{3,\\}: *\\(.*
+\\)"
+  "A regular expression to match the IPython input prompt and the python
+command after it. The first match group is for a command that is rewritten,
+the second for a 'normal' command, and the third for a multiline command.")
+(defvar ipython-de-output-prompt-regexp "^Out\\[[0-9]+\\]: "
+  "A regular expression to match the output prompt of IPython.")
+
+
+(if (not (executable-find ipython-command))
+    (message (format "Can't find executable %s - ipython.el *NOT* activated!!!"
+                     ipython-command))
+    ;; XXX load python-mode, so that we can screw around with its variables
+    ;; this has the disadvantage that python-mode is loaded even if no
+    ;; python-file is ever edited etc. but it means that `py-shell' works
+    ;; without loading a python-file first. Obviously screwing around with
+    ;; python-mode's variables like this is a mess, but well.
+    (require 'python-mode)
+    ;; turn on ansi colors for ipython and activate completion
+    (defun ipython-shell-hook ()
+      ;; the following is to synchronize dir-changes
+      (make-local-variable 'shell-dirstack)
+      (setq shell-dirstack nil)
+      (make-local-variable 'shell-last-dir)
+      (setq shell-last-dir nil)
+      (make-local-variable 'shell-dirtrackp)
+      (setq shell-dirtrackp t)
+      (add-hook 'comint-input-filter-functions 'shell-directory-tracker nil t)
+
+      (ansi-color-for-comint-mode-on)
+      (define-key py-shell-map [tab] 'ipython-complete)
+      ;; Add this so that tab-completion works both in X11 frames and inside
+      ;; terminals (such as when emacs is called with -nw).
+      (define-key py-shell-map "\t" 'ipython-complete)
+      ;;XXX this is really just a cheap hack, it only completes symbols in the
+      ;;interactive session -- useful nonetheless.
+      (define-key py-mode-map [(meta tab)] 'ipython-complete)
+      
+      )
+    (add-hook 'py-shell-hook 'ipython-shell-hook)
+    ;; Regular expression that describes tracebacks for IPython in context and
+    ;; verbose mode. 
+  
+    ;;Adapt python-mode settings for ipython.
+    ;; (this works for %xmode 'verbose' or 'context')
+
+    ;; XXX putative regexps for syntax errors; unfortunately the 
+    ;;     current python-mode traceback-line-re scheme is too primitive,
+    ;;     so it's either matching syntax errors, *or* everything else
+    ;;     (XXX: should ask Fernando for a change)
+    ;;"^   File \"\\(.*?\\)\", line \\([0-9]+\\).*\n.*\n.*\nSyntaxError:"
+    ;;^   File \"\\(.*?\\)\", line \\([0-9]+\\)"
+
+    (setq py-traceback-line-re
+          "\\(^[^\t >].+?\\.py\\).*\n   +[0-9]+[^\00]*?\n-+> \\([0-9]+\\)+")
+
+    
+    ;; Recognize the ipython pdb, whose prompt is 'ipdb>' or  'ipydb>'
+    ;;instead of '(Pdb)'
+    (setq py-pdbtrack-input-prompt "\n[(<]*[Ii]?[Pp]y?db[>)]+ ")
+    (setq pydb-pydbtrack-input-prompt "\n[(]*ipydb[>)]+ ")
+    
+    (setq py-shell-input-prompt-1-regexp "^In \\[[0-9]+\\]: *"
+          py-shell-input-prompt-2-regexp "^   [.][.][.]+: *" )
+    ;; select a suitable color-scheme
+    (unless (member "-colors" py-python-command-args)
+      (setq py-python-command-args 
+            (nconc py-python-command-args 
+                   (list "-colors"
+                         (cond  
+                           ((eq frame-background-mode 'dark)
+                            "Linux")
+                           ((eq frame-background-mode 'light)
+                            "LightBG")
+                           (t ; default (backg-mode isn't always set by XEmacs)
+                            "LightBG"))))))
+    (unless (equal ipython-backup-of-py-python-command py-python-command)
+      (setq ipython-backup-of-py-python-command py-python-command))
+    (setq py-python-command ipython-command))
+
+
+;; MODIFY py-shell so that it loads the editing history
+(defadvice py-shell (around py-shell-with-history)
+  "Add persistent command-history support (in
+$PYTHONHISTORY (or \"~/.ipython/history\", if we use IPython)). Also, if
+`py-shell-initial-switch-buffers' is nil, it only switches to *Python* if that
+buffer already exists."
+  (if (comint-check-proc "*Python*")
+      ad-do-it
+    (setq comint-input-ring-file-name
+          (if (string-equal py-python-command ipython-command)
+              (concat (or (getenv "IPYTHONDIR") "~/.ipython") "/history")
+            (or (getenv "PYTHONHISTORY") "~/.python-history.py")))
+    (comint-read-input-ring t)
+    (let ((buf (current-buffer)))
+      ad-do-it
+      (unless py-shell-initial-switch-buffers
+        (switch-to-buffer-other-window buf)))))
+(ad-activate 'py-shell)
+;; (defadvice py-execute-region (before py-execute-buffer-ensure-process)
+;;   "HACK: test that ipython is already running before executing something.
+;;   Doing this properly seems not worth the bother (unless people actually
+;;   request it)."
+;; (unless (comint-check-proc "*Python*")
+;;     (error "Sorry you have to first do M-x py-shell to send something to ipython.")))
+;; (ad-activate 'py-execute-region)
+
+(defadvice py-execute-region (around py-execute-buffer-ensure-process)
+  "HACK: if `py-shell' is not active or ASYNC is explicitly desired, fall back
+  to python instead of ipython." 
+  (let ((py-which-shell (if (and (comint-check-proc "*Python*") (not async))
+			    py-python-command
+			  ipython-backup-of-py-python-command)))
+    ad-do-it))
+(ad-activate 'py-execute-region)
+
+(defun ipython-to-doctest (start end)
+  "Transform a cut-and-pasted bit from an IPython session into something that
+looks like it came from a normal interactive python session, so that it can
+be used in doctests. Example:
+
+
+    In [1]: import sys
+    
+    In [2]: sys.stdout.write 'Hi!\n'
+    ------> sys.stdout.write ('Hi!\n')
+    Hi!
+    
+    In [3]: 3 + 4
+    Out[3]: 7
+    
+gets converted to:
+
+    >>> import sys
+    >>> sys.stdout.write ('Hi!\n')
+    Hi!
+    >>> 3 + 4
+    7
+
+"
+  (interactive "*r\n")
+  ;(message (format "###DEBUG s:%de:%d" start end))
+  (save-excursion
+    (save-match-data
+      ;; replace ``In [3]: bla`` with ``>>> bla`` and 
+      ;;         ``... :   bla`` with ``...    bla``
+      (goto-char start)
+      (while (re-search-forward ipython-de-input-prompt-regexp end t)
+        ;(message "finding 1")
+        (cond ((match-string 3)         ;continued
+               (replace-match "... \\3" t nil))
+              (t
+               (replace-match ">>> \\1\\2" t nil))))
+      ;; replace ``
+      (goto-char start)
+      (while (re-search-forward ipython-de-output-prompt-regexp end t)
+        (replace-match "" t nil)))))
+
+(defvar ipython-completion-command-string 
+  "print ';'.join(__IP.Completer.all_completions('%s')) #PYTHON-MODE SILENT\n"
+  "The string send to ipython to query for all possible completions")
+
+
+;; xemacs doesn't have `comint-preoutput-filter-functions' so we'll try the
+;; following wonderful hack to work around this case
+(if (featurep 'xemacs)
+    ;;xemacs
+    (defun ipython-complete ()
+      "Try to complete the python symbol before point. Only knows about the stuff
+in the current *Python* session."
+      (interactive)
+      (let* ((ugly-return nil)
+             (sep ";")
+             (python-process (or (get-buffer-process (current-buffer))
+                                 ;XXX hack for .py buffers
+                                 (get-process py-which-bufname)))
+             ;; XXX currently we go backwards to find the beginning of an
+             ;; expression part; a more powerful approach in the future might be
+             ;; to let ipython have the complete line, so that context can be used
+             ;; to do things like filename completion etc.
+             (beg (save-excursion (skip-chars-backward "a-z0-9A-Z_." (point-at-bol))
+                                  (point)))
+             (end (point))
+             (pattern (buffer-substring-no-properties beg end))
+             (completions nil)
+             (completion-table nil)
+             completion
+             (comint-output-filter-functions
+              (append comint-output-filter-functions 
+                      '(ansi-color-filter-apply
+                        (lambda (string) 
+                                        ;(message (format "DEBUG filtering: %s" string))
+                          (setq ugly-return (concat ugly-return string))
+                          (delete-region comint-last-output-start 
+                                         (process-mark (get-buffer-process (current-buffer)))))))))
+                                        ;(message (format "#DEBUG pattern: '%s'" pattern))
+        (process-send-string python-process 
+                              (format ipython-completion-command-string pattern))
+        (accept-process-output python-process)
+                                        ;(message (format "DEBUG return: %s" ugly-return))
+        (setq completions 
+              (split-string (substring ugly-return 0 (position ?\n ugly-return)) sep))
+        (setq completion-table (loop for str in completions
+                                     collect (list str nil)))
+        (setq completion (try-completion pattern completion-table))
+        (cond ((eq completion t))
+              ((null completion)
+               (message "Can't find completion for \"%s\"" pattern)
+               (ding))
+              ((not (string= pattern completion))
+               (delete-region beg end)
+               (insert completion))
+              (t
+               (message "Making completion list...")
+               (with-output-to-temp-buffer "*Python Completions*"
+                 (display-completion-list (all-completions pattern completion-table)))
+               (message "Making completion list...%s" "done")))))
+  ;; emacs
+  (defun ipython-complete ()
+    "Try to complete the python symbol before point. Only knows about the stuff
+in the current *Python* session."
+    (interactive)
+    (let* ((ugly-return nil)
+           (sep ";")
+           (python-process (or (get-buffer-process (current-buffer))
+                                        ;XXX hack for .py buffers
+                               (get-process py-which-bufname)))
+           ;; XXX currently we go backwards to find the beginning of an
+           ;; expression part; a more powerful approach in the future might be
+           ;; to let ipython have the complete line, so that context can be used
+           ;; to do things like filename completion etc.
+           (beg (save-excursion (skip-chars-backward "a-z0-9A-Z_./" (point-at-bol))
+                                (point))) 
+           (end (point))
+           (pattern (buffer-substring-no-properties beg end))
+           (completions nil)
+           (completion-table nil)
+           completion
+         (comint-preoutput-filter-functions
+          (append comint-preoutput-filter-functions 
+                  '(ansi-color-filter-apply
+                    (lambda (string) 
+                      (setq ugly-return (concat ugly-return string))
+                      "")))))
+      (process-send-string python-process 
+                            (format ipython-completion-command-string pattern))
+      (accept-process-output python-process)
+      (setq completions 
+            (split-string (substring ugly-return 0 (position ?\n ugly-return)) sep))
+                                        ;(message (format "DEBUG completions: %S" completions))
+      (setq completion-table (loop for str in completions
+                                   collect (list str nil)))
+      (setq completion (try-completion pattern completion-table))
+      (cond ((eq completion t))
+            ((null completion)
+             (message "Can't find completion for \"%s\"" pattern)
+             (ding))
+            ((not (string= pattern completion))
+             (delete-region beg end)
+             (insert completion))
+            (t
+             (message "Making completion list...")
+             (with-output-to-temp-buffer "*IPython Completions*"
+               (display-completion-list (all-completions pattern completion-table)))
+             (message "Making completion list...%s" "done")))))
+)
+
+;;; autoindent support: patch sent in by Jin Liu <m.liu.jin@gmail.com>,
+;;; originally written by doxgen@newsmth.net
+;;; Minor modifications by fperez for xemacs compatibility.
+
+(defvar ipython-autoindent t
+ "If non-nil, enable autoindent for IPython shell through python-mode.")
+
+(defvar ipython-indenting-buffer-name "*IPython Indentation Calculation*"
+ "Temporary buffer for indenting multiline statement.")
+
+(defun ipython-get-indenting-buffer ()
+ "Return a temporary buffer set in python-mode. Create one if necessary."
+ (let ((buf (get-buffer-create ipython-indenting-buffer-name)))
+   (set-buffer buf)
+   (unless (eq major-mode 'python-mode)
+     (python-mode))
+   buf))
+
+(defvar ipython-indentation-string nil
+ "Indentation for the next line in a multiline statement.")
+
+(defun ipython-send-and-indent ()
+ "Send the current line to IPython, and calculate the indentation for
+the next line."
+ (interactive)
+ (if ipython-autoindent
+     (let ((line (buffer-substring (point-at-bol) (point)))
+           (after-prompt1)
+           (after-prompt2))
+       (save-excursion
+           (comint-bol t)
+           (if (looking-at py-shell-input-prompt-1-regexp)
+               (setq after-prompt1 t)
+             (setq after-prompt2 (looking-at py-shell-input-prompt-2-regexp)))
+           (with-current-buffer (ipython-get-indenting-buffer)
+             (when after-prompt1
+               (erase-buffer))
+             (when (or after-prompt1 after-prompt2)
+               (delete-region (point-at-bol) (point))
+               (insert line)
+               (newline-and-indent))))))
+ ;; send input line to ipython interpreter
+ (comint-send-input))
+
+(defun ipython-indentation-hook (string)
+ "Insert indentation string if py-shell-input-prompt-2-regexp
+matches last process output."
+ (let* ((start-marker (or comint-last-output-start
+                          (point-min-marker)))
+        (end-marker (process-mark (get-buffer-process (current-buffer))))
+        (text (ansi-color-filter-apply (buffer-substring start-marker end-marker))))
+   ;; XXX if `text' matches both pattern, it MUST be the last prompt-2
+   (when (and (string-match py-shell-input-prompt-2-regexp text)
+	      (not (string-match "\n$" text)))
+     (with-current-buffer (ipython-get-indenting-buffer)
+       (setq ipython-indentation-string
+	     (buffer-substring (point-at-bol) (point))))
+     (goto-char end-marker)
+     (insert ipython-indentation-string)
+     (setq ipython-indentation-string nil))))
+
+(add-hook 'py-shell-hook
+         (lambda ()
+           (add-hook 'comint-output-filter-functions
+                     'ipython-indentation-hook)))
+
+(define-key py-shell-map (kbd "RET") 'ipython-send-and-indent)
+;;; / end autoindent support
+
+(provide 'ipython)
diff --git a/doc/manual_base.lyx b/doc/manual_base.lyx
new file mode 100644
index 0000000..4def1fe
--- /dev/null
+++ b/doc/manual_base.lyx
@@ -0,0 +1,10507 @@
+#LyX 1.4.3 created this file. For more info see http://www.lyx.org/
+\lyxformat 245
+\begin_document
+\begin_header
+\textclass article
+\begin_preamble
+%\usepackage{ae,aecompl}
+\usepackage{color}
+
+% A few colors to replace the defaults for certain link types
+\definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
+\definecolor{darkorange}{rgb}{.71,0.21,0.01}
+\definecolor{darkred}{rgb}{.52,0.08,0.01}
+\definecolor{darkgreen}{rgb}{.12,.54,.11}
+
+% Use and configure listings package for nicely formatted code
+\usepackage{listings}
+\lstset{
+  language=Python,
+  basicstyle=\small\ttfamily,
+  commentstyle=\ttfamily\color{blue},
+  stringstyle=\ttfamily\color{darkorange},
+  showstringspaces=false,
+  breaklines=true,
+  postbreak = \space\dots
+}
+
+\usepackage[%pdftex,  % needed for pdflatex
+  breaklinks=true,  % so long urls are correctly broken across lines
+  colorlinks=true,
+  urlcolor=blue,
+  linkcolor=darkred,
+  citecolor=darkgreen,
+  ]{hyperref}
+
+\usepackage{html}
+
+% This helps prevent overly long lines that stretch beyond the margins
+\sloppy
+
+% Define a \codelist command which either uses listings for latex, or
+% plain verbatim for html (since latex2html doesn't understand the 
+% listings package).
+\usepackage{verbatim}
+\newcommand{\codelist}[1] {
+\latex{\lstinputlisting{#1}}
+\html{\verbatiminput{#1}}
+}
+\end_preamble
+\language english
+\inputencoding latin1
+\fontscheme palatino
+\graphics default
+\paperfontsize 11
+\spacing single
+\papersize default
+\use_geometry true
+\use_amsmath 1
+\cite_engine basic
+\use_bibtopic false
+\paperorientation portrait
+\leftmargin 1in
+\topmargin 1in
+\rightmargin 1in
+\bottommargin 1in
+\secnumdepth 3
+\tocdepth 3
+\paragraph_separation skip
+\defskip medskip
+\quotes_language english
+\papercolumns 1
+\papersides 2
+\paperpagestyle fancy
+\tracking_changes false
+\output_changes true
+\end_header
+
+\begin_body
+
+\begin_layout Title
+IPython
+\newline
+
+\size larger
+An enhanced Interactive Python
+\size large
+
+\newline
+User Manual, v.
+ __version__
+\end_layout
+
+\begin_layout Author
+Fernando P�rez
+\begin_inset Foot
+status collapsed
+
+\begin_layout Standard
+
+\size scriptsize
+Department of Applied Mathematics, University of Colorado at Boulder.
+ 
+\family typewriter
+<Fernando.Perez@colorado.edu>
+\end_layout
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Standard
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+latex{
+\end_layout
+
+\end_inset
+
+
+\begin_inset LatexCommand \tableofcontents{}
+
+\end_inset
+
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+}
+\end_layout
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Standard
+\begin_inset ERT
+status open
+
+\begin_layout Standard
+
+
+\backslash
+html{
+\backslash
+bodytext{bgcolor=#ffffff}}
+\end_layout
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Standard
+
+\newpage
+
+\end_layout
+
+\begin_layout Section
+Overview
+\end_layout
+
+\begin_layout Standard
+One of Python's most useful features is its interactive interpreter.
+ This system allows very fast testing of ideas without the overhead of creating
+ test files as is typical in most programming languages.
+ However, the interpreter supplied with the standard Python distribution
+ is somewhat limited for extended interactive use.
+\end_layout
+
+\begin_layout Standard
+IPython is a free software project (released under the BSD license) which
+ tries to:
+\end_layout
+
+\begin_layout Enumerate
+Provide an interactive shell superior to Python's default.
+ IPython has many features for object introspection, system shell access,
+ and its own special command system for adding functionality when working
+ interactively.
+ It tries to be a very efficient environment both for Python code development
+ and for exploration of problems using Python objects (in situations like
+ data analysis).
+\end_layout
+
+\begin_layout Enumerate
+Serve as an embeddable, ready to use interpreter for your own programs.
+ IPython can be started with a single call from inside another program,
+ providing access to the current namespace.
+ This can be very useful both for debugging purposes and for situations
+ where a blend of batch-processing and interactive exploration are needed.
+\end_layout
+
+\begin_layout Enumerate
+Offer a flexible framework which can be used as the base environment for
+ other systems with Python as the underlying language.
+ Specifically scientific environments like Mathematica, IDL and Matlab inspired
+ its design, but similar ideas can be useful in many fields.
+\end_layout
+
+\begin_layout Enumerate
+Allow interactive testing of threaded graphical toolkits.
+ IPython has support for interactive, non-blocking control of GTK, Qt and
+ WX applications via special threading flags.
+ The normal Python shell can only do this for Tkinter applications.
+\end_layout
+
+\begin_layout Subsection
+Main features
+\end_layout
+
+\begin_layout Itemize
+Dynamic object introspection.
+ One can access docstrings, function definition prototypes, source code,
+ source files and other details of any object accessible to the interpreter
+ with a single keystroke (`
+\family typewriter
+?
+\family default
+', and using `
+\family typewriter
+??
+\family default
+' provides additional detail).
+\end_layout
+
+\begin_layout Itemize
+Searching through modules and namespaces with `
+\family typewriter
+*
+\family default
+' wildcards, both when using the `
+\family typewriter
+?
+\family default
+' system and via the 
+\family typewriter
+%psearch
+\family default
+ command.
+\end_layout
+
+\begin_layout Itemize
+Completion in the local namespace, by typing TAB at the prompt.
+ This works for keywords, methods, variables and files in the current directory.
+ This is supported via the readline library, and full access to configuring
+ readline's behavior is provided.
+\end_layout
+
+\begin_layout Itemize
+Numbered input/output prompts with command history (persistent across sessions
+ and tied to each profile), full searching in this history and caching of
+ all input and output.
+\end_layout
+
+\begin_layout Itemize
+User-extensible `magic' commands.
+ A set of commands prefixed with 
+\family typewriter
+%
+\family default
+ is available for controlling IPython itself and provides directory control,
+ namespace information and many aliases to common system shell commands.
+\end_layout
+
+\begin_layout Itemize
+Alias facility for defining your own system aliases.
+\end_layout
+
+\begin_layout Itemize
+Complete system shell access.
+ Lines starting with ! are passed directly to the system shell, and using
+ !! captures shell output into python variables for further use.
+\end_layout
+
+\begin_layout Itemize
+Background execution of Python commands in a separate thread.
+ IPython has an internal job manager called 
+\family typewriter
+jobs
+\family default
+, and a conveninence backgrounding magic function called 
+\family typewriter
+%bg
+\family default
+.
+\end_layout
+
+\begin_layout Itemize
+The ability to expand python variables when calling the system shell.
+ In a shell command, any python variable prefixed with 
+\family typewriter
+$
+\family default
+ is expanded.
+ A double 
+\family typewriter
+$$
+\family default
+ allows passing a literal 
+\family typewriter
+$
+\family default
+ to the shell (for access to shell and environment variables like 
+\family typewriter
+$PATH
+\family default
+).
+\end_layout
+
+\begin_layout Itemize
+Filesystem navigation, via a magic 
+\family typewriter
+%cd
+\family default
+ command, along with a persistent bookmark system (using 
+\family typewriter
+%bookmark
+\family default
+) for fast access to frequently visited directories.
+\end_layout
+
+\begin_layout Itemize
+A lightweight persistence framework via the 
+\family typewriter
+%store
+\family default
+ command, which allows you to save arbitrary Python variables.
+ These get restored automatically when your session restarts.
+\end_layout
+
+\begin_layout Itemize
+Automatic indentation (optional) of code as you type (through the readline
+ library).
+\end_layout
+
+\begin_layout Itemize
+Macro system for quickly re-executing multiple lines of previous input with
+ a single name.
+ Macros can be stored persistently via 
+\family typewriter
+%store
+\family default
+ and edited via 
+\family typewriter
+%edit
+\family default
+.
+ 
+\end_layout
+
+\begin_layout Itemize
+Session logging (you can then later use these logs as code in your programs).
+ Logs can optionally timestamp all input, and also store session output
+ (marked as comments, so the log remains valid Python source code).
+\end_layout
+
+\begin_layout Itemize
+Session restoring: logs can be replayed to restore a previous session to
+ the state where you left it.
+\end_layout
+
+\begin_layout Itemize
+Verbose and colored exception traceback printouts.
+ Easier to parse visually, and in verbose mode they produce a lot of useful
+ debugging information (basically a terminal version of the cgitb module).
+\end_layout
+
+\begin_layout Itemize
+Auto-parentheses: callable objects can be executed without parentheses:
+ 
+\family typewriter
+`sin 3'
+\family default
+ is automatically converted to 
+\family typewriter
+`sin(3)
+\family default
+'.
+\end_layout
+
+\begin_layout Itemize
+Auto-quoting: using `
+\family typewriter
+,
+\family default
+' or `
+\family typewriter
+;
+\family default
+' as the first character forces auto-quoting of the rest of the line: 
+\family typewriter
+`,my_function a\InsetSpace ~
+b'
+\family default
+ becomes automatically 
+\family typewriter
+`my_function("a","b")'
+\family default
+, while 
+\family typewriter
+`;my_function a\InsetSpace ~
+b'
+\family default
+ becomes 
+\family typewriter
+`my_function("a b")'
+\family default
+.
+\end_layout
+
+\begin_layout Itemize
+Extensible input syntax.
+ You can define filters that pre-process user input to simplify input in
+ special situations.
+ This allows for example pasting multi-line code fragments which start with
+ 
+\family typewriter
+`>>>'
+\family default
+ or 
+\family typewriter
+`...'
+\family default
+ such as those from other python sessions or the standard Python documentation.
+\end_layout
+
+\begin_layout Itemize
+Flexible configuration system.
+ It uses a configuration file which allows permanent setting of all command-line
+ options, module loading, code and file execution.
+ The system allows recursive file inclusion, so you can have a base file
+ with defaults and layers which load other customizations for particular
+ projects.
+\end_layout
+
+\begin_layout Itemize
+Embeddable.
+ You can call IPython as a python shell inside your own python programs.
+ This can be used both for debugging code or for providing interactive abilities
+ to your programs with knowledge about the local namespaces (very useful
+ in debugging and data analysis situations).
+\end_layout
+
+\begin_layout Itemize
+Easy debugger access.
+ You can set IPython to call up an enhanced version of the Python debugger
+ (
+\family typewriter
+pdb
+\family default
+) every time there is an uncaught exception.
+ This drops you inside the code which triggered the exception with all the
+ data live and it is possible to navigate the stack to rapidly isolate the
+ source of a bug.
+ The 
+\family typewriter
+%run
+\family default
+ magic command --with the 
+\family typewriter
+-d
+\family default
+ option-- can run any script under 
+\family typewriter
+pdb
+\family default
+'s control, automatically setting initial breakpoints for you.
+ This version of 
+\family typewriter
+pdb
+\family default
+ has IPython-specific improvements, including tab-completion and traceback
+ coloring support.
+\end_layout
+
+\begin_layout Itemize
+Profiler support.
+ You can run single statements (similar to 
+\family typewriter
+profile.run()
+\family default
+) or complete programs under the profiler's control.
+ While this is possible with standard 
+\family typewriter
+cProfile
+\family default
+ or 
+\family typewriter
+profile
+\family default
+ modules, IPython wraps this functionality with magic commands (see 
+\family typewriter
+`%prun'
+\family default
+ and 
+\family typewriter
+`%run -p
+\family default
+') convenient for rapid interactive work.
+\end_layout
+
+\begin_layout Itemize
+Doctest support.
+ The special 
+\family typewriter
+%doctest_mode
+\family default
+ command toggles a mode that allows you to paste existing doctests (with
+ leading `
+\family typewriter
+>>>
+\family default
+' prompts and whitespace) and uses doctest-compatible prompts and output,
+ so you can use IPython sessions as doctest code.
+\end_layout
+
+\begin_layout Subsection
+Portability and Python requirements
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+Python requirements: 
+\series default
+IPython requires with Python version 2.3 or newer.
+ If you are still using Python 2.2 and can not upgrade, the last version
+ of IPython which worked with Python 2.2 was 0.6.15, so you will have to use
+ that.
+\end_layout
+
+\begin_layout Standard
+IPython is developed under 
+\series bold
+Linux
+\series default
+, but it should work in any reasonable Unix-type system (tested OK under
+ Solaris and the *BSD family, for which a port exists thanks to Dryice Liu).
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+Mac OS X
+\series default
+: it works, apparently without any problems (thanks to Jim Boyle at Lawrence
+ Livermore for the information).
+ Thanks to Andrea Riciputi, Fink support is available.
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+CygWin
+\series default
+: it works mostly OK, though some users have reported problems with prompt
+ coloring.
+ No satisfactory solution to this has been found so far, you may want to
+ disable colors permanently in the 
+\family typewriter
+ipythonrc
+\family default
+ configuration file if you experience problems.
+ If you have proper color support under cygwin, please post to the IPython
+ mailing list so this issue can be resolved for all users.
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+Windows
+\series default
+: it works well under Windows XP/2k, and I suspect NT should behave similarly.
+ Section\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sub:Under-Windows}
+
+\end_inset
+
+ describes installation details for Windows, including some additional tools
+ needed on this platform.
+\end_layout
+
+\begin_layout Standard
+Windows 9x support is present, and has been reported to work fine (at least
+ on WinME).
+\end_layout
+
+\begin_layout Standard
+Note, that I have very little access to and experience with Windows development.
+ However, an excellent group of Win32 users (led by Ville Vainio), consistently
+ contribute bugfixes and platform-specific enhancements, so they more than
+ make up for my deficiencies on that front.
+ In fact, Win32 users report using IPython as a system shell (see Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:IPython-as-shell}
+
+\end_inset
+
+ for details), as it offers a level of control and features which the default
+ 
+\family typewriter
+cmd.exe
+\family default
+ doesn't provide.
+\end_layout
+
+\begin_layout Subsection
+Location
+\end_layout
+
+\begin_layout Standard
+IPython is generously hosted at 
+\begin_inset LatexCommand \htmlurl{http://ipython.scipy.org}
+
+\end_inset
+
+ by the Enthought, Inc and the SciPy project.
+ This site offers downloads, subversion access, mailing lists and a bug
+ tracking system.
+ I am very grateful to Enthought (
+\begin_inset LatexCommand \htmlurl{http://www.enthought.com}
+
+\end_inset
+
+) and all of the SciPy team for their contribution.
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:install}
+
+\end_inset
+
+Installation
+\end_layout
+
+\begin_layout Subsection
+Instant instructions
+\end_layout
+
+\begin_layout Standard
+If you are of the impatient kind, under Linux/Unix simply untar/unzip the
+ download, then install with 
+\family typewriter
+`python setup.py install'
+\family default
+.
+ Under Windows, double-click on the provided 
+\family typewriter
+.exe
+\family default
+ binary installer.
+\end_layout
+
+\begin_layout Standard
+Then, take a look at Sections 
+\begin_inset LatexCommand \ref{sec:good_config}
+
+\end_inset
+
+ for configuring things optimally and 
+\begin_inset LatexCommand \ref{sec:quick_tips}
+
+\end_inset
+
+ for quick tips on efficient use of IPython.
+ You can later refer to the rest of the manual for all the gory details.
+\end_layout
+
+\begin_layout Standard
+See the notes in sec.
+ 
+\begin_inset LatexCommand \ref{sec:upgrade}
+
+\end_inset
+
+ for upgrading IPython versions.
+\end_layout
+
+\begin_layout Subsection
+Detailed Unix instructions (Linux, Mac OS X, etc.)
+\end_layout
+
+\begin_layout Standard
+For RPM based systems, simply install the supplied package in the usual
+ manner.
+ If you download the tar archive, the process is:
+\end_layout
+
+\begin_layout Enumerate
+Unzip/untar the 
+\family typewriter
+ipython-XXX.tar.gz
+\family default
+ file wherever you want (
+\family typewriter
+XXX
+\family default
+ is the version number).
+ It will make a directory called 
+\family typewriter
+ipython-XXX.
+ 
+\family default
+Change into that directory where you will find the files 
+\family typewriter
+README
+\family default
+ and 
+\family typewriter
+setup.py
+\family default
+.
+
+\family typewriter
+ O
+\family default
+nce you've completed the installation, you can safely remove this directory.
+ 
+\end_layout
+
+\begin_layout Enumerate
+If you are installing over a previous installation of version 0.2.0 or earlier,
+ first remove your 
+\family typewriter
+$HOME/.ipython
+\family default
+ directory, since the configuration file format has changed somewhat (the
+ '=' were removed from all option specifications).
+ Or you can call ipython with the 
+\family typewriter
+-upgrade
+\family default
+ option and it will do this automatically for you.
+\end_layout
+
+\begin_layout Enumerate
+IPython uses distutils, so you can install it by simply typing at the system
+ prompt (don't type the 
+\family typewriter
+$
+\family default
+)
+\newline
+
+\family typewriter
+$ python setup.py install
+\family default
+
+\newline
+Note that this assumes you have root access to your machine.
+ If you don't have root access or don't want IPython to go in the default
+ python directories, you'll need to use the 
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+verb|--home|
+\end_layout
+
+\end_inset
+
+ option (or 
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+verb|--prefix|
+\end_layout
+
+\end_inset
+
+).
+ For example:
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+verb|$ python setup.py install --home $HOME/local|
+\end_layout
+
+\end_inset
+
+
+\newline
+will install IPython into 
+\family typewriter
+$HOME/local 
+\family default
+and its subdirectories (creating them if necessary).
+\newline
+You can type
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+verb|$ python setup.py --help|
+\end_layout
+
+\end_inset
+
+ 
+\newline
+for more details.
+\newline
+Note that if you change the default location for 
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+verb|--home|
+\end_layout
+
+\end_inset
+
+ at installation, IPython may end up installed at a location which is not
+ part of your 
+\family typewriter
+$PYTHONPATH
+\family default
+ environment variable.
+ In this case, you'll need to configure this variable to include the actual
+ directory where the 
+\family typewriter
+IPython/
+\family default
+ directory ended (typically the value you give to 
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+verb|--home|
+\end_layout
+
+\end_inset
+
+ plus 
+\family typewriter
+/lib/python
+\family default
+).
+\end_layout
+
+\begin_layout Subsubsection
+Mac OSX information
+\end_layout
+
+\begin_layout Standard
+Under OSX, there is a choice you need to make.
+ Apple ships its own build of Python, which lives in the core OSX filesystem
+ hierarchy.
+ You can also manually install a separate Python, either purely by hand
+ (typically in 
+\family typewriter
+/usr/local
+\family default
+) or by using Fink, which puts everything under 
+\family typewriter
+/sw
+\family default
+.
+ Which route to follow is a matter of personal preference, as I've seen
+ users who favor each of the approaches.
+ Here I will simply list the known installation issues under OSX, along
+ with their solutions.
+\end_layout
+
+\begin_layout Standard
+This page: 
+\begin_inset LatexCommand \htmlurl{http://geosci.uchicago.edu/~tobis/pylab.html}
+
+\end_inset
+
+ contains information on this topic, with additional details on how to make
+ IPython and matplotlib play nicely under OSX.
+\end_layout
+
+\begin_layout Subsubsection*
+GUI problems
+\end_layout
+
+\begin_layout Standard
+The following instructions apply to an install of IPython under OSX from
+ unpacking the 
+\family typewriter
+.tar.gz
+\family default
+ distribution and installing it for the default Python interpreter shipped
+ by Apple.
+ If you are using a fink install, fink will take care of these details for
+ you, by installing IPython against fink's Python.
+\end_layout
+
+\begin_layout Standard
+IPython offers various forms of support for interacting with graphical applicati
+ons from the command line, from simple Tk apps (which are in principle always
+ supported by Python) to interactive control of WX, Qt and GTK apps.
+ Under OSX, however, this requires that ipython is installed by calling
+ the special 
+\family typewriter
+pythonw
+\family default
+ script at installation time, which takes care of coordinating things with
+ Apple's graphical environment.
+\end_layout
+
+\begin_layout Standard
+So when installing under OSX, it is best to use the following command:
+\family typewriter
+
+\newline
+
+\family default
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+verb|  $ sudo pythonw setup.py install --install-scripts=/usr/local/bin|
+\end_layout
+
+\end_inset
+
+
+\newline
+ or
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+verb|  $ sudo pythonw setup.py install --install-scripts=/usr/bin|
+\end_layout
+
+\end_inset
+
+
+\newline
+depending on where you like to keep hand-installed executables.
+\end_layout
+
+\begin_layout Standard
+The resulting script will have an appropriate shebang line (the first line
+ in the script whic begins with 
+\family typewriter
+#!...
+\family default
+) such that the ipython interpreter can interact with the OS X GUI.
+ If the installed version does not work and has a shebang line that points
+ to, for example, just 
+\family typewriter
+/usr/bin/python
+\family default
+, then you might have a stale, cached version in your 
+\family typewriter
+build/scripts-<python-version>
+\family default
+ directory.
+ Delete that directory and rerun the 
+\family typewriter
+setup.py
+\family default
+.
+ 
+\end_layout
+
+\begin_layout Standard
+It is also a good idea to use the special flag 
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+verb|--install-scripts|
+\end_layout
+
+\end_inset
+
+ as indicated above, to ensure that the ipython scripts end up in a location
+ which is part of your 
+\family typewriter
+$PATH
+\family default
+.
+ Otherwise Apple's Python will put the scripts in an internal directory
+ not available by default at the command line (if you use 
+\family typewriter
+/usr/local/bin
+\family default
+, you need to make sure this is in your 
+\family typewriter
+$PATH
+\family default
+, which may not be true by default).
+\end_layout
+
+\begin_layout Subsubsection*
+Readline problems
+\end_layout
+
+\begin_layout Standard
+By default, the Python version shipped by Apple does 
+\emph on
+not
+\emph default
+ include the readline library, so central to IPython's behavior.
+ If you install IPython against Apple's Python, you will not have arrow
+ keys, tab completion, etc.
+ For Mac OSX 10.3 (Panther), you can find a prebuilt readline library here:
+\newline
+
+\begin_inset LatexCommand \htmlurl{http://pythonmac.org/packages/readline-5.0-py2.3-macosx10.3.zip}
+
+\end_inset
+
+ 
+\end_layout
+
+\begin_layout Standard
+If you are using OSX 10.4 (Tiger), after installing this package you need
+ to either: 
+\end_layout
+
+\begin_layout Enumerate
+move 
+\family typewriter
+readline.so
+\family default
+ from 
+\family typewriter
+/Library/Python/2.3
+\family default
+ to 
+\family typewriter
+/Library/Python/2.3/site-packages
+\family default
+, or
+\end_layout
+
+\begin_layout Enumerate
+install 
+\begin_inset LatexCommand \htmlurl{http://pythonmac.org/packages/TigerPython23Compat.pkg.zip}
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Standard
+Users installing against Fink's Python or a properly hand-built one should
+ not have this problem.
+\end_layout
+
+\begin_layout Subsubsection*
+DarwinPorts
+\end_layout
+
+\begin_layout Standard
+I report here a message from an OSX user, who suggests an alternative means
+ of using IPython under this operating system with good results.
+ Please let me know of any updates that may be useful for this section.
+ His message is reproduced verbatim below:
+\end_layout
+
+\begin_layout Quote
+From: Markus Banfi 
+\family typewriter
+<markus.banfi-AT-mospheira.net>
+\end_layout
+
+\begin_layout Quote
+As a MacOS X (10.4.2) user I prefer to install software using DawinPorts instead
+ of Fink.
+ I had no problems installing ipython with DarwinPorts.
+ It's just:
+\end_layout
+
+\begin_layout Quote
+
+\family typewriter
+sudo port install py-ipython
+\end_layout
+
+\begin_layout Quote
+It automatically resolved all dependencies (python24, readline, py-readline).
+ So far I did not encounter any problems with the DarwinPorts port of ipython.
+ 
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sub:Under-Windows}
+
+\end_inset
+
+Windows instructions
+\end_layout
+
+\begin_layout Standard
+Some of IPython's very useful features are:
+\end_layout
+
+\begin_layout Itemize
+Integrated readline support (Tab-based file, object and attribute completion,
+ input history across sessions, editable command line, etc.)
+\end_layout
+
+\begin_layout Itemize
+Coloring of prompts, code and tracebacks.
+\end_layout
+
+\begin_layout Standard
+These, by default, are only available under Unix-like operating systems.
+ However, thanks to Gary Bishop's work, Windows XP/2k users can also benefit
+ from them.
+ His readline library originally implemented both GNU readline functionality
+ and color support, so that IPython under Windows XP/2k can be as friendly
+ and powerful as under Unix-like environments.
+ 
+\end_layout
+
+\begin_layout Standard
+This library, now named 
+\family typewriter
+PyReadline
+\family default
+, has been absorbed by the IPython team (J�rgen Stenarson, in particular),
+ and it continues to be developed with new features, as well as being distribute
+d directly from the IPython site.
+\end_layout
+
+\begin_layout Standard
+The
+\family typewriter
+ PyReadline
+\family default
+ extension requires 
+\family typewriter
+CTypes
+\family default
+ and the windows IPython installer needs 
+\family typewriter
+PyWin32
+\family default
+, so in all you need:
+\end_layout
+
+\begin_layout Enumerate
+
+\family typewriter
+PyWin32
+\family default
+ from 
+\begin_inset LatexCommand \htmlurl{http://sourceforge.net/projects/pywin32}
+
+\end_inset
+
+.
+\end_layout
+
+\begin_layout Enumerate
+
+\family typewriter
+PyReadline
+\family default
+ for Windows from 
+\begin_inset LatexCommand \htmlurl{http://ipython.scipy.org/moin/PyReadline/Intro}
+
+\end_inset
+
+.
+ That page contains further details on using and configuring the system
+ to your liking.
+\end_layout
+
+\begin_layout Enumerate
+Finally, 
+\emph on
+only 
+\emph default
+if you are using Python 2.3 or 2.4, you need 
+\family typewriter
+CTypes
+\family default
+ from 
+\begin_inset LatexCommand \htmlurl{http://starship.python.net/crew/theller/ctypes}
+
+\end_inset
+
+ (you 
+\emph on
+must
+\emph default
+ use version 0.9.1 or newer).
+ This package is included in Python 2.5, so you don't need to manually get
+ it if your Python version is 2.5 or newer.
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+Warning about a broken readline-like library:
+\series default
+ several users have reported problems stemming from using the pseudo-readline
+ library at 
+\begin_inset LatexCommand \htmlurl{http://newcenturycomputers.net/projects/readline.html}
+
+\end_inset
+
+.
+ This is a broken library which, while called readline, only implements
+ an incomplete subset of the readline API.
+ Since it is still called readline, it fools IPython's detection mechanisms
+ and causes unpredictable crashes later.
+ If you wish to use IPython under Windows, you must NOT use this library,
+ which for all purposes is (at least as of version 1.6) terminally broken.
+\end_layout
+
+\begin_layout Subsubsection
+Installation procedure
+\end_layout
+
+\begin_layout Standard
+Once you have the above installed, from the IPython download directory grab
+ the 
+\family typewriter
+ipython-XXX.win32.exe
+\family default
+ file, where 
+\family typewriter
+XXX
+\family default
+ represents the version number.
+ This is a regular windows executable installer, which you can simply double-cli
+ck to install.
+ It will add an entry for IPython to your Start Menu, as well as registering
+ IPython in the Windows list of applications, so you can later uninstall
+ it from the Control Panel.
+ 
+\end_layout
+
+\begin_layout Standard
+IPython tries to install the configuration information in a directory named
+ 
+\family typewriter
+.ipython
+\family default
+ (
+\family typewriter
+_ipython
+\family default
+ under Windows) located in your `home' directory.
+ IPython sets this directory by looking for a 
+\family typewriter
+HOME
+\family default
+ environment variable; if such a variable does not exist, it uses 
+\family typewriter
+HOMEDRIVE
+\backslash
+HOMEPATH 
+\family default
+(these are always defined by Windows).
+ This typically gives something like 
+\family typewriter
+C:
+\backslash
+Documents and Settings
+\backslash
+YourUserName
+\family default
+, but your local details may vary.
+ In this directory you will find all the files that configure IPython's
+ defaults, and you can put there your profiles and extensions.
+ This directory is automatically added by IPython to 
+\family typewriter
+sys.path
+\family default
+, so anything you place there can be found by 
+\family typewriter
+import
+\family default
+ statements.
+\end_layout
+
+\begin_layout Paragraph
+Upgrading
+\end_layout
+
+\begin_layout Standard
+For an IPython upgrade, you should first uninstall the previous version.
+ This will ensure that all files and directories (such as the documentation)
+ which carry embedded version strings in their names are properly removed.
+\end_layout
+
+\begin_layout Paragraph
+Manual installation under Win32
+\end_layout
+
+\begin_layout Standard
+In case the automatic installer does not work for some reason, you can download
+ the 
+\family typewriter
+ipython-XXX.tar.gz
+\family default
+ file, which contains the full IPython source distribution (the popular
+ WinZip can read 
+\family typewriter
+.tar.gz
+\family default
+ files).
+ After uncompressing the archive, you can install it at a command terminal
+ just like any other Python module, by using 
+\family typewriter
+`python setup.py install'
+\family default
+.
+ 
+\end_layout
+
+\begin_layout Standard
+After the installation, run the supplied 
+\family typewriter
+win32_manual_post_install.py 
+\family default
+script, which creates the necessary Start Menu shortcuts for you.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:upgrade}
+
+\end_inset
+
+Upgrading from a previous version
+\end_layout
+
+\begin_layout Standard
+If you are upgrading from a previous version of IPython, after doing the
+ routine installation described above, you should call IPython with the
+ 
+\family typewriter
+-upgrade
+\family default
+ option the first time you run your new copy.
+ This will automatically update your configuration directory while preserving
+ copies of your old files.
+ You can then later merge back any personal customizations you may have
+ made into the new files.
+ It is a good idea to do this as there may be new options available in the
+ new configuration files which you will not have.
+\end_layout
+
+\begin_layout Standard
+Under Windows, if you don't know how to call python scripts with arguments
+ from a command line, simply delete the old config directory and IPython
+ will make a new one.
+ Win2k and WinXP users will find it in 
+\family typewriter
+C:
+\backslash
+Documents and Settings
+\backslash
+YourUserName
+\backslash
+_ipython
+\family default
+, and Win 9x users under 
+\family typewriter
+C:
+\backslash
+Program Files
+\backslash
+IPython
+\backslash
+_ipython.
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:good_config}
+
+\end_inset
+
+
+\begin_inset OptArg
+status collapsed
+
+\begin_layout Standard
+Initial configuration
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+ldots
+\end_layout
+
+\end_inset
+
+
+\end_layout
+
+\end_inset
+
+Initial configuration of your environment
+\end_layout
+
+\begin_layout Standard
+This section will help you set various things in your environment for your
+ IPython sessions to be as efficient as possible.
+ All of IPython's configuration information, along with several example
+ files, is stored in a directory named by default 
+\family typewriter
+$HOME/.ipython
+\family default
+.
+ You can change this by defining the environment variable 
+\family typewriter
+IPYTHONDIR
+\family default
+, or at runtime with the command line option 
+\family typewriter
+-ipythondir
+\family default
+.
+\end_layout
+
+\begin_layout Standard
+If all goes well, the first time you run IPython it should automatically
+ create a user copy of the config directory for you, based on its builtin
+ defaults.
+ You can look at the files it creates to learn more about configuring the
+ system.
+ The main file you will modify to configure IPython's behavior is called
+ 
+\family typewriter
+ipythonrc
+\family default
+ (with a 
+\family typewriter
+.ini
+\family default
+ extension under Windows), included for reference in Sec.
+ 
+\begin_inset LatexCommand \ref{sec:ipytonrc-sample}
+
+\end_inset
+
+.
+ This file is very commented and has many variables you can change to suit
+ your taste, you can find more details in Sec.
+ 
+\begin_inset LatexCommand \ref{sec:customization}
+
+\end_inset
+
+.
+ Here we discuss the basic things you will want to make sure things are
+ working properly from the beginning.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:help-access}
+
+\end_inset
+
+Access to the Python help system
+\end_layout
+
+\begin_layout Standard
+This is true for Python in general (not just for IPython): you should have
+ an environment variable called 
+\family typewriter
+PYTHONDOCS
+\family default
+ pointing to the directory where your HTML Python documentation lives.
+ In my system it's 
+\family typewriter
+/usr/share/doc/python-docs-2.3.4/html
+\family default
+, check your local details or ask your systems administrator.
+ 
+\end_layout
+
+\begin_layout Standard
+This is the directory which holds the HTML version of the Python manuals.
+ Unfortunately it seems that different Linux distributions package these
+ files differently, so you may have to look around a bit.
+ Below I show the contents of this directory on my system for reference:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+[html]> ls
+\newline
+about.dat acks.html dist/ ext/ index.html lib/ modindex.html stdabout.dat
+ tut/ about.html api/ doc/ icons/ inst/ mac/ ref/ style.css
+\end_layout
+
+\begin_layout Standard
+You should really make sure this variable is correctly set so that Python's
+ pydoc-based help system works.
+ It is a powerful and convenient system with full access to the Python manuals
+ and all modules accessible to you.
+\end_layout
+
+\begin_layout Standard
+Under Windows it seems that pydoc finds the documentation automatically,
+ so no extra setup appears necessary.
+\end_layout
+
+\begin_layout Subsection
+Editor
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+%edit
+\family default
+ command (and its alias 
+\family typewriter
+%ed
+\family default
+) will invoke the editor set in your environment as 
+\family typewriter
+EDITOR
+\family default
+.
+ If this variable is not set, it will default to 
+\family typewriter
+vi
+\family default
+ under Linux/Unix and to 
+\family typewriter
+notepad
+\family default
+ under Windows.
+ You may want to set this variable properly and to a lightweight editor
+ which doesn't take too long to start (that is, something other than a new
+ instance of 
+\family typewriter
+Emacs
+\family default
+).
+ This way you can edit multi-line code quickly and with the power of a real
+ editor right inside IPython.
+ 
+\end_layout
+
+\begin_layout Standard
+If you are a dedicated 
+\family typewriter
+Emacs
+\family default
+ user, you should set up the 
+\family typewriter
+Emacs
+\family default
+ server so that new requests are handled by the original process.
+ This means that almost no time is spent in handling the request (assuming
+ an 
+\family typewriter
+Emacs
+\family default
+ process is already running).
+ For this to work, you need to set your 
+\family typewriter
+EDITOR 
+\family default
+environment variable to 
+\family typewriter
+'emacsclient'
+\family default
+.
+
+\family typewriter
+ 
+\family default
+The code below, supplied by Francois Pinard, can then be used in your 
+\family typewriter
+.emacs
+\family default
+ file to enable the server:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+(defvar server-buffer-clients)
+\newline
+(when (and (fboundp 'server-start) (string-equal
+ (getenv "TERM") 'xterm))
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+(server-start)
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+(defun fp-kill-server-with-buffer-routine ()
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+(and server-buffer-clients (server-done)))
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+(add-hook 'kill-buffer-hook 'fp-kill-server-with-buffer-routine))
+\end_layout
+
+\begin_layout Standard
+You can also set the value of this editor via the commmand-line option '-
+\family typewriter
+editor'
+\family default
+ or in your 
+\family typewriter
+ipythonrc
+\family default
+ file.
+ This is useful if you wish to use specifically for IPython an editor different
+ from your typical default (and for Windows users who tend to use fewer
+ environment variables).
+\end_layout
+
+\begin_layout Subsection
+Color 
+\end_layout
+
+\begin_layout Standard
+The default IPython configuration has most bells and whistles turned on
+ (they're pretty safe).
+ But there's one that 
+\emph on
+may
+\emph default
+ cause problems on some systems: the use of color on screen for displaying
+ information.
+ This is very useful, since IPython can show prompts and exception tracebacks
+ with various colors, display syntax-highlighted source code, and in general
+ make it easier to visually parse information.
+\end_layout
+
+\begin_layout Standard
+The following terminals seem to handle the color sequences fine:
+\end_layout
+
+\begin_layout Itemize
+Linux main text console, KDE Konsole, Gnome Terminal, E-term, rxvt, xterm.
+\end_layout
+
+\begin_layout Itemize
+CDE terminal (tested under Solaris).
+ This one boldfaces light colors.
+\end_layout
+
+\begin_layout Itemize
+(X)Emacs buffers.
+ See sec.
+\begin_inset LatexCommand \ref{sec:emacs}
+
+\end_inset
+
+ for more details on using IPython with (X)Emacs.
+\end_layout
+
+\begin_layout Itemize
+A Windows (XP/2k) command prompt 
+\emph on
+with Gary Bishop's support extensions
+\emph default
+.
+ Gary's extensions are discussed in Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sub:Under-Windows}
+
+\end_inset
+
+.
+\end_layout
+
+\begin_layout Itemize
+A Windows (XP/2k) CygWin shell.
+ Although some users have reported problems; it is not clear whether there
+ is an issue for everyone or only under specific configurations.
+ If you have full color support under cygwin, please post to the IPython
+ mailing list so this issue can be resolved for all users.
+\end_layout
+
+\begin_layout Standard
+These have shown problems:
+\end_layout
+
+\begin_layout Itemize
+Windows command prompt in WinXP/2k logged into a Linux machine via telnet
+ or ssh.
+\end_layout
+
+\begin_layout Itemize
+Windows native command prompt in WinXP/2k, 
+\emph on
+without 
+\emph default
+Gary Bishop's extensions.
+ Once Gary's readline library is installed, the normal WinXP/2k command
+ prompt works perfectly.
+\end_layout
+
+\begin_layout Standard
+Currently the following color schemes are available:
+\end_layout
+
+\begin_layout Itemize
+
+\family typewriter
+NoColor
+\family default
+: uses no color escapes at all (all escapes are empty 
+\begin_inset Quotes eld
+\end_inset
+
+ 
+\begin_inset Quotes eld
+\end_inset
+
+ strings).
+ This 'scheme' is thus fully safe to use in any terminal.
+\end_layout
+
+\begin_layout Itemize
+
+\family typewriter
+Linux
+\family default
+: works well in Linux console type environments: dark background with light
+ fonts.
+ It uses bright colors for information, so it is difficult to read if you
+ have a light colored background.
+\end_layout
+
+\begin_layout Itemize
+
+\family typewriter
+LightBG
+\family default
+: the basic colors are similar to those in the 
+\family typewriter
+Linux
+\family default
+ scheme but darker.
+ It is easy to read in terminals with light backgrounds.
+\end_layout
+
+\begin_layout Standard
+IPython uses colors for two main groups of things: prompts and tracebacks
+ which are directly printed to the terminal, and the object introspection
+ system which passes large sets of data through a pager.
+\end_layout
+
+\begin_layout Subsubsection
+Input/Output prompts and exception tracebacks
+\end_layout
+
+\begin_layout Standard
+You can test whether the colored prompts and tracebacks work on your system
+ interactively by typing 
+\family typewriter
+'%colors Linux'
+\family default
+ at the prompt (use '
+\family typewriter
+%colors LightBG'
+\family default
+ if your terminal has a light background).
+ If the input prompt shows garbage like:
+\newline
+
+\family typewriter
+[0;32mIn [[1;32m1[0;32m]: [0;00m
+\family default
+
+\newline
+instead of (in color) something like:
+\newline
+
+\family typewriter
+In [1]:
+\family default
+ 
+\newline
+this means that your terminal doesn't properly handle color escape sequences.
+ You can go to a 'no color' mode by typing '
+\family typewriter
+%colors NoColor
+\family default
+'.
+ 
+\end_layout
+
+\begin_layout Standard
+You can try using a different terminal emulator program (Emacs users, see
+ below).
+ To permanently set your color preferences, edit the file
+\family typewriter
+ $HOME/.ipython/ipythonrc 
+\family default
+and set the 
+\family typewriter
+colors
+\family default
+ option to the desired value.
+\end_layout
+
+\begin_layout Subsubsection
+Object details (types, docstrings, source code, etc.)
+\end_layout
+
+\begin_layout Standard
+IPython has a set of special functions for studying the objects you are
+ working with, discussed in detail in Sec.
+ 
+\begin_inset LatexCommand \ref{sec:dyn-object-info}
+
+\end_inset
+
+.
+ But this system relies on passing information which is longer than your
+ screen through a data pager, such as the common Unix 
+\family typewriter
+less
+\family default
+ and 
+\family typewriter
+more
+\family default
+ programs.
+ In order to be able to see this information in color, your pager needs
+ to be properly configured.
+ I strongly recommend using 
+\family typewriter
+less
+\family default
+ instead of 
+\family typewriter
+more
+\family default
+, as it seems that 
+\family typewriter
+more
+\family default
+ simply can not understand colored text correctly.
+\end_layout
+
+\begin_layout Standard
+In order to configure 
+\family typewriter
+less
+\family default
+ as your default pager, do the following:
+\end_layout
+
+\begin_layout Enumerate
+Set the environment 
+\family typewriter
+PAGER
+\family default
+ variable to 
+\family typewriter
+less
+\family default
+.
+\end_layout
+
+\begin_layout Enumerate
+Set the environment 
+\family typewriter
+LESS
+\family default
+ variable to 
+\family typewriter
+-r
+\family default
+ (plus any other options you always want to pass to 
+\family typewriter
+less
+\family default
+ by default).
+ This tells 
+\family typewriter
+less
+\family default
+ to properly interpret control sequences, which is how color information
+ is given to your terminal.
+\end_layout
+
+\begin_layout Standard
+For the 
+\family typewriter
+csh
+\family default
+ or 
+\family typewriter
+tcsh
+\family default
+ shells, add to your 
+\family typewriter
+~/.cshrc
+\family default
+ file the lines:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+setenv PAGER less
+\newline
+setenv LESS -r
+\end_layout
+
+\begin_layout Standard
+There is similar syntax for other Unix shells, look at your system documentation
+ for details.
+\end_layout
+
+\begin_layout Standard
+If you are on a system which lacks proper data pagers (such as Windows),
+ IPython will use a very limited builtin pager.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:emacs}
+
+\end_inset
+
+(X)Emacs configuration
+\end_layout
+
+\begin_layout Standard
+Thanks to the work of Alexander Schmolck and Prabhu Ramachandran, currently
+ (X)Emacs and IPython get along very well.
+ 
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+Important note:
+\series default
+ You will need to use a recent enough version of 
+\family typewriter
+python-mode.el
+\family default
+, along with the file 
+\family typewriter
+ipython.el
+\family default
+.
+ You can check that the version you have of 
+\family typewriter
+python-mode.el
+\family default
+ is new enough by either looking at the revision number in the file itself,
+ or asking for it in (X)Emacs via 
+\family typewriter
+M-x py-version
+\family default
+.
+ Versions 4.68 and newer contain the necessary fixes for proper IPython support.
+\end_layout
+
+\begin_layout Standard
+The file 
+\family typewriter
+ipython.el
+\family default
+ is included with the IPython distribution, in the documentation directory
+ (where this manual resides in PDF and HTML formats).
+\end_layout
+
+\begin_layout Standard
+Once you put these files in your Emacs path, all you need in your 
+\family typewriter
+.emacs
+\family default
+ file is:
+\end_layout
+
+\begin_layout LyX-Code
+(require 'ipython)
+\end_layout
+
+\begin_layout Standard
+This should give you full support for executing code snippets via IPython,
+ opening IPython as your Python shell via 
+\family typewriter
+C-c\InsetSpace ~
+!
+\family default
+, etc.
+ 
+\end_layout
+
+\begin_layout Standard
+If you happen to get garbage instead of colored prompts as described in
+ the previous section, you may need to set also in your 
+\family typewriter
+.emacs
+\family default
+ file:
+\end_layout
+
+\begin_layout LyX-Code
+(setq ansi-color-for-comint-mode t)
+\end_layout
+
+\begin_layout Subsubsection*
+Notes
+\end_layout
+
+\begin_layout Itemize
+There is one caveat you should be aware of: you must start the IPython shell
+ 
+\emph on
+before
+\emph default
+ attempting to execute any code regions via 
+\family typewriter
+C-c\InsetSpace ~
+|
+\family default
+.
+ Simply type 
+\family typewriter
+C-c\InsetSpace ~
+!
+\family default
+ to start IPython before passing any code regions to the interpreter, and
+ you shouldn't experience any problems.
+\newline
+This is due to a bug in Python itself,
+ which has been fixed for Python 2.3, but exists as of Python 2.2.2 (reported
+ as SF bug [ 737947 ]).
+\end_layout
+
+\begin_layout Itemize
+The (X)Emacs support is maintained by Alexander Schmolck, so all comments/reques
+ts should be directed to him through the IPython mailing lists.
+ 
+\end_layout
+
+\begin_layout Itemize
+This code is still somewhat experimental so it's a bit rough around the
+ edges (although in practice, it works quite well).
+\end_layout
+
+\begin_layout Itemize
+Be aware that if you customize 
+\family typewriter
+py-python-command
+\family default
+ previously, this value will override what 
+\family typewriter
+ipython.el
+\family default
+ does (because loading the customization variables comes later).
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:quick_tips}
+
+\end_inset
+
+Quick tips
+\end_layout
+
+\begin_layout Standard
+IPython can be used as an improved replacement for the Python prompt, and
+ for that you don't really need to read any more of this manual.
+ But in this section we'll try to summarize a few tips on how to make the
+ most effective use of it for everyday Python development, highlighting
+ things you might miss in the rest of the manual (which is getting long).
+ We'll give references to parts in the manual which provide more detail
+ when appropriate.
+\end_layout
+
+\begin_layout Standard
+The following article by Jeremy Jones provides an introductory tutorial
+ about IPython:
+\newline
+
+\begin_inset LatexCommand \htmlurl{http://www.onlamp.com/pub/a/python/2005/01/27/ipython.html}
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Itemize
+The TAB key.
+ TAB-completion, especially for attributes, is a convenient way to explore
+ the structure of any object you're dealing with.
+ Simply type 
+\family typewriter
+object_name.<TAB>
+\family default
+ and a list of the object's attributes will be printed (see sec.
+ 
+\begin_inset LatexCommand \ref{sec:readline}
+
+\end_inset
+
+ for more).
+ Tab completion also works on file and directory names, which combined with
+ IPython's alias system allows you to do from within IPython many of the
+ things you normally would need the system shell for.
+ 
+\end_layout
+
+\begin_layout Itemize
+Explore your objects.
+ Typing 
+\family typewriter
+object_name?
+\family default
+ will print all sorts of details about any object, including docstrings,
+ function definition lines (for call arguments) and constructor details
+ for classes.
+ The magic commands 
+\family typewriter
+%pdoc
+\family default
+, 
+\family typewriter
+%pdef
+\family default
+, 
+\family typewriter
+%psource
+\family default
+ and 
+\family typewriter
+%pfile
+\family default
+ will respectively print the docstring, function definition line, full source
+ code and the complete file for any object (when they can be found).
+ If automagic is on (it is by default), you don't need to type the '
+\family typewriter
+%
+\family default
+' explicitly.
+ See sec.
+ 
+\begin_inset LatexCommand \ref{sec:dyn-object-info}
+
+\end_inset
+
+ for more.
+\end_layout
+
+\begin_layout Itemize
+The 
+\family typewriter
+%run
+\family default
+ magic command allows you to run any python script and load all of its data
+ directly into the interactive namespace.
+ Since the file is re-read from disk each time, changes you make to it are
+ reflected immediately (in contrast to the behavior of 
+\family typewriter
+import
+\family default
+).
+ I rarely use 
+\family typewriter
+import
+\family default
+ for code I am testing, relying on 
+\family typewriter
+%run
+\family default
+ instead.
+ See sec.
+ 
+\begin_inset LatexCommand \ref{sec:magic}
+
+\end_inset
+
+ for more on this and other magic commands, or type the name of any magic
+ command and ? to get details on it.
+ See also sec.
+ 
+\begin_inset LatexCommand \ref{sec:dreload}
+
+\end_inset
+
+ for a recursive reload command.
+\newline
+
+\family typewriter
+%run
+\family default
+ also has special flags for timing the execution of your scripts (
+\family typewriter
+-t
+\family default
+) and for executing them under the control of either Python's 
+\family typewriter
+pdb 
+\family default
+debugger (
+\family typewriter
+-d
+\family default
+) or profiler (
+\family typewriter
+-p
+\family default
+).
+ With all of these, 
+\family typewriter
+%run
+\family default
+ can be used as the main tool for efficient interactive development of code
+ which you write in your editor of choice.
+\end_layout
+
+\begin_layout Itemize
+Use the Python debugger, 
+\family typewriter
+pdb
+\family default
+
+\begin_inset Foot
+status collapsed
+
+\begin_layout Standard
+Thanks to Christian Hart and Matthew Arnison for the suggestions leading
+ to IPython's improved debugger and profiler support.
+\end_layout
+
+\end_inset
+
+.
+ The 
+\family typewriter
+%pdb
+\family default
+ command allows you to toggle on and off the automatic invocation of an
+ IPython-enhanced 
+\family typewriter
+pdb
+\family default
+ debugger (with coloring, tab completion and more) at any uncaught exception.
+ The advantage of this is that 
+\family typewriter
+pdb
+\family default
+ starts 
+\emph on
+inside
+\emph default
+ the function where the exception occurred, with all data still available.
+ You can print variables, see code, execute statements and even walk up
+ and down the call stack to track down the true source of the problem (which
+ often is many layers in the stack above where the exception gets triggered).
+\newline
+Runn
+ing programs with 
+\family typewriter
+%run
+\family default
+ and pdb active can be an efficient to develop and debug code, in many cases
+ eliminating the need for 
+\family typewriter
+print
+\family default
+ statements or external debugging tools.
+ I often simply put a 
+\family typewriter
+1/0
+\family default
+ in a place where I want to take a look so that pdb gets called, quickly
+ view whatever variables I need to or test various pieces of code and then
+ remove the 
+\family typewriter
+1/0
+\family default
+.
+\newline
+Note also that `
+\family typewriter
+%run -d
+\family default
+' activates 
+\family typewriter
+pdb
+\family default
+ and automatically sets initial breakpoints for you to step through your
+ code, watch variables, etc.
+ See Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:cache_output}
+
+\end_inset
+
+ for details.
+\end_layout
+
+\begin_layout Itemize
+Use the output cache.
+ All output results are automatically stored in a global dictionary named
+ 
+\family typewriter
+Out
+\family default
+ and variables named 
+\family typewriter
+_1
+\family default
+, 
+\family typewriter
+_2
+\family default
+, etc.
+ alias them.
+ For example, the result of input line 4 is available either as 
+\family typewriter
+Out[4]
+\family default
+ or as 
+\family typewriter
+_4
+\family default
+.
+ Additionally, three variables named 
+\family typewriter
+_
+\family default
+, 
+\family typewriter
+__
+\family default
+ and 
+\family typewriter
+___
+\family default
+ are always kept updated with the for the last three results.
+ This allows you to recall any previous result and further use it for new
+ calculations.
+ See Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:cache_output}
+
+\end_inset
+
+ for more.
+\end_layout
+
+\begin_layout Itemize
+Put a '
+\family typewriter
+;
+\family default
+' at the end of a line to supress the printing of output.
+ This is useful when doing calculations which generate long output you are
+ not interested in seeing.
+ The 
+\family typewriter
+_*
+\family default
+ variables and the 
+\family typewriter
+Out[]
+\family default
+ list do get updated with the contents of the output, even if it is not
+ printed.
+ You can thus still access the generated results this way for further processing.
+\end_layout
+
+\begin_layout Itemize
+A similar system exists for caching input.
+ All input is stored in a global list called 
+\family typewriter
+In
+\family default
+ , so you can re-execute lines 22 through 28 plus line 34 by typing 
+\family typewriter
+'exec In[22:29]+In[34]'
+\family default
+ (using Python slicing notation).
+ If you need to execute the same set of lines often, you can assign them
+ to a macro with the 
+\family typewriter
+%macro
+\family default
+ 
+\family typewriter
+function.
+ 
+\family default
+See sec.
+ 
+\begin_inset LatexCommand \ref{sec:cache_input}
+
+\end_inset
+
+ for more.
+\end_layout
+
+\begin_layout Itemize
+Use your input history.
+ The 
+\family typewriter
+%hist
+\family default
+ command can show you all previous input, without line numbers if desired
+ (option 
+\family typewriter
+-n
+\family default
+) so you can directly copy and paste code either back in IPython or in a
+ text editor.
+ You can also save all your history by turning on logging via 
+\family typewriter
+%logstart
+\family default
+; these logs can later be either reloaded as IPython sessions or used as
+ code for your programs.
+\end_layout
+
+\begin_layout Itemize
+Define your own system aliases.
+ Even though IPython gives you access to your system shell via the 
+\family typewriter
+!
+\family default
+ prefix, it is convenient to have aliases to the system commands you use
+ most often.
+ This allows you to work seamlessly from inside IPython with the same commands
+ you are used to in your system shell.
+\newline
+IPython comes with some pre-defined
+ aliases and a complete system for changing directories, both via a stack
+ (see 
+\family typewriter
+%pushd
+\family default
+, 
+\family typewriter
+%popd
+\family default
+ and 
+\family typewriter
+%dhist
+\family default
+) and via direct 
+\family typewriter
+%cd
+\family default
+.
+ The latter keeps a history of visited directories and allows you to go
+ to any previously visited one.
+\end_layout
+
+\begin_layout Itemize
+Use Python to manipulate the results of system commands.
+ The `
+\family typewriter
+!!
+\family default
+' special syntax, and the 
+\family typewriter
+%sc
+\family default
+ and 
+\family typewriter
+%sx
+\family default
+ magic commands allow you to capture system output into Python variables.
+\end_layout
+
+\begin_layout Itemize
+Expand python variables when calling the shell (either via 
+\family typewriter
+`!'
+\family default
+ and 
+\family typewriter
+`!!'
+\family default
+ or via aliases) by prepending a 
+\family typewriter
+$
+\family default
+ in front of them.
+ You can also expand complete python expressions.
+ See sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sub:System-shell-access}
+
+\end_inset
+
+ for more.
+\end_layout
+
+\begin_layout Itemize
+Use profiles to maintain different configurations (modules to load, function
+ definitions, option settings) for particular tasks.
+ You can then have customized versions of IPython for specific purposes.
+ See sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:profiles}
+
+\end_inset
+
+ for more.
+\end_layout
+
+\begin_layout Itemize
+Embed IPython in your programs.
+ A few lines of code are enough to load a complete IPython inside your own
+ programs, giving you the ability to work with your data interactively after
+ automatic processing has been completed.
+ See sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:embed}
+
+\end_inset
+
+ for more.
+\end_layout
+
+\begin_layout Itemize
+Use the Python profiler.
+ When dealing with performance issues, the 
+\family typewriter
+%run
+\family default
+ command with a 
+\family typewriter
+-p
+\family default
+ option allows you to run complete programs under the control of the Python
+ profiler.
+ The 
+\family typewriter
+%prun
+\family default
+ command does a similar job for single Python expressions (like function
+ calls).
+\end_layout
+
+\begin_layout Itemize
+Use the IPython.demo.Demo class to load any Python script as an interactive
+ demo.
+ With a minimal amount of simple markup, you can control the execution of
+ the script, stopping as needed.
+ See sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:interactive-demos}
+
+\end_inset
+
+ for more.
+\end_layout
+
+\begin_layout Itemize
+Run your doctests from within IPython for development and debugging.
+ The special 
+\family typewriter
+%doctest_mode
+\family default
+ command toggles a mode where the prompt, output and exceptions display
+ matches as closely as possible that of the default Python interpreter.
+ In addition, this mode allows you to directly paste in code that contains
+ leading `
+\family typewriter
+>>>
+\family default
+' prompts, even if they have extra leading whitespace (as is common in doctest
+ files).
+ This combined with the `
+\family typewriter
+%history -t
+\family default
+n' call to see your translated history (with these extra prompts removed
+ and no line numbers) allows for an easy doctest workflow, where you can
+ go from doctest to interactive execution to pasting into valid Python code
+ as needed.
+\end_layout
+
+\begin_layout Subsection
+Source code handling tips
+\end_layout
+
+\begin_layout Standard
+IPython is a line-oriented program, without full control of the terminal.
+ Therefore, it doesn't support true multiline editing.
+ However, it has a number of useful tools to help you in dealing effectively
+ with more complex editing.
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+%edit
+\family default
+ command gives a reasonable approximation of multiline editing, by invoking
+ your favorite editor on the spot.
+ IPython will execute the code you type in there as if it were typed interactive
+ly.
+ Type 
+\family typewriter
+%edit?
+\family default
+ for the full details on the edit command.
+\end_layout
+
+\begin_layout Standard
+If you have typed various commands during a session, which you'd like to
+ reuse, IPython provides you with a number of tools.
+ Start by using 
+\family typewriter
+%hist
+\family default
+ to see your input history, so you can see the line numbers of all input.
+ Let us say that you'd like to reuse lines 10 through 20, plus lines 24
+ and 28.
+ All the commands below can operate on these with the syntax
+\end_layout
+
+\begin_layout LyX-Code
+%command 10-20 24 28
+\end_layout
+
+\begin_layout Standard
+where the command given can be:
+\end_layout
+
+\begin_layout Itemize
+
+\family typewriter
+%macro <macroname>
+\family default
+: this stores the lines into a variable which, when called at the prompt,
+ re-executes the input.
+ Macros can be edited later using 
+\family typewriter
+`%edit macroname
+\family default
+', and they can be stored persistently across sessions with `
+\family typewriter
+%store macroname
+\family default
+' (the storage system is per-profile).
+ The combination of quick macros, persistent storage and editing, allows
+ you to easily refine quick-and-dirty interactive input into permanent utilities
+, always available both in IPython and as files for general reuse.
+\end_layout
+
+\begin_layout Itemize
+
+\family typewriter
+%edit
+\family default
+: this will open a text editor with those lines pre-loaded for further modificat
+ion.
+ It will then execute the resulting file's contents as if you had typed
+ it at the prompt.
+\end_layout
+
+\begin_layout Itemize
+
+\family typewriter
+%save <filename>
+\family default
+: this saves the lines directly to a named file on disk.
+\end_layout
+
+\begin_layout Standard
+While 
+\family typewriter
+%macro
+\family default
+ saves input lines into memory for interactive re-execution, sometimes you'd
+ like to save your input directly to a file.
+ The 
+\family typewriter
+%save
+\family default
+ magic does this: its input sytnax is the same as 
+\family typewriter
+%macro
+\family default
+, but it saves your input directly to a Python file.
+ Note that the 
+\family typewriter
+%logstart
+\family default
+ command also saves input, but it logs 
+\emph on
+all
+\emph default
+ input to disk (though you can temporarily suspend it and reactivate it
+ with 
+\family typewriter
+%logoff/%logon
+\family default
+); 
+\family typewriter
+%save
+\family default
+ allows you to select which lines of input you need to save.
+\end_layout
+
+\begin_layout Subsubsection*
+Lightweight 'version control'
+\end_layout
+
+\begin_layout Standard
+When you call 
+\family typewriter
+%edit
+\family default
+ with no arguments, IPython opens an empty editor with a temporary file,
+ and it returns the contents of your editing session as a string variable.
+ Thanks to IPython's output caching mechanism, this is automatically stored:
+\end_layout
+
+\begin_layout LyX-Code
+In [1]: %edit
+\end_layout
+
+\begin_layout LyX-Code
+IPython will make a temporary file named: /tmp/ipython_edit_yR-HCN.py
+\end_layout
+
+\begin_layout LyX-Code
+Editing...
+ done.
+ Executing edited code...
+\end_layout
+
+\begin_layout LyX-Code
+hello - this is a temporary file
+\end_layout
+
+\begin_layout LyX-Code
+Out[1]: "print 'hello - this is a temporary file'
+\backslash
+n"
+\end_layout
+
+\begin_layout Standard
+Now, if you call 
+\family typewriter
+`%edit -p'
+\family default
+, IPython tries to open an editor with the same data as the last time you
+ used 
+\family typewriter
+%edit
+\family default
+.
+ So if you haven't used 
+\family typewriter
+%edit
+\family default
+ in the meantime, this same contents will reopen; however, it will be done
+ in a 
+\emph on
+new file
+\emph default
+.
+ This means that if you make changes and you later want to find an old version,
+ you can always retrieve it by using its output number, via 
+\family typewriter
+`%edit _NN'
+\family default
+, where 
+\family typewriter
+NN
+\family default
+ is the number of the output prompt.
+\end_layout
+
+\begin_layout Standard
+Continuing with the example above, this should illustrate this idea:
+\end_layout
+
+\begin_layout LyX-Code
+In [2]: edit -p
+\end_layout
+
+\begin_layout LyX-Code
+IPython will make a temporary file named: /tmp/ipython_edit_nA09Qk.py
+\end_layout
+
+\begin_layout LyX-Code
+Editing...
+ done.
+ Executing edited code...
+\end_layout
+
+\begin_layout LyX-Code
+hello - now I made some changes
+\end_layout
+
+\begin_layout LyX-Code
+Out[2]: "print 'hello - now I made some changes'
+\backslash
+n"
+\end_layout
+
+\begin_layout LyX-Code
+In [3]: edit _1
+\end_layout
+
+\begin_layout LyX-Code
+IPython will make a temporary file named: /tmp/ipython_edit_gy6-zD.py
+\end_layout
+
+\begin_layout LyX-Code
+Editing...
+ done.
+ Executing edited code...
+\end_layout
+
+\begin_layout LyX-Code
+hello - this is a temporary file
+\end_layout
+
+\begin_layout LyX-Code
+IPython version control at work :)
+\end_layout
+
+\begin_layout LyX-Code
+Out[3]: "print 'hello - this is a temporary file'
+\backslash
+nprint 'IPython version control at work :)'
+\backslash
+n"
+\end_layout
+
+\begin_layout Standard
+This section was written after a contribution by Alexander Belchenko on
+ the IPython user list.
+\end_layout
+
+\begin_layout LyX-Code
+
+\end_layout
+
+\begin_layout Subsection
+Effective logging
+\end_layout
+
+\begin_layout Standard
+A very useful suggestion sent in by Robert Kern follows:
+\end_layout
+
+\begin_layout Standard
+I recently happened on a nifty way to keep tidy per-project log files.
+ I made a profile for my project (which is called "parkfield").
+\end_layout
+
+\begin_layout LyX-Code
+include ipythonrc
+\end_layout
+
+\begin_layout LyX-Code
+# cancel earlier logfile invocation:
+\end_layout
+
+\begin_layout LyX-Code
+logfile ''
+\end_layout
+
+\begin_layout LyX-Code
+execute import time
+\end_layout
+
+\begin_layout LyX-Code
+execute __cmd = '/Users/kern/research/logfiles/parkfield-%s.log rotate'
+\end_layout
+
+\begin_layout LyX-Code
+execute __IP.magic_logstart(__cmd % time.strftime('%Y-%m-%d'))
+\end_layout
+
+\begin_layout Standard
+I also added a shell alias for convenience:
+\end_layout
+
+\begin_layout LyX-Code
+alias parkfield="ipython -pylab -profile parkfield"
+\end_layout
+
+\begin_layout Standard
+Now I have a nice little directory with everything I ever type in, organized
+ by project and date.
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+Contribute your own: 
+\series default
+If you have your own favorite tip on using IPython efficiently for a certain
+ task (especially things which can't be done in the normal Python interpreter),
+ don't hesitate to send it!
+\end_layout
+
+\begin_layout Section
+Command-line use
+\end_layout
+
+\begin_layout Standard
+You start IPython with the command:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+$ ipython [options] files
+\end_layout
+
+\begin_layout Standard
+If invoked with no options, it executes all the files listed in sequence
+ and drops you into the interpreter while still acknowledging any options
+ you may have set in your ipythonrc file.
+ This behavior is different from standard Python, which when called as 
+\family typewriter
+python -i
+\family default
+ will only execute one file and ignore your configuration setup.
+\end_layout
+
+\begin_layout Standard
+Please note that some of the configuration options are not available at
+ the command line, simply because they are not practical here.
+ Look into your ipythonrc configuration file for details on those.
+ This file typically installed in the 
+\family typewriter
+$HOME/.ipython
+\family default
+ directory.
+ For Windows users, 
+\family typewriter
+$HOME
+\family default
+ resolves to 
+\family typewriter
+C:
+\backslash
+
+\backslash
+Documents and Settings
+\backslash
+
+\backslash
+YourUserName
+\family default
+ in most instances.
+ In the rest of this text, we will refer to this directory as 
+\family typewriter
+IPYTHONDIR
+\family default
+.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:threading-opts}
+
+\end_inset
+
+Special Threading Options
+\end_layout
+
+\begin_layout Standard
+The following special options are ONLY valid at the beginning of the command
+ line, and not later.
+ This is because they control the initial- ization of ipython itself, before
+ the normal option-handling mechanism is active.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-gthread,\InsetSpace ~
+-qthread,\InsetSpace ~
+-q4thread,\InsetSpace ~
+-wthread,\InsetSpace ~
+-pylab:
+\family default
+\series default
+ Only 
+\emph on
+one
+\emph default
+ of these can be given, and it can only be given as the first option passed
+ to IPython (it will have no effect in any other position).
+ They provide threading support for the GTK, Qt (versions 3 and 4) and WXPython
+ toolkits, and for the matplotlib library.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ With any of the first four options, IPython starts running a separate thread
+ for the graphical toolkit's operation, so that you can open and control
+ graphical elements from within an IPython command line, without blocking.
+ All four provide essentially the same functionality, respectively for GTK,
+ Qt3, Qt4 and WXWidgets (via their Python interfaces).
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ Note that with 
+\family typewriter
+-wthread
+\family default
+, you can additionally use the -wxversion option to request a specific version
+ of wx to be used.
+ This requires that you have the 
+\family typewriter
+wxversion
+\family default
+ Python module installed, which is part of recent wxPython distributions.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ If 
+\family typewriter
+-pylab
+\family default
+ is given, IPython loads special support for the mat plotlib library (
+\begin_inset LatexCommand \htmlurl{http://matplotlib.sourceforge.net}
+
+\end_inset
+
+), allowing interactive usage of any of its backends as defined in the user's
+ 
+\family typewriter
+~/.matplotlib/matplotlibrc
+\family default
+ file.
+ It automatically activates GTK, Qt or WX threading for IPyhton if the choice
+ of matplotlib backend requires it.
+ It also modifies the 
+\family typewriter
+%run
+\family default
+ command to correctly execute (without blocking) any matplotlib-based script
+ which calls 
+\family typewriter
+show()
+\family default
+ at the end.
+ 
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-tk
+\family default
+\series default
+ The 
+\family typewriter
+-g/q/q4/wthread
+\family default
+ options, and 
+\family typewriter
+-pylab
+\family default
+ (if matplotlib is configured to use GTK, Qt3, Qt4 or WX), will normally
+ block Tk graphical interfaces.
+ This means that when either GTK, Qt or WX threading is active, any attempt
+ to open a Tk GUI will result in a dead window, and possibly cause the Python
+ interpreter to crash.
+ An extra option, 
+\family typewriter
+-tk
+\family default
+, is available to address this issue.
+ It can 
+\emph on
+only
+\emph default
+ be given as a 
+\emph on
+second
+\emph default
+ option after any of the above (
+\family typewriter
+-gthread
+\family default
+, 
+\family typewriter
+-wthread
+\family default
+ or 
+\family typewriter
+-pylab
+\family default
+).
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ If 
+\family typewriter
+-tk
+\family default
+ is given, IPython will try to coordinate Tk threading with GTK, Qt or WX.
+ This is however potentially unreliable, and you will have to test on your
+ platform and Python configuration to determine whether it works for you.
+ Debian users have reported success, apparently due to the fact that Debian
+ builds all of Tcl, Tk, Tkinter and Python with pthreads support.
+ Under other Linux environments (such as Fedora Core 2/3), this option has
+ caused random crashes and lockups of the Python interpreter.
+ Under other operating systems (Mac OSX and Windows), you'll need to try
+ it to find out, since currently no user reports are available.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ There is unfortunately no way for IPython to determine at run time whether
+ 
+\family typewriter
+-tk
+\family default
+ will work reliably or not, so you will need to do some experiments before
+ relying on it for regular work.
+ 
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:cmd-line-opts}
+
+\end_inset
+
+Regular Options
+\end_layout
+
+\begin_layout Standard
+After the above threading options have been given, regular options can follow
+ in any order.
+ All options can be abbreviated to their shortest non-ambiguous form and
+ are case-sensitive.
+ One or two dashes can be used.
+ Some options have an alternate short form, indicated after a 
+\family typewriter
+|
+\family default
+.
+\end_layout
+
+\begin_layout Standard
+Most options can also be set from your ipythonrc configuration file.
+ See the provided example for more details on what the options do.
+ Options given at the command line override the values set in the ipythonrc
+ file.
+\end_layout
+
+\begin_layout Standard
+All options with a 
+\family typewriter
+[no]
+\family default
+ prepended can be specified in negated form (
+\family typewriter
+-nooption
+\family default
+ instead of 
+\family typewriter
+-option
+\family default
+) to turn the feature off.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-help
+\family default
+\series default
+: print a help message and exit.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-pylab:
+\family default
+\series default
+ this can 
+\emph on
+only
+\emph default
+ be given as the 
+\emph on
+first
+\emph default
+ option passed to IPython (it will have no effect in any other position).
+ It adds special support for the matplotlib library (
+\begin_inset LatexCommand \htmlurl[http://matplotlib.sourceforge.net]{http://matplotlib.sourceforge.net}
+
+\end_inset
+
+), allowing interactive usage of any of its backends as defined in the user's
+ 
+\family typewriter
+.matplotlibrc
+\family default
+ file.
+ It automatically activates GTK or WX threading for IPyhton if the choice
+ of matplotlib backend requires it.
+ It also modifies the 
+\family typewriter
+%run
+\family default
+ command to correctly execute (without blocking) any matplotlib-based script
+ which calls 
+\family typewriter
+show()
+\family default
+ at the end.
+ See Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:matplotlib-support}
+
+\end_inset
+
+ for more details.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-autocall <val>:
+\family default
+\series default
+ Make IPython automatically call any callable object even if you didn't
+ type explicit parentheses.
+ For example, `str 43' becomes `str(43)' automatically.
+ The value can be `0' to disable the feature, `1' for 
+\emph on
+smart
+\emph default
+ autocall, where it is not applied if there are no more arguments on the
+ line, and `2' for 
+\emph on
+full
+\emph default
+ autocall, where all callable objects are automatically called (even if
+ no arguments are present).
+ The default is `1'.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]autoindent:
+\family default
+\series default
+ Turn automatic indentation on/off.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]automagic
+\series default
+:
+\family default
+ make magic commands automatic (without needing their first character to
+ be 
+\family typewriter
+%
+\family default
+).
+ Type 
+\family typewriter
+%magic
+\family default
+ at the IPython prompt for more information.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]autoedit_syntax:
+\family default
+\series default
+ When a syntax error occurs after editing a file, automatically open the
+ file to the trouble causing line for convenient fixing.
+ 
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]banner
+\series default
+:
+\family default
+ Print the initial information banner (default on).
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-c\InsetSpace ~
+<command>:
+\family default
+\series default
+ execute the given command string, and set sys.argv to 
+\family typewriter
+['c']
+\family default
+.
+ This is similar to the 
+\family typewriter
+-c
+\family default
+ option in the normal Python interpreter.
+ 
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-cache_size|cs\InsetSpace ~
+<n>
+\series default
+:
+\family default
+ size of the output cache (maximum number of entries to hold in memory).
+ The default is 1000, you can change it permanently in your config file.
+ Setting it to 0 completely disables the caching system, and the minimum
+ value accepted is 20 (if you provide a value less than 20, it is reset
+ to 0 and a warning is issued) This limit is defined because otherwise you'll
+ spend more time re-flushing a too small cache than working.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-classic|cl
+\series default
+:
+\family default
+ Gives IPython a similar feel to the classic Python prompt.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-colors\InsetSpace ~
+<scheme>:
+\family default
+\series default
+ Color scheme for prompts and exception reporting.
+ Currently implemented: NoColor, Linux and LightBG.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]color_info:
+\family default
+\series default
+ IPython can display information about objects via a set of functions, and
+ optionally can use colors for this, syntax highlighting source code and
+ various other elements.
+ However, because this information is passed through a pager (like 'less')
+ and many pagers get confused with color codes, this option is off by default.
+ You can test it and turn it on permanently in your ipythonrc file if it
+ works for you.
+ As a reference, the 'less' pager supplied with Mandrake 8.2 works ok, but
+ that in RedHat 7.2 doesn't.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ Test it and turn it on permanently if it works with your system.
+ The magic function 
+\family typewriter
+%color_info
+\family default
+ allows you to toggle this interactively for testing.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]debug
+\family default
+\series default
+: Show information about the loading process.
+ Very useful to pin down problems with your configuration files or to get
+ details about session restores.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]deep_reload
+\series default
+:
+\family default
+ IPython can use the 
+\family typewriter
+deep_reload
+\family default
+ module which reloads changes in modules recursively (it replaces the 
+\family typewriter
+reload()
+\family default
+ function, so you don't need to change anything to use it).
+ 
+\family typewriter
+deep_reload()
+\family default
+ forces a full reload of modules whose code may have changed, which the
+ default 
+\family typewriter
+reload()
+\family default
+ function does not.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ When deep_reload is off, IPython will use the normal 
+\family typewriter
+reload()
+\family default
+, but deep_reload will still be available as 
+\family typewriter
+dreload()
+\family default
+.
+ This feature is off by default [which means that you have both normal 
+\family typewriter
+reload()
+\family default
+ and 
+\family typewriter
+dreload()
+\family default
+].
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-editor\InsetSpace ~
+<name>
+\family default
+\series default
+: Which editor to use with the 
+\family typewriter
+%edit
+\family default
+ command.
+ By default, IPython will honor your 
+\family typewriter
+EDITOR
+\family default
+ environment variable (if not set, vi is the Unix default and notepad the
+ Windows one).
+ Since this editor is invoked on the fly by IPython and is meant for editing
+ small code snippets, you may want to use a small, lightweight editor here
+ (in case your default 
+\family typewriter
+EDITOR
+\family default
+ is something like Emacs).
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-ipythondir\InsetSpace ~
+<name>
+\series default
+:
+\family default
+ name of your IPython configuration directory 
+\family typewriter
+IPYTHONDIR
+\family default
+.
+ This can also be specified through the environment variable 
+\family typewriter
+IPYTHONDIR
+\family default
+.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-log|l
+\family default
+\series default
+: generate a log file of all input.
+ The file is named 
+\family typewriter
+ipython_log.py
+\family default
+ in your current directory (which prevents logs from multiple IPython sessions
+ from trampling each other).
+ You can use this to later restore a session by loading your logfile as
+ a file to be executed with option 
+\family typewriter
+-logplay
+\family default
+ (see below).
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-logfile|lf\InsetSpace ~
+<name>
+\series default
+: 
+\family default
+specify the name of your logfile.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-logplay|lp\InsetSpace ~
+<name>
+\series default
+:
+\family default
+ you can replay a previous log.
+ For restoring a session as close as possible to the state you left it in,
+ use this option (don't just run the logfile).
+ With 
+\family typewriter
+-logplay
+\family default
+, IPython will try to reconstruct the previous working environment in full,
+ not just execute the commands in the logfile.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ When a session is restored, logging is automatically turned on again with
+ the name of the logfile it was invoked with (it is read from the log header).
+ So once you've turned logging on for a session, you can quit IPython and
+ reload it as many times as you want and it will continue to log its history
+ and restore from the beginning every time.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ Caveats: there are limitations in this option.
+ The history variables 
+\family typewriter
+_i*
+\family default
+,
+\family typewriter
+_*
+\family default
+ and 
+\family typewriter
+_dh
+\family default
+ don't get restored properly.
+ In the future we will try to implement full session saving by writing and
+ retrieving a 'snapshot' of the memory state of IPython.
+ But our first attempts failed because of inherent limitations of Python's
+ Pickle module, so this may have to wait.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]messages
+\series default
+:
+\family default
+ Print messages which IPython collects about its startup process (default
+ on).
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]pdb
+\family default
+\series default
+: Automatically call the pdb debugger after every uncaught exception.
+ If you are used to debugging using pdb, this puts you automatically inside
+ of it after any call (either in IPython or in code called by it) which
+ triggers an exception which goes uncaught.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]pprint
+\series default
+:
+\family default
+ ipython can optionally use the pprint (pretty printer) module for displaying
+ results.
+ pprint tends to give a nicer display of nested data structures.
+ If you like it, you can turn it on permanently in your config file (default
+ off).
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-profile|p <name>
+\series default
+:
+\family default
+ assume that your config file is 
+\family typewriter
+ipythonrc-<name>
+\family default
+ (looks in current dir first, then in 
+\family typewriter
+IPYTHONDIR
+\family default
+).
+ This is a quick way to keep and load multiple config files for different
+ tasks, especially if you use the include option of config files.
+ You can keep a basic 
+\family typewriter
+IPYTHONDIR/ipythonrc
+\family default
+ file and then have other 'profiles' which include this one and load extra
+ things for particular tasks.
+ For example:
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\InsetSpace ~
+ 
+\family default
+1.
+
+\family typewriter
+ $HOME/.ipython/ipythonrc
+\family default
+ : load basic things you always want.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\InsetSpace ~
+ 
+\family default
+2.
+
+\family typewriter
+ $HOME/.ipython/ipythonrc-math
+\family default
+ : load (1) and basic math-related modules.
+ 
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\InsetSpace ~
+ 
+\family default
+3.
+
+\family typewriter
+ $HOME/.ipython/ipythonrc-numeric
+\family default
+ : load (1) and Numeric and plotting modules.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ Since it is possible to create an endless loop by having circular file
+ inclusions, IPython will stop if it reaches 15 recursive inclusions.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-prompt_in1|pi1\InsetSpace ~
+<string>:
+\family default
+\series default
+ Specify the string used for input prompts.
+ Note that if you are using numbered prompts, the number is represented
+ with a '
+\backslash
+#' in the string.
+ Don't forget to quote strings with spaces embedded in them.
+ Default: '
+\family typewriter
+In\InsetSpace ~
+[
+\backslash
+#]:
+\family default
+'.
+ Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:prompts}
+
+\end_inset
+
+ discusses in detail all the available escapes to customize your prompts.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-prompt_in2|pi2\InsetSpace ~
+<string>:
+\family default
+\series default
+ Similar to the previous option, but used for the continuation prompts.
+ The special sequence '
+\family typewriter
+
+\backslash
+D
+\family default
+' is similar to '
+\family typewriter
+
+\backslash
+#
+\family default
+', but with all digits replaced dots (so you can have your continuation
+ prompt aligned with your input prompt).
+ Default: '
+\family typewriter
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+.
+\backslash
+D.:
+\family default
+' (note three spaces at the start for alignment with '
+\family typewriter
+In\InsetSpace ~
+[
+\backslash
+#]
+\family default
+').
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-prompt_out|po\InsetSpace ~
+<string>:
+\family default
+\series default
+ String used for output prompts, also uses numbers like 
+\family typewriter
+prompt_in1
+\family default
+.
+ Default: '
+\family typewriter
+Out[
+\backslash
+#]:
+\family default
+'
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-quick
+\family default
+\series default
+: start in bare bones mode (no config file loaded).
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-rcfile\InsetSpace ~
+<name>
+\series default
+:
+\family default
+ name of your IPython resource configuration file.
+ Normally IPython loads ipythonrc (from current directory) or
+\family typewriter
+ IPYTHONDIR/ipythonrc
+\family default
+.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ If the loading of your config file fails, IPython starts with a bare bones
+ configuration (no modules loaded at all).
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-[no]readline
+\family default
+\series default
+: use the readline library, which is needed to support name completion and
+ command history, among other things.
+ It is enabled by default, but may cause problems for users of X/Emacs in
+ Python comint or shell buffers.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ Note that X/Emacs 'eterm' buffers (opened with 
+\family typewriter
+M-x\InsetSpace ~
+term
+\family default
+) support IPython's readline and syntax coloring fine, only 'emacs' (
+\family typewriter
+M-x\InsetSpace ~
+shell
+\family default
+ and 
+\family typewriter
+C-c\InsetSpace ~
+!
+\family default
+) buffers do not.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-screen_length|sl\InsetSpace ~
+<n>
+\series default
+:
+\family default
+ number of lines of your screen.
+ This is used to control printing of very long strings.
+ Strings longer than this number of lines will be sent through a pager instead
+ of directly printed.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ The default value for this is 0, which means IPython will auto-detect your
+ screen size every time it needs to print certain potentially long strings
+ (this doesn't change the behavior of the 'print' keyword, it's only triggered
+ internally).
+ If for some reason this isn't working well (it needs curses support), specify
+ it yourself.
+ Otherwise don't change the default.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-separate_in|si\InsetSpace ~
+<string>
+\series default
+:
+\family default
+ separator before input prompts.
+ Default: '
+\family typewriter
+
+\backslash
+n
+\family default
+'
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-separate_out|so\InsetSpace ~
+<string>
+\family default
+\series default
+: separator before output prompts.
+ Default: nothing.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-separate_out2|so2\InsetSpace ~
+<string>
+\series default
+:
+\family default
+ separator after output prompts.
+ Default: nothing.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ For these three options, use the value 0 to specify no separator.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-nosep
+\series default
+: 
+\family default
+shorthand for 
+\family typewriter
+'-SeparateIn 0 -SeparateOut 0 -SeparateOut2 0'
+\family default
+.
+ Simply removes all input/output separators.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-upgrade
+\family default
+\series default
+: allows you to upgrade your 
+\family typewriter
+IPYTHONDIR
+\family default
+ configuration when you install a new version of IPython.
+ Since new versions may include new command line options or example files,
+ this copies updated ipythonrc-type files.
+ However, it backs up (with a 
+\family typewriter
+.old
+\family default
+ extension) all files which it overwrites so that you can merge back any
+ customizations you might have in your personal files.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-Version
+\series default
+:
+\family default
+ print version information and exit.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-wxversion\InsetSpace ~
+<string>:
+\family default
+\series default
+ Select a specific version of wxPython (used in conjunction with 
+\family typewriter
+-wthread
+\family default
+).
+ Requires the wxversion module, part of recent wxPython distributions
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+-xmode\InsetSpace ~
+<modename>
+\series default
+:
+\family default
+ Mode for exception reporting.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ Valid modes: Plain, Context and Verbose.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ Plain: similar to python's normal traceback printing.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ Context: prints 5 lines of context source code around each line in the
+ traceback.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ Verbose: similar to Context, but additionally 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).
+\end_layout
+
+\begin_layout Section
+Interactive use
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+Warning
+\series default
+: IPython relies on the existence of a global variable called 
+\family typewriter
+__IP
+\family default
+ which controls the shell itself.
+ If you redefine 
+\family typewriter
+__IP
+\family default
+ to anything, bizarre behavior will quickly occur.
+\end_layout
+
+\begin_layout Standard
+Other than the above warning, IPython is meant to work as a drop-in replacement
+ for the standard interactive interpreter.
+ As such, any code which is valid python should execute normally under IPython
+ (cases where this is not true should be reported as bugs).
+ It does, however, offer many features which are not available at a standard
+ python prompt.
+ What follows is a list of these.
+\end_layout
+
+\begin_layout Subsection
+Caution for Windows users
+\end_layout
+
+\begin_layout Standard
+Windows, unfortunately, uses the `
+\family typewriter
+
+\backslash
+
+\family default
+' character as a path separator.
+ This is a terrible choice, because `
+\family typewriter
+
+\backslash
+
+\family default
+' also represents the escape character in most modern programming languages,
+ including Python.
+ For this reason, issuing many of the commands discussed below (especially
+ magics which affect the filesystem) with `
+\family typewriter
+
+\backslash
+
+\family default
+' in them will cause strange errors.
+\end_layout
+
+\begin_layout Standard
+A partial solution is to use instead the `
+\family typewriter
+/
+\family default
+' character as a path separator, which Windows recognizes in 
+\emph on
+most
+\emph default
+ situations.
+ However, in Windows commands `
+\family typewriter
+/
+\family default
+' flags options, so you can not use it for the root directory.
+ This means that paths beginning at the root must be typed in a contrived
+ manner like:
+\newline
+
+\family typewriter
+%copy 
+\backslash
+opt/foo/bar.txt 
+\backslash
+tmp
+\end_layout
+
+\begin_layout Standard
+There is no sensible thing IPython can do to truly work around this flaw
+ in Windows
+\begin_inset Foot
+status collapsed
+
+\begin_layout Standard
+If anyone comes up with a 
+\emph on
+clean
+\emph default
+ solution which works consistently and does not negatively impact other
+ platforms at all, I'll gladly accept a patch.
+\end_layout
+
+\end_inset
+
+.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:magic}
+
+\end_inset
+
+Magic command system
+\end_layout
+
+\begin_layout Standard
+IPython will treat any line whose first character is a 
+\family typewriter
+%
+\family default
+ as a special call to a 'magic' function.
+ These allow you to control the behavior of IPython itself, plus a lot of
+ system-type features.
+ They are all prefixed with a 
+\family typewriter
+%
+\family default
+ character, but parameters are given without parentheses or quotes.
+\end_layout
+
+\begin_layout Standard
+Example: typing 
+\family typewriter
+'%cd mydir'
+\family default
+ (without the quotes) changes you working directory to 
+\family typewriter
+'mydir'
+\family default
+, if it exists.
+\end_layout
+
+\begin_layout Standard
+If you have 'automagic' enabled (in your 
+\family typewriter
+ipythonrc
+\family default
+ file, via the command line option 
+\family typewriter
+-automagic 
+\family default
+or with the 
+\family typewriter
+%automagic
+\family default
+ function), you don't need to type in the 
+\family typewriter
+%
+\family default
+ explicitly.
+ IPython will scan its internal list of magic functions and call one if
+ it exists.
+ With automagic on you can then just type '
+\family typewriter
+cd mydir
+\family default
+' to go to directory '
+\family typewriter
+mydir
+\family default
+'.
+ The automagic system has the lowest possible precedence in name searches,
+ so defining an identifier with the same name as an existing magic function
+ will shadow it for automagic use.
+ You can still access the shadowed magic function by explicitly using the
+ 
+\family typewriter
+%
+\family default
+ character at the beginning of the line.
+\end_layout
+
+\begin_layout Standard
+An example (with automagic on) should clarify all this:
+\end_layout
+
+\begin_layout LyX-Code
+In [1]: cd ipython # %cd is called by automagic
+\end_layout
+
+\begin_layout LyX-Code
+/home/fperez/ipython
+\end_layout
+
+\begin_layout LyX-Code
+In [2]: cd=1 # now cd is just a variable
+\end_layout
+
+\begin_layout LyX-Code
+In [3]: cd ..
+ # and doesn't work as a function anymore
+\end_layout
+
+\begin_layout LyX-Code
+------------------------------------------------------------
+\end_layout
+
+\begin_layout LyX-Code
+    File "<console>", line 1
+\end_layout
+
+\begin_layout LyX-Code
+      cd ..
+\end_layout
+
+\begin_layout LyX-Code
+          ^
+\end_layout
+
+\begin_layout LyX-Code
+SyntaxError: invalid syntax
+\end_layout
+
+\begin_layout LyX-Code
+
+\end_layout
+
+\begin_layout LyX-Code
+In [4]: %cd ..
+ # but %cd always works
+\end_layout
+
+\begin_layout LyX-Code
+/home/fperez
+\end_layout
+
+\begin_layout LyX-Code
+In [5]: del cd # if you remove the cd variable
+\end_layout
+
+\begin_layout LyX-Code
+In [6]: cd ipython # automagic can work again
+\end_layout
+
+\begin_layout LyX-Code
+/home/fperez/ipython
+\end_layout
+
+\begin_layout Standard
+You can define your own magic functions to extend the system.
+ The following example defines a new magic command, 
+\family typewriter
+%impall
+\family default
+:
+\end_layout
+
+\begin_layout LyX-Code
+import IPython.ipapi 
+\end_layout
+
+\begin_layout LyX-Code
+ip = IPython.ipapi.get()
+\end_layout
+
+\begin_layout LyX-Code
+
+\end_layout
+
+\begin_layout LyX-Code
+def doimp(self, arg):
+\end_layout
+
+\begin_layout LyX-Code
+    ip = self.api
+\end_layout
+
+\begin_layout LyX-Code
+    ip.ex("import %s; reload(%s); from %s import *" % (
+\end_layout
+
+\begin_layout LyX-Code
+    arg,arg,arg)
+\end_layout
+
+\begin_layout LyX-Code
+    )
+\end_layout
+
+\begin_layout LyX-Code
+ip.expose_magic('impall', doimp)
+\end_layout
+
+\begin_layout Standard
+You can also define your own aliased names for magic functions.
+ In your 
+\family typewriter
+ipythonrc
+\family default
+ file, placing a line like:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+execute __IP.magic_cl = __IP.magic_clear
+\end_layout
+
+\begin_layout Standard
+will define 
+\family typewriter
+%cl
+\family default
+ as a new name for 
+\family typewriter
+%clear
+\family default
+.
+\end_layout
+
+\begin_layout Standard
+Type 
+\family typewriter
+%magic
+\family default
+ for more information, including a list of all available magic functions
+ at any time and their docstrings.
+ You can also type 
+\family typewriter
+%magic_function_name?
+\family default
+ (see sec.
+ 
+\begin_inset LatexCommand \ref{sec:dyn-object-info}
+
+\end_inset
+
+ for information on the 
+\family typewriter
+'?'
+\family default
+ system) to get information about any particular magic function you are
+ interested in.
+\end_layout
+
+\begin_layout Subsubsection
+Magic commands
+\end_layout
+
+\begin_layout Standard
+The rest of this section is automatically generated for each release from
+ the docstrings in the IPython code.
+ Therefore the formatting is somewhat minimal, but this method has the advantage
+ of having information always in sync with the code.
+\end_layout
+
+\begin_layout Standard
+A list of all the magic commands available in IPython's 
+\emph on
+default
+\emph default
+ installation follows.
+ This is similar to what you'll see by simply typing 
+\family typewriter
+%magic
+\family default
+ at the prompt, but that will also give you information about magic commands
+ you may have added as part of your personal customizations.
+\end_layout
+
+\begin_layout Standard
+\begin_inset Include \input{magic.tex}
+preview false
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Subsection
+Access to the standard Python help
+\end_layout
+
+\begin_layout Standard
+As of Python 2.1, a help system is available with access to object docstrings
+ and the Python manuals.
+ Simply type 
+\family typewriter
+'help'
+\family default
+ (no quotes) to access it.
+ You can also type 
+\family typewriter
+help(object)
+\family default
+ to obtain information about a given object, and 
+\family typewriter
+help('keyword')
+\family default
+ for information on a keyword.
+ As noted in sec.
+ 
+\begin_inset LatexCommand \ref{sec:help-access}
+
+\end_inset
+
+, you need to properly configure your environment variable 
+\family typewriter
+PYTHONDOCS
+\family default
+ for this feature to work correctly.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:dyn-object-info}
+
+\end_inset
+
+Dynamic object information
+\end_layout
+
+\begin_layout Standard
+Typing 
+\family typewriter
+?word
+\family default
+ or 
+\family typewriter
+word?
+\family default
+ prints detailed information about an object.
+ If certain strings in the object are too long (docstrings, code, etc.) they
+ get snipped in the center for brevity.
+ This system gives access variable types and values, full source code for
+ any object (if available), function prototypes and other useful information.
+\end_layout
+
+\begin_layout Standard
+Typing 
+\family typewriter
+??word
+\family default
+ or 
+\family typewriter
+word??
+\family default
+ gives access to the full information without snipping long strings.
+ Long strings are sent to the screen through the 
+\family typewriter
+less
+\family default
+ pager if longer than the screen and printed otherwise.
+ On systems lacking the 
+\family typewriter
+less
+\family default
+ command, IPython uses a very basic internal pager.
+\end_layout
+
+\begin_layout Standard
+The following magic functions are particularly useful for gathering information
+ about your working environment.
+ You can get more details by typing 
+\family typewriter
+%magic
+\family default
+ or querying them individually (use 
+\family typewriter
+%function_name?
+\family default
+ with or without the 
+\family typewriter
+%
+\family default
+), this is just a summary:
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+%pdoc\InsetSpace ~
+<object>
+\family default
+\series default
+: Print (or run through a pager if too long) the docstring for an object.
+ If the given object is a class, it will print both the class and the constructo
+r docstrings.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+%pdef\InsetSpace ~
+<object>
+\family default
+\series default
+: Print the definition header for any callable object.
+ If the object is a class, print the constructor information.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+%psource\InsetSpace ~
+<object>
+\family default
+\series default
+: Print (or run through a pager if too long) the source code for an object.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+%pfile\InsetSpace ~
+<object>
+\family default
+\series default
+: Show the entire source file where an object was defined via a pager, opening
+ it at the line where the object definition begins.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+%who/%whos
+\family default
+\series default
+: These functions give information about identifiers you have defined interactiv
+ely (not things you loaded or defined in your configuration files).
+ 
+\family typewriter
+%who
+\family default
+ just prints a list of identifiers and 
+\family typewriter
+%whos
+\family default
+ prints a table with some basic details about each identifier.
+\end_layout
+
+\begin_layout Standard
+Note that the dynamic object information functions (
+\family typewriter
+?/??, %pdoc, %pfile, %pdef, %psource
+\family default
+) give you access to documentation even on things which are not really defined
+ as separate identifiers.
+ Try for example typing 
+\family typewriter
+{}.get?
+\family default
+ or after doing 
+\family typewriter
+import os
+\family default
+, type 
+\family typewriter
+os.path.abspath??
+\family default
+.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:readline}
+
+\end_inset
+
+Readline-based features
+\end_layout
+
+\begin_layout Standard
+These features require the GNU readline library, so they won't work if your
+ Python installation lacks readline support.
+ We will first describe the default behavior IPython uses, and then how
+ to change it to suit your preferences.
+\end_layout
+
+\begin_layout Subsubsection
+Command line completion
+\end_layout
+
+\begin_layout Standard
+At any time, hitting TAB will complete any available python commands or
+ variable names, and show you a list of the possible completions if there's
+ no unambiguous one.
+ It will also complete filenames in the current directory if no python names
+ match what you've typed so far.
+\end_layout
+
+\begin_layout Subsubsection
+Search command history
+\end_layout
+
+\begin_layout Standard
+IPython provides two ways for searching through previous input and thus
+ reduce the need for repetitive typing:
+\end_layout
+
+\begin_layout Enumerate
+Start typing, and then use 
+\family typewriter
+Ctrl-p
+\family default
+ (previous,up) and 
+\family typewriter
+Ctrl-n
+\family default
+ (next,down) to search through only the history items that match what you've
+ typed so far.
+ If you use 
+\family typewriter
+Ctrl-p/Ctrl-n
+\family default
+ at a blank prompt, they just behave like normal arrow keys.
+\end_layout
+
+\begin_layout Enumerate
+Hit 
+\family typewriter
+Ctrl-r
+\family default
+: opens a search prompt.
+ Begin typing and the system searches your history for lines that contain
+ what you've typed so far, completing as much as it can.
+\end_layout
+
+\begin_layout Subsubsection
+Persistent command history across sessions
+\end_layout
+
+\begin_layout Standard
+IPython will save your input history when it leaves and reload it next time
+ you restart it.
+ By default, the history file is named 
+\family typewriter
+$IPYTHONDIR/history
+\family default
+, but if you've loaded a named profile, '
+\family typewriter
+-PROFILE_NAME
+\family default
+' is appended to the name.
+ This allows you to keep separate histories related to various tasks: commands
+ related to numerical work will not be clobbered by a system shell history,
+ for example.
+\end_layout
+
+\begin_layout Subsubsection
+Autoindent
+\end_layout
+
+\begin_layout Standard
+IPython can recognize lines ending in ':' and indent the next line, while
+ also un-indenting automatically after 'raise' or 'return'.
+ 
+\end_layout
+
+\begin_layout Standard
+This feature uses the readline library, so it will honor your 
+\family typewriter
+~/.inputrc
+\family default
+ configuration (or whatever file your 
+\family typewriter
+INPUTRC
+\family default
+ variable points to).
+ Adding the following lines to your 
+\family typewriter
+.inputrc
+\family default
+ file can make indenting/unindenting more convenient (
+\family typewriter
+M-i
+\family default
+ indents, 
+\family typewriter
+M-u
+\family default
+ unindents):
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+$if Python
+\newline
+"
+\backslash
+M-i": "\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+" 
+\newline
+"
+\backslash
+M-u": "
+\backslash
+d
+\backslash
+d
+\backslash
+d
+\backslash
+d" 
+\newline
+$endif
+\end_layout
+
+\begin_layout Standard
+Note that there are 4 spaces between the quote marks after 
+\family typewriter
+"M-i"
+\family default
+ above.
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+Warning:
+\series default
+ this feature is ON by default, but it can cause problems with the pasting
+ of multi-line indented code (the pasted code gets re-indented on each line).
+ A magic function 
+\family typewriter
+%autoindent
+\family default
+ allows you to toggle it on/off at runtime.
+ You can also disable it permanently on in your 
+\family typewriter
+ipythonrc
+\family default
+ file (set 
+\family typewriter
+autoindent 0
+\family default
+).
+\end_layout
+
+\begin_layout Subsubsection
+Customizing readline behavior
+\end_layout
+
+\begin_layout Standard
+All these features are based on the GNU readline library, which has an extremely
+ customizable interface.
+ Normally, readline is configured via a file which defines the behavior
+ of the library; the details of the syntax for this can be found in the
+ readline documentation available with your system or on the Internet.
+ IPython doesn't read this file (if it exists) directly, but it does support
+ passing to readline valid options via a simple interface.
+ In brief, you can customize readline by setting the following options in
+ your 
+\family typewriter
+ipythonrc
+\family default
+ configuration file (note that these options can 
+\emph on
+not
+\emph default
+ be specified at the command line):
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+readline_parse_and_bind:
+\family default
+\series default
+ this option can appear as many times as you want, each time defining a
+ string to be executed via a 
+\family typewriter
+readline.parse_and_bind()
+\family default
+ command.
+ The syntax for valid commands of this kind can be found by reading the
+ documentation for the GNU readline library, as these commands are of the
+ kind which readline accepts in its configuration file.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+readline_remove_delims:
+\family default
+\series default
+ a string of characters to be removed from the default word-delimiters list
+ used by readline, so that completions may be performed on strings which
+ contain them.
+ Do not change the default value unless you know what you're doing.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+readline_omit__names
+\family default
+\series default
+: when tab-completion is enabled, hitting 
+\family typewriter
+<tab>
+\family default
+ after a '
+\family typewriter
+.
+\family default
+' in a name will complete all attributes of an object, including all the
+ special methods whose names include double underscores (like 
+\family typewriter
+__getitem__
+\family default
+ or 
+\family typewriter
+__class__
+\family default
+).
+ If you'd rather not see these names by default, you can set this option
+ to 1.
+ Note that even when this option is set, you can still see those names by
+ explicitly typing a 
+\family typewriter
+_
+\family default
+ after the period and hitting 
+\family typewriter
+<tab>
+\family default
+: '
+\family typewriter
+name._<tab>
+\family default
+' will always complete attribute names starting with '
+\family typewriter
+_
+\family default
+'.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+\InsetSpace ~
+ This option is off by default so that new users see all attributes of any
+ objects they are dealing with.
+\end_layout
+
+\begin_layout Standard
+You will find the default values along with a corresponding detailed explanation
+ in your 
+\family typewriter
+ipythonrc
+\family default
+ file.
+\end_layout
+
+\begin_layout Subsection
+Session logging and restoring
+\end_layout
+
+\begin_layout Standard
+You can log all input from a session either by starting IPython with the
+ command line switches 
+\family typewriter
+-log
+\family default
+ or 
+\family typewriter
+-logfile 
+\family default
+(see sec.
+ 
+\begin_inset LatexCommand \ref{sec:cmd-line-opts}
+
+\end_inset
+
+)or by activating the logging at any moment with the magic function 
+\family typewriter
+%logstart
+\family default
+.
+ 
+\end_layout
+
+\begin_layout Standard
+Log files can later be reloaded with the 
+\family typewriter
+-logplay
+\family default
+ option and IPython will attempt to 'replay' the log by executing all the
+ lines in it, thus restoring the state of a previous session.
+ This feature is not quite perfect, but can still be useful in many cases.
+\end_layout
+
+\begin_layout Standard
+The log files can also be used as a way to have a permanent record of any
+ code you wrote while experimenting.
+ Log files are regular text files which you can later open in your favorite
+ text editor to extract code or to 'clean them up' before using them to
+ replay a session.
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+%logstart
+\family default
+ function for activating logging in mid-session is used as follows:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+%logstart [log_name [log_mode]]
+\end_layout
+
+\begin_layout Standard
+If no name is given, it defaults to a file named 
+\family typewriter
+'log'
+\family default
+ in your IPYTHONDIR directory, in 
+\family typewriter
+'rotate'
+\family default
+ mode (see below).
+\end_layout
+
+\begin_layout Standard
+'
+\family typewriter
+%logstart name
+\family default
+' saves to file 
+\family typewriter
+'name'
+\family default
+ in 
+\family typewriter
+'backup'
+\family default
+ mode.
+ It saves your history up to that point and then continues logging.
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+%logstart
+\family default
+ takes a second optional parameter: logging mode.
+ This can be one of (note that the modes are given unquoted):
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+over
+\family default
+: overwrite existing 
+\family typewriter
+log_name
+\family default
+.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+backup
+\family default
+: rename (if exists) to 
+\family typewriter
+log_name~
+\family default
+ and start 
+\family typewriter
+log_name
+\family default
+.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+append
+\family default
+: well, that says it.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+rotate
+\family default
+: create rotating logs 
+\family typewriter
+log_name
+\family default
+.
+\family typewriter
+1~
+\family default
+, 
+\family typewriter
+log_name.2~
+\family default
+, etc.
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+%logoff
+\family default
+ and 
+\family typewriter
+%logon
+\family default
+ functions allow you to temporarily stop and resume logging to a file which
+ had previously been started with 
+\family typewriter
+%logstart
+\family default
+.
+ They will fail (with an explanation) if you try to use them before logging
+ has been started.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sub:System-shell-access}
+
+\end_inset
+
+System shell access
+\end_layout
+
+\begin_layout Standard
+Any input line beginning with a 
+\family typewriter
+!
+\family default
+ character is passed verbatim (minus the 
+\family typewriter
+!
+\family default
+, of course) to the underlying operating system.
+ For example, typing 
+\family typewriter
+!ls
+\family default
+ will run 
+\family typewriter
+'ls'
+\family default
+ in the current directory.
+\end_layout
+
+\begin_layout Subsubsection
+Manual capture of command output
+\end_layout
+
+\begin_layout Standard
+If the input line begins with 
+\emph on
+two
+\emph default
+ exclamation marks, 
+\family typewriter
+!!
+\family default
+, the command is executed but its output is captured and returned as a python
+ list, split on newlines.
+ Any output sent by the subprocess to standard error is printed separately,
+ so that the resulting list only captures standard output.
+ The 
+\family typewriter
+!!
+\family default
+ syntax is a shorthand for the 
+\family typewriter
+%sx
+\family default
+ magic command.
+\end_layout
+
+\begin_layout Standard
+Finally, the 
+\family typewriter
+%sc
+\family default
+ magic (short for `shell capture') is similar to 
+\family typewriter
+%sx
+\family default
+, but allowing more fine-grained control of the capture details, and storing
+ the result directly into a named variable.
+\end_layout
+
+\begin_layout Standard
+See Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:magic}
+
+\end_inset
+
+ for details on the magics 
+\family typewriter
+%sc
+\family default
+ and 
+\family typewriter
+%sx
+\family default
+, or use IPython's own help (
+\family typewriter
+sc?
+\family default
+ and 
+\family typewriter
+sx?
+\family default
+) for further details.
+\end_layout
+
+\begin_layout Standard
+IPython also allows you to expand the value of python variables when making
+ system calls.
+ Any python variable or expression which you prepend with 
+\family typewriter
+$
+\family default
+ will get expanded before the system call is made.
+ 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [1]: pyvar='Hello world'
+\newline
+In [2]: !echo "A python variable: $pyvar" 
+\newline
+A python
+ variable: Hello world
+\end_layout
+
+\begin_layout Standard
+If you want the shell to actually see a literal 
+\family typewriter
+$
+\family default
+, you need to type it twice:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [3]: !echo "A system variable: $$HOME" 
+\newline
+A system variable: /home/fperez
+\end_layout
+
+\begin_layout Standard
+You can pass arbitrary expressions, though you'll need to delimit them with
+ 
+\family typewriter
+{}
+\family default
+ if there is ambiguity as to the extent of the expression:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [5]: x=10
+\newline
+In [6]: y=20
+\newline
+In [13]: !echo $x+y 
+\newline
+10+y 
+\newline
+In [7]: !echo ${x+y} 
+\newline
+30
+ 
+\end_layout
+
+\begin_layout Standard
+Even object attributes can be expanded:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [12]: !echo $sys.argv 
+\newline
+[/home/fperez/usr/bin/ipython] 
+\end_layout
+
+\begin_layout Subsection
+System command aliases
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+%alias
+\family default
+ magic function and the 
+\family typewriter
+alias
+\family default
+ option in the 
+\family typewriter
+ipythonrc
+\family default
+ configuration file allow you to define magic functions which are in fact
+ system shell commands.
+ These aliases can have parameters.
+ 
+\end_layout
+
+\begin_layout Standard
+'
+\family typewriter
+%alias alias_name cmd
+\family default
+' defines '
+\family typewriter
+alias_name
+\family default
+' as an alias for '
+\family typewriter
+cmd
+\family default
+' 
+\end_layout
+
+\begin_layout Standard
+Then, typing '
+\family typewriter
+%alias_name params
+\family default
+' will execute the system command '
+\family typewriter
+cmd params
+\family default
+' (from your underlying operating system).
+ 
+\end_layout
+
+\begin_layout Standard
+You can also define aliases with parameters using 
+\family typewriter
+%s
+\family default
+ specifiers (one per parameter).
+ The following example defines the 
+\family typewriter
+%parts
+\family default
+ function as an alias to the command '
+\family typewriter
+echo first %s second %s
+\family default
+' where each 
+\family typewriter
+%s
+\family default
+ will be replaced by a positional parameter to the call to 
+\family typewriter
+%parts:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [1]: alias parts echo first %s second %s
+\newline
+In [2]: %parts A B
+\newline
+first A second
+ B 
+\newline
+In [3]: %parts A 
+\newline
+Incorrect number of arguments: 2 expected.
+ 
+\newline
+parts is an alias to: 'echo first %s second %s' 
+\end_layout
+
+\begin_layout Standard
+If called with no parameters, 
+\family typewriter
+%alias
+\family default
+ prints the table of currently defined aliases.
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+%rehash/rehashx
+\family default
+ magics allow you to load your entire 
+\family typewriter
+$PATH
+\family default
+ as ipython aliases.
+ See their respective docstrings (or sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:magic}
+
+\end_inset
+
+ for further details).
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:dreload}
+
+\end_inset
+
+Recursive reload
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+dreload
+\family default
+ function does a recursive reload of a module: changes made to the module
+ since you imported will actually be available without having to exit.
+\end_layout
+
+\begin_layout Subsection
+Verbose and colored exception traceback printouts
+\end_layout
+
+\begin_layout Standard
+IPython provides the option to see very detailed exception tracebacks, which
+ can be especially useful when debugging large programs.
+ You can run any Python file with the 
+\family typewriter
+%run
+\family default
+ function to benefit from these detailed tracebacks.
+ Furthermore, both normal and verbose tracebacks can be colored (if your
+ terminal supports it) which makes them much easier to parse visually.
+\end_layout
+
+\begin_layout Standard
+See the magic 
+\family typewriter
+xmode
+\family default
+ and 
+\family typewriter
+colors
+\family default
+ functions for details (just type 
+\family typewriter
+%magic
+\family default
+).
+\end_layout
+
+\begin_layout Standard
+These features are basically a terminal version of Ka-Ping Yee's 
+\family typewriter
+cgitb
+\family default
+ module, now part of the standard Python library.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:cache_input}
+
+\end_inset
+
+Input caching system
+\end_layout
+
+\begin_layout Standard
+IPython offers numbered prompts (In/Out) with input and output caching.
+ All input is saved and can be retrieved as variables (besides the usual
+ arrow key recall).
+\end_layout
+
+\begin_layout Standard
+The following GLOBAL variables always exist (so don't overwrite them!):
+ 
+\family typewriter
+_i
+\family default
+: stores previous input.
+ 
+\family typewriter
+_ii
+\family default
+: next previous.
+ 
+\family typewriter
+_iii
+\family default
+: next-next previous.
+ 
+\family typewriter
+_ih
+\family default
+ : a list of all input 
+\family typewriter
+_ih[n]
+\family default
+ is the input from line 
+\family typewriter
+n
+\family default
+ and this list is aliased to the global variable 
+\family typewriter
+In
+\family default
+.
+ If you overwrite 
+\family typewriter
+In
+\family default
+ with a variable of your own, you can remake the assignment to the internal
+ list with a simple 
+\family typewriter
+'In=_ih'
+\family default
+.
+\end_layout
+
+\begin_layout Standard
+Additionally, global variables named 
+\family typewriter
+_i<n>
+\family default
+ are dynamically created (
+\family typewriter
+<n>
+\family default
+ being the prompt counter), such that 
+\newline
+
+\family typewriter
+_i<n> == _ih[<n>] == In[<n>].
+\end_layout
+
+\begin_layout Standard
+For example, what you typed at prompt 14 is available as 
+\family typewriter
+_i14,
+\family default
+ 
+\family typewriter
+_ih[14]
+\family default
+ and 
+\family typewriter
+In[14]
+\family default
+.
+\end_layout
+
+\begin_layout Standard
+This allows you to easily cut and paste multi line interactive prompts by
+ printing them out: they print like a clean string, without prompt characters.
+ You can also manipulate them like regular variables (they are strings),
+ modify or exec them (typing 
+\family typewriter
+'exec _i9'
+\family default
+ will re-execute the contents of input prompt 9, '
+\family typewriter
+exec In[9:14]+In[18]
+\family default
+' will re-execute lines 9 through 13 and line 18).
+\end_layout
+
+\begin_layout Standard
+You can also re-execute multiple lines of input easily by using the magic
+ 
+\family typewriter
+%macro
+\family default
+ function (which automates the process and allows re-execution without having
+ to type '
+\family typewriter
+exec
+\family default
+' every time).
+ The macro system also allows you to re-execute previous lines which include
+ magic function calls (which require special processing).
+ Type 
+\family typewriter
+%macro?
+\family default
+ or see sec.
+ 
+\begin_inset LatexCommand \ref{sec:magic}
+
+\end_inset
+
+ for more details on the macro system.
+\end_layout
+
+\begin_layout Standard
+A history function 
+\family typewriter
+%hist
+\family default
+ allows you to see any part of your input history by printing a range of
+ the 
+\family typewriter
+_i
+\family default
+ variables.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:cache_output}
+
+\end_inset
+
+Output caching system
+\end_layout
+
+\begin_layout Standard
+For output that is returned from actions, a system similar to the input
+ cache exists but using 
+\family typewriter
+_
+\family default
+ instead of 
+\family typewriter
+_i
+\family default
+.
+ Only actions that produce a result (NOT assignments, for example) are cached.
+ If you are familiar with Mathematica, IPython's 
+\family typewriter
+_
+\family default
+ variables behave exactly like Mathematica's 
+\family typewriter
+%
+\family default
+ variables.
+\end_layout
+
+\begin_layout Standard
+The following GLOBAL variables always exist (so don't overwrite them!):
+ 
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+_
+\family default
+\series default
+ (a 
+\emph on
+single
+\emph default
+ underscore) : stores previous output, like Python's default interpreter.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+__
+\family default
+\series default
+ (two underscores): next previous.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+___
+\family default
+\series default
+ (three underscores): next-next previous.
+\end_layout
+
+\begin_layout Standard
+Additionally, global variables named 
+\family typewriter
+_<n> 
+\family default
+are dynamically created (
+\family typewriter
+<n>
+\family default
+ being the prompt counter), such that the result of output 
+\family typewriter
+<n>
+\family default
+ is always available as 
+\family typewriter
+_<n>
+\family default
+ (don't use the angle brackets, just the number, e.g.
+ 
+\family typewriter
+_21
+\family default
+).
+\end_layout
+
+\begin_layout Standard
+These global variables are all stored in a global dictionary (not a list,
+ since it only has entries for lines which returned a result) available
+ under the names 
+\family typewriter
+_oh
+\family default
+ and 
+\family typewriter
+Out
+\family default
+ (similar to 
+\family typewriter
+_ih
+\family default
+ and 
+\family typewriter
+In
+\family default
+).
+ So the output from line 12 can be obtained as 
+\family typewriter
+_12
+\family default
+, 
+\family typewriter
+Out[12]
+\family default
+ or 
+\family typewriter
+_oh[12]
+\family default
+.
+ If you accidentally overwrite the 
+\family typewriter
+Out
+\family default
+ variable you can recover it by typing 
+\family typewriter
+'Out=_oh
+\family default
+' at the prompt.
+\end_layout
+
+\begin_layout Standard
+This system obviously can potentially put heavy memory demands on your system,
+ since it prevents Python's garbage collector from removing any previously
+ computed results.
+ You can control how many results are kept in memory with the option (at
+ the command line or in your 
+\family typewriter
+ipythonrc
+\family default
+ file) 
+\family typewriter
+cache_size
+\family default
+.
+ If you set it to 0, the whole system is completely disabled and the prompts
+ revert to the classic 
+\family typewriter
+'>>>'
+\family default
+ of normal Python.
+\end_layout
+
+\begin_layout Subsection
+Directory history
+\end_layout
+
+\begin_layout Standard
+Your history of visited directories is kept in the global list 
+\family typewriter
+_dh
+\family default
+, and the magic 
+\family typewriter
+%cd
+\family default
+ command can be used to go to any entry in that list.
+ The 
+\family typewriter
+%dhist
+\family default
+ command allows you to view this history.
+\end_layout
+
+\begin_layout Subsection
+Automatic parentheses and quotes
+\end_layout
+
+\begin_layout Standard
+These features were adapted from Nathan Gray's LazyPython.
+ They are meant to allow less typing for common situations.
+\end_layout
+
+\begin_layout Subsubsection
+Automatic parentheses
+\end_layout
+
+\begin_layout Standard
+Callable objects (i.e.
+ functions, methods, etc) can be invoked like this (notice the commas between
+ the arguments):
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+>>> callable_ob arg1, arg2, arg3 
+\end_layout
+
+\begin_layout Standard
+and the input will be translated to this: 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+--> callable_ob(arg1, arg2, arg3) 
+\end_layout
+
+\begin_layout Standard
+You can force automatic parentheses by using '/' as the first character
+ of a line.
+ For example:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+>>> /globals # becomes 'globals()' 
+\end_layout
+
+\begin_layout Standard
+Note that the '/' MUST be the first character on the line! This won't work:
+ 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+>>> print /globals # syntax error
+\end_layout
+
+\begin_layout Standard
+In most cases the automatic algorithm should work, so you should rarely
+ need to explicitly invoke /.
+ One notable exception is if you are trying to call a function with a list
+ of tuples as arguments (the parenthesis will confuse IPython): 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [1]: zip (1,2,3),(4,5,6) # won't work 
+\end_layout
+
+\begin_layout Standard
+but this will work: 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [2]: /zip (1,2,3),(4,5,6)
+\newline
+------> zip ((1,2,3),(4,5,6)) 
+\newline
+Out[2]= [(1, 4),
+ (2, 5), (3, 6)] 
+\end_layout
+
+\begin_layout Standard
+IPython tells you that it has altered your command line by displaying the
+ new command line preceded by 
+\family typewriter
+-->
+\family default
+.
+ e.g.: 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [18]: callable list
+\newline
+-------> callable (list)
+\end_layout
+
+\begin_layout Subsubsection
+Automatic quoting 
+\end_layout
+
+\begin_layout Standard
+You can force automatic quoting of a function's arguments by using 
+\family typewriter
+`,'
+\family default
+ or 
+\family typewriter
+`;'
+\family default
+ as the first character of a line.
+ For example: 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+>>> ,my_function /home/me # becomes my_function("/home/me") 
+\end_layout
+
+\begin_layout Standard
+If you use 
+\family typewriter
+`;'
+\family default
+ instead, the whole argument is quoted as a single string (while 
+\family typewriter
+`,'
+\family default
+ splits on whitespace):
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+>>> ,my_function a b c # becomes my_function("a","b","c")
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+>>> ;my_function a b c # becomes my_function("a b c")
+\end_layout
+
+\begin_layout Standard
+Note that the `
+\family typewriter
+,
+\family default
+' or `
+\family typewriter
+;
+\family default
+' MUST be the first character on the line! This won't work: 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+>>> x = ,my_function /home/me # syntax error
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:customization}
+
+\end_inset
+
+Customization
+\end_layout
+
+\begin_layout Standard
+As we've already mentioned, IPython reads a configuration file which can
+ be specified at the command line (
+\family typewriter
+-rcfile
+\family default
+) or which by default is assumed to be called 
+\family typewriter
+ipythonrc
+\family default
+.
+ Such a file is looked for in the current directory where IPython is started
+ and then in your 
+\family typewriter
+IPYTHONDIR
+\family default
+, which allows you to have local configuration files for specific projects.
+ In this section we will call these types of configuration files simply
+ rcfiles (short for resource configuration file).
+\end_layout
+
+\begin_layout Standard
+The syntax of an rcfile is one of key-value pairs separated by whitespace,
+ one per line.
+ Lines beginning with a 
+\family typewriter
+#
+\family default
+ are ignored as comments, but comments can 
+\series bold
+not
+\series default
+ be put on lines with data (the parser is fairly primitive).
+ Note that these are not python files, and this is deliberate, because it
+ allows us to do some things which would be quite tricky to implement if
+ they were normal python files.
+\end_layout
+
+\begin_layout Standard
+First, an rcfile can contain permanent default values for almost all command
+ line options (except things like 
+\family typewriter
+-help
+\family default
+ or 
+\family typewriter
+-Version
+\family default
+).
+ Sec\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:cmd-line-opts}
+
+\end_inset
+
+ contains a description of all command-line options.
+ However, values you explicitly specify at the command line override the
+ values defined in the rcfile.
+\end_layout
+
+\begin_layout Standard
+Besides command line option values, the rcfile can specify values for certain
+ extra special options which are not available at the command line.
+ These options are briefly described below.
+ 
+\end_layout
+
+\begin_layout Standard
+Each of these options may appear as many times as you need it in the file.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+include\InsetSpace ~
+<file1>\InsetSpace ~
+<file2>\InsetSpace ~
+...
+\family default
+\series default
+: you can name 
+\emph on
+other 
+\emph default
+rcfiles you want to recursively load up to 15 levels (don't use the 
+\family typewriter
+<>
+\family default
+ brackets in your names!).
+ This feature allows you to define a 'base' rcfile with general options
+ and special-purpose files which can be loaded only when needed with particular
+ configuration options.
+ To make this more convenient, IPython accepts the 
+\family typewriter
+-profile <name>
+\family default
+ option (abbreviates to 
+\family typewriter
+-p <name
+\family default
+>)
+\family typewriter
+ which
+\family default
+ tells it to look for an rcfile named 
+\family typewriter
+ipythonrc-<name>
+\family default
+.
+ 
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+import_mod\InsetSpace ~
+<mod1>\InsetSpace ~
+<mod2>\InsetSpace ~
+...
+\family default
+\series default
+: import modules with '
+\family typewriter
+import
+\family default
+ 
+\family typewriter
+<mod1>,<mod2>,...
+\family default
+' 
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+import_some\InsetSpace ~
+<mod>\InsetSpace ~
+<f1>\InsetSpace ~
+<f2>\InsetSpace ~
+...
+\family default
+\series default
+: import functions with '
+\family typewriter
+from <mod> import
+\family default
+ 
+\family typewriter
+<f1>,<f2>,...
+\family default
+' 
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+import_all\InsetSpace ~
+<mod1>\InsetSpace ~
+<mod2>\InsetSpace ~
+...
+\family default
+\series default
+: for each module listed import functions with '
+\family typewriter
+from <mod> import *
+\family default
+' 
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+execute\InsetSpace ~
+<python\InsetSpace ~
+code>
+\family default
+\series default
+: give any single-line python code to be executed.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+execfile\InsetSpace ~
+<filename>
+\family default
+\series default
+: execute the python file given with an '
+\family typewriter
+execfile(filename)
+\family default
+' command.
+ Username expansion is performed on the given names.
+ So if you need any amount of extra fancy customization that won't fit in
+ any of the above 'canned' options, you can just put it in a separate python
+ file and execute it.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+
+\family typewriter
+\series bold
+alias\InsetSpace ~
+<alias_def>
+\family default
+\series default
+: this is equivalent to calling '
+\family typewriter
+%alias\InsetSpace ~
+<alias_def>
+\family default
+' at the IPython command line.
+ This way, from within IPython you can do common system tasks without having
+ to exit it or use the 
+\family typewriter
+!
+\family default
+ escape.
+ IPython isn't meant to be a shell replacement, but it is often very useful
+ to be able to do things with files while testing code.
+ This gives you the flexibility to have within IPython any aliases you may
+ be used to under your normal system shell.
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:ipytonrc-sample}
+
+\end_inset
+
+Sample 
+\family typewriter
+ipythonrc
+\family default
+ file
+\end_layout
+
+\begin_layout Standard
+The default rcfile, called 
+\family typewriter
+ipythonrc
+\family default
+ and supplied in your 
+\family typewriter
+IPYTHONDIR 
+\family default
+directory contains lots of comments on all of these options.
+ We reproduce it here for reference:
+\end_layout
+
+\begin_layout Standard
+\begin_inset ERT
+status open
+
+\begin_layout Standard
+
+
+\backslash
+codelist{../IPython/UserConfig/ipythonrc}
+\end_layout
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:prompts}
+
+\end_inset
+
+Fine-tuning your prompt
+\end_layout
+
+\begin_layout Standard
+IPython's prompts can be customized using a syntax similar to that of the
+ 
+\family typewriter
+bash
+\family default
+ shell.
+ Many of 
+\family typewriter
+bash
+\family default
+'s escapes are supported, as well as a few additional ones.
+ We list them below:
+\end_layout
+
+\begin_layout Description
+
+\backslash
+# the prompt/history count number.
+ This escape is automatically wrapped in the coloring codes for the currently
+ active color scheme.
+\end_layout
+
+\begin_layout Description
+
+\backslash
+N the 'naked' prompt/history count number: this is just the number itself,
+ without any coloring applied to it.
+ This lets you produce numbered prompts with your own colors.
+\end_layout
+
+\begin_layout Description
+
+\backslash
+D the prompt/history count, with the actual digits replaced by dots.
+ Used mainly in continuation prompts (prompt_in2)
+\end_layout
+
+\begin_layout Description
+
+\backslash
+w the current working directory
+\end_layout
+
+\begin_layout Description
+
+\backslash
+W the basename of current working directory
+\end_layout
+
+\begin_layout Description
+
+\backslash
+X
+\emph on
+n
+\emph default
+ where 
+\begin_inset Formula $n=0\ldots5.$
+\end_inset
+
+ The current working directory, with 
+\family typewriter
+$HOME
+\family default
+ replaced by 
+\family typewriter
+~
+\family default
+, and filtered out to contain only 
+\begin_inset Formula $n$
+\end_inset
+
+ path elements
+\end_layout
+
+\begin_layout Description
+
+\backslash
+Y
+\emph on
+n
+\emph default
+ Similar to 
+\backslash
+X
+\emph on
+n
+\emph default
+, but with the 
+\begin_inset Formula $n+1$
+\end_inset
+
+ element included if it is 
+\family typewriter
+~
+\family default
+ (this is similar to the behavior of the %c
+\emph on
+n
+\emph default
+ escapes in 
+\family typewriter
+tcsh
+\family default
+)
+\end_layout
+
+\begin_layout Description
+
+\backslash
+u the username of the current user
+\end_layout
+
+\begin_layout Description
+
+\backslash
+$ if the effective UID is 0, a #, otherwise a $
+\end_layout
+
+\begin_layout Description
+
+\backslash
+h the hostname up to the first `.'
+\end_layout
+
+\begin_layout Description
+
+\backslash
+H the hostname
+\end_layout
+
+\begin_layout Description
+
+\backslash
+n a newline
+\end_layout
+
+\begin_layout Description
+
+\backslash
+r a carriage return
+\end_layout
+
+\begin_layout Description
+
+\backslash
+v IPython version string
+\end_layout
+
+\begin_layout Standard
+In addition to these, ANSI color escapes can be insterted into the prompts,
+ as 
+\family typewriter
+
+\backslash
+C_
+\emph on
+ColorName
+\family default
+\emph default
+.
+ The list of valid color names is: Black, Blue, Brown, Cyan, DarkGray, Green,
+ LightBlue, LightCyan, LightGray, LightGreen, LightPurple, LightRed, NoColor,
+ Normal, Purple, Red, White, Yellow.
+\end_layout
+
+\begin_layout Standard
+Finally, IPython supports the evaluation of arbitrary expressions in your
+ prompt string.
+ The prompt strings are evaluated through the syntax of PEP 215, but basically
+ you can use 
+\family typewriter
+$x.y
+\family default
+ to expand the value of 
+\family typewriter
+x.y
+\family default
+, and for more complicated expressions you can use braces: 
+\family typewriter
+${foo()+x}
+\family default
+ will call function 
+\family typewriter
+foo
+\family default
+ and add to it the value of 
+\family typewriter
+x
+\family default
+, before putting the result into your prompt.
+ For example, using 
+\newline
+
+\family typewriter
+prompt_in1 '${commands.getoutput("uptime")}
+\backslash
+nIn [
+\backslash
+#]: '
+\newline
+
+\family default
+will print the result of the uptime command on each prompt (assuming the
+ 
+\family typewriter
+commands
+\family default
+ module has been imported in your 
+\family typewriter
+ipythonrc
+\family default
+ file).
+\end_layout
+
+\begin_layout Subsubsection
+Prompt examples
+\end_layout
+
+\begin_layout Standard
+The following options in an ipythonrc file will give you IPython's default
+ prompts:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+prompt_in1 'In [
+\backslash
+#]:'
+\newline
+prompt_in2 '\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+.
+\backslash
+D.:'
+\newline
+prompt_out 'Out[
+\backslash
+#]:'
+\end_layout
+
+\begin_layout Standard
+which look like this:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [1]: 1+2
+\newline
+Out[1]: 3
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [2]: for i in (1,2,3):
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+...: \InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+print i,
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+...:
+\newline
+1 2 3
+\end_layout
+
+\begin_layout Standard
+These will give you a very colorful prompt with path information:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+#prompt_in1 '
+\backslash
+C_Red
+\backslash
+u
+\backslash
+C_Blue[
+\backslash
+C_Cyan
+\backslash
+Y1
+\backslash
+C_Blue]
+\backslash
+C_LightGreen
+\backslash
+#>'
+\newline
+prompt_in2 ' ..
+\backslash
+D>'
+\newline
+prompt_out '<
+\backslash
+#>' 
+\end_layout
+
+\begin_layout Standard
+which look like this:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+\color red
+fperez
+\color blue
+[
+\color cyan
+~/ipython
+\color blue
+]
+\color green
+1>
+\color none
+ 1+2
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+
+\color red
+<1>
+\color none
+ 3
+\newline
+
+\color red
+fperez
+\color blue
+[
+\color cyan
+~/ipython
+\color blue
+]
+\color green
+2>
+\color none
+ for i in (1,2,3):
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+
+\color green
+...>
+\color none
+ \InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+print i,
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+
+\color green
+...>
+\color none
+
+\newline
+1 2 3
+\end_layout
+
+\begin_layout Standard
+The following shows the usage of dynamic expression evaluation:
+\end_layout
+
+\begin_layout Subsection
+\begin_inset LatexCommand \label{sec:profiles}
+
+\end_inset
+
+IPython profiles
+\end_layout
+
+\begin_layout Standard
+As we already mentioned, IPython supports the 
+\family typewriter
+-profile
+\family default
+ command-line option (see sec.
+ 
+\begin_inset LatexCommand \ref{sec:cmd-line-opts}
+
+\end_inset
+
+).
+ A profile is nothing more than a particular configuration file like your
+ basic 
+\family typewriter
+ipythonrc
+\family default
+ one, but with particular customizations for a specific purpose.
+ When you start IPython with '
+\family typewriter
+ipython -profile <name>
+\family default
+', it assumes that in your 
+\family typewriter
+IPYTHONDIR
+\family default
+ there is a file called 
+\family typewriter
+ipythonrc-<name>
+\family default
+, and loads it instead of the normal 
+\family typewriter
+ipythonrc
+\family default
+.
+\end_layout
+
+\begin_layout Standard
+This system allows you to maintain multiple configurations which load modules,
+ set options, define functions, etc.
+ suitable for different tasks and activate them in a very simple manner.
+ In order to avoid having to repeat all of your basic options (common things
+ that don't change such as your color preferences, for example), any profile
+ can include another configuration file.
+ The most common way to use profiles is then to have each one include your
+ basic 
+\family typewriter
+ipythonrc
+\family default
+ file as a starting point, and then add further customizations.
+\end_layout
+
+\begin_layout Standard
+In sections 
+\begin_inset LatexCommand \ref{sec:syntax-extensions}
+
+\end_inset
+
+ and 
+\begin_inset LatexCommand \ref{sec:Gnuplot}
+
+\end_inset
+
+ we discuss some particular profiles which come as part of the standard
+ IPython distribution.
+ You may also look in your 
+\family typewriter
+IPYTHONDIR
+\family default
+ directory, any file whose name begins with 
+\family typewriter
+ipythonrc-
+\family default
+ is a profile.
+ You can use those as examples for further customizations to suit your own
+ needs.
+\end_layout
+
+\begin_layout Section
+\begin_inset OptArg
+status open
+
+\begin_layout Standard
+IPython as default...
+\end_layout
+
+\end_inset
+
+IPython as your default Python environment
+\end_layout
+
+\begin_layout Standard
+Python honors the environment variable 
+\family typewriter
+PYTHONSTARTUP 
+\family default
+and will execute at startup the file referenced by this variable.
+ If you put at the end of this file the following two lines of code:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+import IPython
+\newline
+IPython.Shell.IPShell().mainloop(sys_exit=1)
+\end_layout
+
+\begin_layout Standard
+then IPython will be your working environment anytime you start Python.
+ The 
+\family typewriter
+sys_exit=1
+\family default
+ is needed to have IPython issue a call to 
+\family typewriter
+sys.exit()
+\family default
+ when it finishes, otherwise you'll be back at the normal Python '
+\family typewriter
+>>>
+\family default
+' prompt
+\begin_inset Foot
+status collapsed
+
+\begin_layout Standard
+Based on an idea by Holger Krekel.
+\end_layout
+
+\end_inset
+
+.
+\end_layout
+
+\begin_layout Standard
+This is probably useful to developers who manage multiple Python versions
+ and don't want to have correspondingly multiple IPython versions.
+ Note that in this mode, there is no way to pass IPython any command-line
+ options, as those are trapped first by Python itself.
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:embed}
+
+\end_inset
+
+Embedding IPython
+\end_layout
+
+\begin_layout Standard
+It is possible to start an IPython instance 
+\emph on
+inside
+\emph default
+ your own Python programs.
+ This allows you to evaluate dynamically the state of your code, operate
+ with your variables, analyze them, etc.
+ Note however that any changes you make to values while in the shell do
+ 
+\emph on
+not
+\emph default
+ propagate back to the running code, so it is safe to modify your values
+ because you won't break your code in bizarre ways by doing so.
+\end_layout
+
+\begin_layout Standard
+This feature allows you to easily have a fully functional python environment
+ for doing object introspection anywhere in your code with a simple function
+ call.
+ In some cases a simple print statement is enough, but if you need to do
+ more detailed analysis of a code fragment this feature can be very valuable.
+\end_layout
+
+\begin_layout Standard
+It can also be useful in scientific computing situations where it is common
+ to need to do some automatic, computationally intensive part and then stop
+ to look at data, plots, etc
+\begin_inset Foot
+status collapsed
+
+\begin_layout Standard
+This functionality was inspired by IDL's combination of the 
+\family typewriter
+stop
+\family default
+ keyword and the 
+\family typewriter
+.continue
+\family default
+ executive command, which I have found very useful in the past, and by a
+ posting on comp.lang.python by cmkl <cmkleffner-AT-gmx.de> on Dec.
+ 06/01 concerning similar uses of pyrepl.
+\end_layout
+
+\end_inset
+
+.
+ Opening an IPython instance will give you full access to your data and
+ functions, and you can resume program execution once you are done with
+ the interactive part (perhaps to stop again later, as many times as needed).
+\end_layout
+
+\begin_layout Standard
+The following code snippet is the bare minimum you need to include in your
+ Python programs for this to work (detailed examples follow later):
+\end_layout
+
+\begin_layout LyX-Code
+from IPython.Shell import IPShellEmbed
+\end_layout
+
+\begin_layout LyX-Code
+ipshell = IPShellEmbed()
+\end_layout
+
+\begin_layout LyX-Code
+ipshell() # this call anywhere in your program will start IPython
+\end_layout
+
+\begin_layout Standard
+You can run embedded instances even in code which is itself being run at
+ the IPython interactive prompt with '
+\family typewriter
+%run\InsetSpace ~
+<filename>
+\family default
+'.
+ Since it's easy to get lost as to where you are (in your top-level IPython
+ or in your embedded one), it's a good idea in such cases to set the in/out
+ prompts to something different for the embedded instances.
+ The code examples below illustrate this.
+\end_layout
+
+\begin_layout Standard
+You can also have multiple IPython instances in your program and open them
+ separately, for example with different options for data presentation.
+ If you close and open the same instance multiple times, its prompt counters
+ simply continue from each execution to the next.
+\end_layout
+
+\begin_layout Standard
+Please look at the docstrings in the 
+\family typewriter
+Shell.py
+\family default
+ module for more details on the use of this system.
+\end_layout
+
+\begin_layout Standard
+The following sample file illustrating how to use the embedding functionality
+ is provided in the examples directory as 
+\family typewriter
+example-embed.py
+\family default
+.
+ It should be fairly self-explanatory:
+\end_layout
+
+\begin_layout Standard
+\begin_inset ERT
+status open
+
+\begin_layout Standard
+
+
+\backslash
+codelist{examples/example-embed.py}
+\end_layout
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Standard
+Once you understand how the system functions, you can use the following
+ code fragments in your programs which are ready for cut and paste:
+\end_layout
+
+\begin_layout Standard
+\begin_inset ERT
+status open
+
+\begin_layout Standard
+
+
+\backslash
+codelist{examples/example-embed-short.py}
+\end_layout
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:using-pdb}
+
+\end_inset
+
+Using the Python debugger (
+\family typewriter
+pdb
+\family default
+)
+\end_layout
+
+\begin_layout Subsection
+Running entire programs via 
+\family typewriter
+pdb
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+pdb
+\family default
+, the Python debugger, is a powerful interactive debugger which allows you
+ to step through code, set breakpoints, watch variables, etc.
+ IPython makes it very easy to start any script under the control of 
+\family typewriter
+pdb
+\family default
+, regardless of whether you have wrapped it into a 
+\family typewriter
+`main()'
+\family default
+ function or not.
+ For this, simply type 
+\family typewriter
+`%run -d myscript'
+\family default
+ at an IPython prompt.
+ See the 
+\family typewriter
+%run
+\family default
+ command's documentation (via 
+\family typewriter
+`%run?'
+\family default
+ or in Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:magic}
+
+\end_inset
+
+) for more details, including how to control where 
+\family typewriter
+pdb
+\family default
+ will stop execution first.
+\end_layout
+
+\begin_layout Standard
+For more information on the use of the 
+\family typewriter
+pdb
+\family default
+ debugger, read the included 
+\family typewriter
+pdb.doc
+\family default
+ file (part of the standard Python distribution).
+ On a stock Linux system it is located at 
+\family typewriter
+/usr/lib/python2.3/pdb.doc
+\family default
+, but the easiest way to read it is by using the 
+\family typewriter
+help()
+\family default
+ function of the 
+\family typewriter
+pdb
+\family default
+ module as follows (in an IPython prompt):
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+In [1]: import pdb
+\newline
+In [2]: pdb.help()
+\end_layout
+
+\begin_layout Standard
+This will load the 
+\family typewriter
+pdb.doc
+\family default
+ document in a file viewer for you automatically.
+\end_layout
+
+\begin_layout Subsection
+Automatic invocation of 
+\family typewriter
+pdb
+\family default
+ on exceptions
+\end_layout
+
+\begin_layout Standard
+IPython, if started with the 
+\family typewriter
+-pdb
+\family default
+ option (or if the option is set in your rc file) can call the Python 
+\family typewriter
+pdb
+\family default
+ debugger every time your code triggers an uncaught exception
+\begin_inset Foot
+status collapsed
+
+\begin_layout Standard
+Many thanks to Christopher Hart for the request which prompted adding this
+ feature to IPython.
+\end_layout
+
+\end_inset
+
+.
+ This feature can also be toggled at any time with the 
+\family typewriter
+%pdb
+\family default
+ magic command.
+ This can be extremely useful in order to find the origin of subtle bugs,
+ because 
+\family typewriter
+pdb
+\family default
+ opens up at the point in your code which triggered the exception, and while
+ your program is at this point `dead', all the data is still available and
+ you can walk up and down the stack frame and understand the origin of the
+ problem.
+\end_layout
+
+\begin_layout Standard
+Furthermore, you can use these debugging facilities both with the embedded
+ IPython mode and without IPython at all.
+ For an embedded shell (see sec.
+ 
+\begin_inset LatexCommand \ref{sec:embed}
+
+\end_inset
+
+), simply call the constructor with 
+\family typewriter
+`-pdb'
+\family default
+ in the argument string and automatically 
+\family typewriter
+pdb
+\family default
+ will be called if an uncaught exception is triggered by your code.
+ 
+\end_layout
+
+\begin_layout Standard
+For stand-alone use of the feature in your programs which do not use IPython
+ at all, put the following lines toward the top of your `main' routine:
+\end_layout
+
+\begin_layout Standard
+\align left
+
+\family typewriter
+import sys,IPython.ultraTB 
+\newline
+sys.excepthook = IPython.ultraTB.FormattedTB(mode=`Verbos
+e', color_scheme=`Linux', call_pdb=1)
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+mode
+\family default
+ keyword can be either 
+\family typewriter
+`Verbose'
+\family default
+ or 
+\family typewriter
+`Plain'
+\family default
+, giving either very detailed or normal tracebacks respectively.
+ The 
+\family typewriter
+color_scheme
+\family default
+ keyword can be one of 
+\family typewriter
+`NoColor'
+\family default
+, 
+\family typewriter
+`Linux'
+\family default
+ (default) or 
+\family typewriter
+`LightBG'
+\family default
+.
+ These are the same options which can be set in IPython with 
+\family typewriter
+-colors
+\family default
+ and 
+\family typewriter
+-xmode
+\family default
+.
+\end_layout
+
+\begin_layout Standard
+This will give any of your programs detailed, colored tracebacks with automatic
+ invocation of 
+\family typewriter
+pdb
+\family default
+.
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:syntax-extensions}
+
+\end_inset
+
+Extensions for syntax processing
+\end_layout
+
+\begin_layout Standard
+This isn't for the faint of heart, because the potential for breaking things
+ is quite high.
+ But it can be a very powerful and useful feature.
+ In a nutshell, you can redefine the way IPython processes the user input
+ line to accept new, special extensions to the syntax without needing to
+ change any of IPython's own code.
+\end_layout
+
+\begin_layout Standard
+In the 
+\family typewriter
+IPython/Extensions
+\family default
+ directory you will find some examples supplied, which we will briefly describe
+ now.
+ These can be used `as is' (and both provide very useful functionality),
+ or you can use them as a starting point for writing your own extensions.
+\end_layout
+
+\begin_layout Subsection
+Pasting of code starting with 
+\family typewriter
+`>>> 
+\family default
+' or 
+\family typewriter
+`...
+ 
+\family default
+'
+\end_layout
+
+\begin_layout Standard
+In the python tutorial it is common to find code examples which have been
+ taken from real python sessions.
+ The problem with those is that all the lines begin with either 
+\family typewriter
+`>>> 
+\family default
+' or 
+\family typewriter
+`...
+ 
+\family default
+', which makes it impossible to paste them all at once.
+ One must instead do a line by line manual copying, carefully removing the
+ leading extraneous characters.
+\end_layout
+
+\begin_layout Standard
+This extension identifies those starting characters and removes them from
+ the input automatically, so that one can paste multi-line examples directly
+ into IPython, saving a lot of time.
+ Please look at the file 
+\family typewriter
+InterpreterPasteInput.py
+\family default
+ in the 
+\family typewriter
+IPython/Extensions
+\family default
+ directory for details on how this is done.
+\end_layout
+
+\begin_layout Standard
+IPython comes with a special profile enabling this feature, called 
+\family typewriter
+tutorial
+\family default
+\emph on
+.
+
+\emph default
+ Simply start IPython via 
+\family typewriter
+`ipython\InsetSpace ~
+-p\InsetSpace ~
+tutorial'
+\family default
+ and the feature will be available.
+ In a normal IPython session you can activate the feature by importing the
+ corresponding module with:
+\newline
+
+\family typewriter
+In [1]: import IPython.Extensions.InterpreterPasteInput
+\end_layout
+
+\begin_layout Standard
+The following is a 'screenshot' of how things work when this extension is
+ on, copying an example from the standard tutorial:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+IPython profile: tutorial
+\newline
+\InsetSpace ~
+
+\newline
+*** Pasting of code with ">>>" or "..." has been enabled.
+\newline
+\InsetSpace ~
+
+\newline
+In
+ [1]: >>> def fib2(n): # return Fibonacci series up to n
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+ ...: ...\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+ """Return a list containing the Fibonacci series up to n."""
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+ ...: ...\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+ result = []
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+ ...: ...\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+ a, b = 0, 1
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+ ...: ...\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+ while b < n:
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+ ...: ...\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+ result.append(b)\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+ # see below
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+ ...: ...\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+ a, b = b, a+b
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+ ...: ...\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+ return result
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+ ...:
+\newline
+\InsetSpace ~
+
+\newline
+In [2]: fib2(10)
+\newline
+Out[2]: [1, 1, 2, 3, 5, 8]
+\end_layout
+
+\begin_layout Standard
+Note that as currently written, this extension does 
+\emph on
+not 
+\emph default
+recognize IPython's prompts for pasting.
+ Those are more complicated, since the user can change them very easily,
+ they involve numbers and can vary in length.
+ One could however extract all the relevant information from the IPython
+ instance and build an appropriate regular expression.
+ This is left as an exercise for the reader.
+\end_layout
+
+\begin_layout Subsection
+Input of physical quantities with units
+\end_layout
+
+\begin_layout Standard
+The module 
+\family typewriter
+PhysicalQInput
+\family default
+ allows a simplified form of input for physical quantities with units.
+ This file is meant to be used in conjunction with the 
+\family typewriter
+PhysicalQInteractive
+\family default
+ module (in the same directory) and 
+\family typewriter
+Physics.PhysicalQuantities
+\family default
+ from Konrad Hinsen's ScientificPython (
+\begin_inset LatexCommand \htmlurl{http://dirac.cnrs-orleans.fr/ScientificPython/}
+
+\end_inset
+
+).
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+Physics.PhysicalQuantities
+\family default
+ module defines 
+\family typewriter
+PhysicalQuantity
+\family default
+ objects, but these must be declared as instances of a class.
+ For example, to define 
+\family typewriter
+v
+\family default
+ as a velocity of 3\InsetSpace ~
+m/s, normally you would write:
+\family typewriter
+
+\newline
+In [1]: v = PhysicalQuantity(3,'m/s')
+\end_layout
+
+\begin_layout Standard
+Using the 
+\family typewriter
+PhysicalQ_Input
+\family default
+ extension this can be input instead as:
+\family typewriter
+
+\newline
+In [1]: v = 3 m/s
+\family default
+
+\newline
+which is much more convenient for interactive use (even though it is blatantly
+ invalid Python syntax).
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+physics
+\family default
+ profile supplied with IPython (enabled via 
+\family typewriter
+'ipython -p physics'
+\family default
+) uses these extensions, which you can also activate with:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+from math import * # math MUST be imported BEFORE PhysicalQInteractive
+\newline
+from
+ IPython.Extensions.PhysicalQInteractive import *
+\newline
+import IPython.Extensions.PhysicalQ
+Input
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:IPython-as-shell}
+
+\end_inset
+
+IPython as a system shell
+\end_layout
+
+\begin_layout Standard
+IPython ships with a special profile called 
+\family typewriter
+pysh
+\family default
+, which you can activate at the command line as 
+\family typewriter
+`ipython -p pysh'
+\family default
+.
+ This loads 
+\family typewriter
+InterpreterExec
+\family default
+, along with some additional facilities and a prompt customized for filesystem
+ navigation.
+\end_layout
+
+\begin_layout Standard
+Note that this does 
+\emph on
+not
+\emph default
+ make IPython a full-fledged system shell.
+ In particular, it has no job control, so if you type Ctrl-Z (under Unix),
+ you'll suspend pysh itself, not the process you just started.
+ 
+\end_layout
+
+\begin_layout Standard
+What the shell profile allows you to do is to use the convenient and powerful
+ syntax of Python to do quick scripting at the command line.
+ Below we describe some of its features.
+\end_layout
+
+\begin_layout Subsection
+Aliases
+\end_layout
+
+\begin_layout Standard
+All of your 
+\family typewriter
+$PATH
+\family default
+ has been loaded as IPython aliases, so you should be able to type any normal
+ system command and have it executed.
+ See 
+\family typewriter
+%alias?
+\family default
+ and 
+\family typewriter
+%unalias?
+\family default
+ for details on the alias facilities.
+ See also 
+\family typewriter
+%rehash?
+\family default
+ and 
+\family typewriter
+%rehashx? 
+\family default
+for details on the mechanism used to load 
+\family typewriter
+$PATH
+\family default
+.
+\end_layout
+
+\begin_layout Subsection
+Special syntax
+\end_layout
+
+\begin_layout Standard
+Any lines which begin with 
+\family typewriter
+`~'
+\family default
+, 
+\family typewriter
+`/'
+\family default
+ and 
+\family typewriter
+`.'
+\family default
+ will be executed as shell commands instead of as Python code.
+ The special escapes below are also recognized.
+ 
+\family typewriter
+!cmd
+\family default
+ is valid in single or multi-line input, all others are only valid in single-lin
+e input:
+\end_layout
+
+\begin_layout Description
+
+\family typewriter
+!cmd
+\family default
+ pass `cmd' directly to the shell 
+\end_layout
+
+\begin_layout Description
+
+\family typewriter
+!!cmd
+\family default
+ execute `cmd' and return output as a list (split on `
+\backslash
+n') 
+\end_layout
+
+\begin_layout Description
+
+\family typewriter
+$var=cmd
+\family default
+ capture output of cmd into var, as a string 
+\end_layout
+
+\begin_layout Description
+
+\family typewriter
+$$var=cmd
+\family default
+ capture output of cmd into var, as a list (split on `
+\backslash
+n')
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+$
+\family default
+/
+\family typewriter
+$$
+\family default
+ syntaxes make Python variables from system output, which you can later
+ use for further scripting.
+ The converse is also possible: when executing an alias or calling to the
+ system via 
+\family typewriter
+!
+\family default
+/
+\family typewriter
+!!
+\family default
+, you can expand any python variable or expression by prepending it with
+ 
+\family typewriter
+$
+\family default
+.
+ Full details of the allowed syntax can be found in Python's PEP 215.
+\end_layout
+
+\begin_layout Standard
+A few brief examples will illustrate these (note that the indentation below
+ may be incorrectly displayed):
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+fperez[~/test]|3> !ls *s.py 
+\newline
+scopes.py strings.py
+\end_layout
+
+\begin_layout Standard
+ls is an internal alias, so there's no need to use 
+\family typewriter
+!
+\family default
+: 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+fperez[~/test]|4> ls *s.py 
+\newline
+scopes.py* strings.py
+\end_layout
+
+\begin_layout Standard
+!!ls will return the output into a Python variable: 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+fperez[~/test]|5> !!ls *s.py 
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+<5> ['scopes.py', 'strings.py'] 
+\newline
+fperez[~/test]|6> print _5 
+\newline
+['scopes.py', 'strings.py
+']
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+$
+\family default
+ and 
+\family typewriter
+$$
+\family default
+ allow direct capture to named variables: 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+fperez[~/test]|7> $astr = ls *s.py 
+\newline
+fperez[~/test]|8> astr 
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+<8> 'scopes.py
+\backslash
+nstrings.py'
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+fperez[~/test]|9> $$alist = ls *s.py 
+\newline
+fperez[~/test]|10> alist 
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+<10> ['scopes.py', 'strings.py']
+\end_layout
+
+\begin_layout Standard
+alist is now a normal python list you can loop over.
+ Using 
+\family typewriter
+$
+\family default
+ will expand back the python values when alias calls are made:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+fperez[~/test]|11> for f in alist: 
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+|..> \InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+print 'file',f, 
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+|..> \InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+wc -l $f 
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+|..> 
+\newline
+file scopes.py 13 scopes.py 
+\newline
+file strings.py 4 strings.py
+\end_layout
+
+\begin_layout Standard
+Note that you may need to protect your variables with braces if you want
+ to append strings to their names.
+ To copy all files in alist to 
+\family typewriter
+.bak
+\family default
+ extensions, you must use: 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+fperez[~/test]|12> for f in alist: 
+\newline
+
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+hspace*{0mm}
+\end_layout
+
+\end_inset
+
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+|..> \InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+\InsetSpace ~
+cp $f ${f}.bak
+\end_layout
+
+\begin_layout Standard
+If you try using 
+\family typewriter
+$f.bak
+\family default
+, you'll get an AttributeError exception saying that your string object
+ doesn't have a 
+\family typewriter
+.bak
+\family default
+ attribute.
+ This is because the 
+\family typewriter
+$
+\family default
+ expansion mechanism allows you to expand full Python expressions: 
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+fperez[~/test]|13> echo "sys.platform is: $sys.platform" 
+\newline
+sys.platform is: linux2
+\end_layout
+
+\begin_layout Standard
+IPython's input history handling is still active, which allows you to rerun
+ a single block of multi-line input by simply using exec: 
+\newline
+
+\family typewriter
+fperez[~/test]|14> $$alist = ls *.eps 
+\newline
+fperez[~/test]|15> exec _i11 
+\newline
+file image2.eps
+ 921 image2.eps 
+\newline
+file image.eps 921 image.eps
+\end_layout
+
+\begin_layout Standard
+While these are new special-case syntaxes, they are designed to allow very
+ efficient use of the shell with minimal typing.
+ At an interactive shell prompt, conciseness of expression wins over readability.
+\end_layout
+
+\begin_layout Subsection
+Useful functions and modules
+\end_layout
+
+\begin_layout Standard
+The os, sys and shutil modules from the Python standard library are automaticall
+y loaded.
+ Some additional functions, useful for shell usage, are listed below.
+ You can request more help about them with `
+\family typewriter
+?
+\family default
+'.
+\end_layout
+
+\begin_layout Description
+
+\family typewriter
+shell
+\family default
+ - execute a command in the underlying system shell 
+\end_layout
+
+\begin_layout Description
+
+\family typewriter
+system
+\family default
+ - like 
+\family typewriter
+shell()
+\family default
+, but return the exit status of the command
+\end_layout
+
+\begin_layout Description
+
+\family typewriter
+sout
+\family default
+ - capture the output of a command as a string
+\end_layout
+
+\begin_layout Description
+
+\family typewriter
+lout
+\family default
+ - capture the output of a command as a list (split on `
+\backslash
+n')
+\end_layout
+
+\begin_layout Description
+
+\family typewriter
+getoutputerror
+\family default
+ - capture (output,error) of a shell commandss
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+sout
+\family default
+/
+\family typewriter
+lout
+\family default
+ are the functional equivalents of 
+\family typewriter
+$
+\family default
+/
+\family typewriter
+$$
+\family default
+.
+ They are provided to allow you to capture system output in the middle of
+ true python code, function definitions, etc (where 
+\family typewriter
+$
+\family default
+ and 
+\family typewriter
+$$
+\family default
+ are invalid).
+\end_layout
+
+\begin_layout Subsection
+Directory management
+\end_layout
+
+\begin_layout Standard
+Since each command passed by pysh to the underlying system is executed in
+ a subshell which exits immediately, you can NOT use !cd to navigate the
+ filesystem.
+\end_layout
+
+\begin_layout Standard
+Pysh provides its own builtin 
+\family typewriter
+`%cd
+\family default
+' magic command to move in the filesystem (the 
+\family typewriter
+%
+\family default
+ is not required with automagic on).
+ It also maintains a list of visited directories (use 
+\family typewriter
+%dhist
+\family default
+ to see it) and allows direct switching to any of them.
+ Type 
+\family typewriter
+`cd?
+\family default
+' for more details.
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+%pushd
+\family default
+, 
+\family typewriter
+%popd
+\family default
+ and 
+\family typewriter
+%dirs
+\family default
+ are provided for directory stack handling.
+\end_layout
+
+\begin_layout Subsection
+Prompt customization
+\end_layout
+
+\begin_layout Standard
+The supplied 
+\family typewriter
+ipythonrc-pysh
+\family default
+ profile comes with an example of a very colored and detailed prompt, mainly
+ to serve as an illustration.
+ The valid escape sequences, besides color names, are:
+\end_layout
+
+\begin_layout Description
+
+\backslash
+# - Prompt number, wrapped in the color escapes for the input prompt (determined
+ by the current color scheme).
+\end_layout
+
+\begin_layout Description
+
+\backslash
+N - Just the prompt counter number, 
+\emph on
+without
+\emph default
+ any coloring wrappers.
+ You can thus customize the actual prompt colors manually.
+\end_layout
+
+\begin_layout Description
+
+\backslash
+D - Dots, as many as there are digits in 
+\backslash
+# (so they align).
+\end_layout
+
+\begin_layout Description
+
+\backslash
+w - Current working directory (cwd).
+\end_layout
+
+\begin_layout Description
+
+\backslash
+W - Basename of current working directory.
+\end_layout
+
+\begin_layout Description
+
+\backslash
+X
+\emph on
+N
+\emph default
+ - Where 
+\emph on
+N
+\emph default
+=0..5.
+ N terms of the cwd, with $HOME written as ~.
+\end_layout
+
+\begin_layout Description
+
+\backslash
+Y
+\emph on
+N
+\emph default
+ - Where 
+\emph on
+N
+\emph default
+=0..5.
+ Like X
+\emph on
+N
+\emph default
+, but if ~ is term 
+\emph on
+N
+\emph default
++1 it's also shown.
+\end_layout
+
+\begin_layout Description
+
+\backslash
+u - Username.
+\end_layout
+
+\begin_layout Description
+
+\backslash
+H - Full hostname.
+\end_layout
+
+\begin_layout Description
+
+\backslash
+h - Hostname up to first '.'
+\end_layout
+
+\begin_layout Description
+
+\backslash
+$ - Root symbol ($ or #).
+ 
+\end_layout
+
+\begin_layout Description
+
+\backslash
+t - Current time, in H:M:S format.
+\end_layout
+
+\begin_layout Description
+
+\backslash
+v - IPython release version.
+ 
+\end_layout
+
+\begin_layout Description
+
+\backslash
+n - Newline.
+ 
+\end_layout
+
+\begin_layout Description
+
+\backslash
+r - Carriage return.
+ 
+\end_layout
+
+\begin_layout Description
+
+\backslash
+
+\backslash
+ - An explicitly escaped '
+\backslash
+'.
+\end_layout
+
+\begin_layout Standard
+You can configure your prompt colors using any ANSI color escape.
+ Each color escape sets the color for any subsequent text, until another
+ escape comes in and changes things.
+ The valid color escapes are:
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_Black
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_Blue
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_Brown
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_Cyan
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_DarkGray
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_Green
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_LightBlue
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_LightCyan
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_LightGray
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_LightGreen
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_LightPurple
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_LightRed
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_Purple
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_Red
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_White
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_Yellow
+\end_layout
+
+\begin_layout Description
+
+\backslash
+C_Normal Stop coloring, defaults to your terminal settings.
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:Threading-support}
+
+\end_inset
+
+Threading support
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+WARNING: 
+\series default
+The threading support is still somewhat experimental, and it has only seen
+ reasonable testing under Linux.
+ Threaded code is particularly tricky to debug, and it tends to show extremely
+ platform-dependent behavior.
+ Since I only have access to Linux machines, I will have to rely on user's
+ experiences and assistance for this area of IPython to improve under other
+ platforms.
+\end_layout
+
+\begin_layout Standard
+IPython, via the 
+\family typewriter
+-gthread
+\family default
+ , 
+\family typewriter
+-qthread
+\family default
+, 
+\family typewriter
+-q4thread
+\family default
+ and 
+\family typewriter
+-wthread
+\family default
+ options (described in Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:threading-opts}
+
+\end_inset
+
+), can run in multithreaded mode to support pyGTK, Qt3, Qt4 and WXPython
+ applications respectively.
+ These GUI toolkits need to control the python main loop of execution, so
+ under a normal Python interpreter, starting a pyGTK, Qt3, Qt4 or WXPython
+ application will immediately freeze the shell.
+ 
+\end_layout
+
+\begin_layout Standard
+IPython, with one of these options (you can only use one at a time), separates
+ the graphical loop and IPython's code execution run into different threads.
+ This allows you to test interactively (with 
+\family typewriter
+%run
+\family default
+, for example) your GUI code without blocking.
+\end_layout
+
+\begin_layout Standard
+A nice mini-tutorial on using IPython along with the Qt Designer application
+ is available at the SciPy wiki: 
+\begin_inset LatexCommand \htmlurl{http://www.scipy.org/Cookbook/Matplotlib/Qt_with_IPython_and_Designer}
+
+\end_inset
+
+.
+\end_layout
+
+\begin_layout Subsection
+Tk issues
+\end_layout
+
+\begin_layout Standard
+As indicated in Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:threading-opts}
+
+\end_inset
+
+, a special 
+\family typewriter
+-tk
+\family default
+ option is provided to try and allow Tk graphical applications to coexist
+ interactively with WX, Qt or GTK ones.
+ Whether this works at all, however, is very platform and configuration
+ dependent.
+ Please experiment with simple test cases before committing to using this
+ combination of Tk and GTK/Qt/WX threading in a production environment.
+\end_layout
+
+\begin_layout Subsection
+I/O pitfalls
+\end_layout
+
+\begin_layout Standard
+Be mindful that the Python interpreter switches between threads every 
+\begin_inset Formula $N$
+\end_inset
+
+ bytecodes, where the default value as of Python\InsetSpace ~
+2.3 is 
+\begin_inset Formula $N=100.$
+\end_inset
+
+ This value can be read by using the 
+\family typewriter
+sys.getcheckinterval()
+\family default
+ function, and it can be reset via 
+\family typewriter
+sys.setcheckinterval(
+\emph on
+N
+\emph default
+)
+\family default
+.
+ This switching of threads can cause subtly confusing effects if one of
+ your threads is doing file I/O.
+ In text mode, most systems only flush file buffers when they encounter
+ a 
+\family typewriter
+`
+\backslash
+n'
+\family default
+.
+ An instruction as simple as
+\family typewriter
+
+\newline
+\InsetSpace ~
+\InsetSpace ~
+print >> filehandle, 
+\begin_inset Quotes eld
+\end_inset
+
+hello world
+\begin_inset Quotes erd
+\end_inset
+
+
+\family default
+
+\newline
+actually consists of several bytecodes, so it is possible that the newline
+ does not reach your file before the next thread switch.
+ Similarly, if you are writing to a file in binary mode, the file won't
+ be flushed until the buffer fills, and your other thread may see apparently
+ truncated files.
+ 
+\end_layout
+
+\begin_layout Standard
+For this reason, if you are using IPython's thread support and have (for
+ example) a GUI application which will read data generated by files written
+ to from the IPython thread, the safest approach is to open all of your
+ files in unbuffered mode (the third argument to the 
+\family typewriter
+file/open
+\family default
+ function is the buffering value):
+\newline
+
+\family typewriter
+\InsetSpace ~
+\InsetSpace ~
+filehandle = open(filename,mode,0)
+\end_layout
+
+\begin_layout Standard
+This is obviously a brute force way of avoiding race conditions with the
+ file buffering.
+ If you want to do it cleanly, and you have a resource which is being shared
+ by the interactive IPython loop and your GUI thread, you should really
+ handle it with thread locking and syncrhonization properties.
+ The Python documentation discusses these.
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:interactive-demos}
+
+\end_inset
+
+Interactive demos with IPython
+\end_layout
+
+\begin_layout Standard
+IPython ships with a basic system for running scripts interactively in sections,
+ useful when presenting code to audiences.
+ A few tags embedded in comments (so that the script remains valid Python
+ code) divide a file into separate blocks, and the demo can be run one block
+ at a time, with IPython printing (with syntax highlighting) the block before
+ executing it, and returning to the interactive prompt after each block.
+ The interactive namespace is updated after each block is run with the contents
+ of the demo's namespace.
+\end_layout
+
+\begin_layout Standard
+This allows you to show a piece of code, run it and then execute interactively
+ commands based on the variables just created.
+ Once you want to continue, you simply execute the next block of the demo.
+ The following listing shows the markup necessary for dividing a script
+ into sections for execution as a demo.
+\end_layout
+
+\begin_layout Standard
+\begin_inset ERT
+status open
+
+\begin_layout Standard
+
+
+\backslash
+codelist{examples/example-demo.py}
+\end_layout
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Standard
+In order to run a file as a demo, you must first make a 
+\family typewriter
+Demo
+\family default
+ object out of it.
+ If the file is named 
+\family typewriter
+myscript.py
+\family default
+, the following code will make a demo:
+\end_layout
+
+\begin_layout LyX-Code
+from IPython.demo import Demo
+\end_layout
+
+\begin_layout LyX-Code
+mydemo = Demo('myscript.py')
+\end_layout
+
+\begin_layout Standard
+This creates the 
+\family typewriter
+mydemo
+\family default
+ object, whose blocks you run one at a time by simply calling the object
+ with no arguments.
+ If you have autocall active in IPython (the default), all you need to do
+ is type
+\end_layout
+
+\begin_layout LyX-Code
+mydemo
+\end_layout
+
+\begin_layout Standard
+and IPython will call it, executing each block.
+ Demo objects can be restarted, you can move forward or back skipping blocks,
+ re-execute the last block, etc.
+ Simply use the Tab key on a demo object to see its methods, and call 
+\family typewriter
+`?'
+\family default
+ on them to see their docstrings for more usage details.
+ In addition, the 
+\family typewriter
+demo
+\family default
+ module itself contains a comprehensive docstring, which you can access
+ via
+\end_layout
+
+\begin_layout LyX-Code
+from IPython import demo
+\end_layout
+
+\begin_layout LyX-Code
+demo?
+\end_layout
+
+\begin_layout Standard
+
+\series bold
+Limitations:
+\series default
+ It is important to note that these demos are limited to fairly simple uses.
+ In particular, you can 
+\emph on
+not
+\emph default
+ put division marks in indented code (loops, if statements, function definitions
+, etc.) Supporting something like this would basically require tracking the
+ internal execution state of the Python interpreter, so only top-level divisions
+ are allowed.
+ If you want to be able to open an IPython instance at an arbitrary point
+ in a program, you can use IPython's embedding facilities, described in
+ detail in Sec\SpecialChar \@.
+\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:embed}
+
+\end_inset
+
+.
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:matplotlib-support}
+
+\end_inset
+
+Plotting with 
+\family typewriter
+matplotlib
+\family default
+ 
+\end_layout
+
+\begin_layout Standard
+The matplotlib library (
+\begin_inset LatexCommand \htmlurl[http://matplotlib.sourceforge.net]{http://matplotlib.sourceforge.net}
+
+\end_inset
+
+) provides high quality 2D plotting for Python.
+ Matplotlib can produce plots on screen using a variety of GUI toolkits,
+ including Tk, GTK and WXPython.
+ It also provides a number of commands useful for scientific computing,
+ all with a syntax compatible with that of the popular Matlab program.
+\end_layout
+
+\begin_layout Standard
+IPython accepts the special option 
+\family typewriter
+-pylab
+\family default
+ (Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:cmd-line-opts}
+
+\end_inset
+
+).
+ This configures it to support matplotlib, honoring the settings in the
+ 
+\family typewriter
+.matplotlibrc
+\family default
+ file.
+ IPython will detect the user's choice of matplotlib GUI backend, and automatica
+lly select the proper threading model to prevent blocking.
+ It also sets matplotlib in interactive mode and modifies 
+\family typewriter
+%run
+\family default
+ slightly, so that any matplotlib-based script can be executed using 
+\family typewriter
+%run
+\family default
+ and the final 
+\family typewriter
+show()
+\family default
+ command does not block the interactive shell.
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+-pylab
+\family default
+ option must be given first in order for IPython to configure its threading
+ mode.
+ However, you can still issue other options afterwards.
+ This allows you to have a matplotlib-based environment customized with
+ additional modules using the standard IPython profile mechanism (Sec.\InsetSpace ~
+
+\begin_inset LatexCommand \ref{sec:profiles}
+
+\end_inset
+
+): ``
+\family typewriter
+ipython -pylab -p myprofile
+\family default
+'' will load the profile defined in 
+\family typewriter
+ipythonrc-myprofile
+\family default
+ after configuring matplotlib.
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:Gnuplot}
+
+\end_inset
+
+Plotting with 
+\family typewriter
+Gnuplot
+\end_layout
+
+\begin_layout Standard
+Through the magic extension system described in sec.
+ 
+\begin_inset LatexCommand \ref{sec:magic}
+
+\end_inset
+
+, IPython incorporates a mechanism for conveniently interfacing with the
+ Gnuplot system (
+\begin_inset LatexCommand \htmlurl{http://www.gnuplot.info}
+
+\end_inset
+
+).
+ Gnuplot is a very complete 2D and 3D plotting package available for many
+ operating systems and commonly included in modern Linux distributions.
+ 
+\end_layout
+
+\begin_layout Standard
+Besides having Gnuplot installed, this functionality requires the 
+\family typewriter
+Gnuplot.py
+\family default
+ module for interfacing python with Gnuplot.
+ It can be downloaded from: 
+\begin_inset LatexCommand \htmlurl{http://gnuplot-py.sourceforge.net}
+
+\end_inset
+
+.
+\end_layout
+
+\begin_layout Subsection
+Proper Gnuplot configuration
+\end_layout
+
+\begin_layout Standard
+As of version 4.0, Gnuplot has excellent mouse and interactive keyboard support.
+ However, as of 
+\family typewriter
+Gnuplot.py
+\family default
+ version 1.7, a new option was added to communicate between Python and Gnuplot
+ via FIFOs (pipes).
+ This mechanism, while fast, also breaks the mouse system.
+ You must therefore set the variable 
+\family typewriter
+prefer_fifo_data
+\family default
+ to 
+\family typewriter
+0
+\family default
+ in file 
+\family typewriter
+gp_unix.py
+\family default
+ if you wish to keep the interactive mouse and keyboard features working
+ properly (
+\family typewriter
+prefer_inline_data
+\family default
+ also must be 
+\family typewriter
+0
+\family default
+, but this is the default so unless you've changed it manually you should
+ be fine).
+\end_layout
+
+\begin_layout Standard
+'Out of the box', Gnuplot is configured with a rather poor set of size,
+ color and linewidth choices which make the graphs fairly hard to read on
+ modern high-resolution displays (although they work fine on old 640x480
+ ones).
+ Below is a section of my 
+\family typewriter
+.Xdefaults
+\family default
+ file which I use for having a more convenient Gnuplot setup.
+ Remember to load it by running 
+\family typewriter
+`xrdb .Xdefaults`
+\family default
+:
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+!******************************************************************
+\newline
+! gnuplot
+ options
+\newline
+! modify this for a convenient window size
+\newline
+gnuplot*geometry: 780x580
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+! on-screen font (not for PostScript)
+\newline
+gnuplot*font: -misc-fixed-bold-r-normal--15
+-120-100-100-c-90-iso8859-1
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+! color options
+\newline
+gnuplot*background: black
+\newline
+gnuplot*textColor: white
+\newline
+gnuplot*borderCo
+lor: white
+\newline
+gnuplot*axisColor: white
+\newline
+gnuplot*line1Color: red
+\newline
+gnuplot*line2Color:
+ green
+\newline
+gnuplot*line3Color: blue
+\newline
+gnuplot*line4Color: magenta
+\newline
+gnuplot*line5Color:
+ cyan
+\newline
+gnuplot*line6Color: sienna
+\newline
+gnuplot*line7Color: orange
+\newline
+gnuplot*line8Color:
+ coral
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+! multiplicative factor for point styles
+\newline
+gnuplot*pointsize: 2
+\end_layout
+
+\begin_layout Standard
+
+\family typewriter
+! line width options (in pixels)
+\newline
+gnuplot*borderWidth: 2
+\newline
+gnuplot*axisWidth:
+ 2
+\newline
+gnuplot*line1Width: 2
+\newline
+gnuplot*line2Width: 2
+\newline
+gnuplot*line3Width: 2
+\newline
+gnuplot*line4Wi
+dth: 2
+\newline
+gnuplot*line5Width: 2
+\newline
+gnuplot*line6Width: 2
+\newline
+gnuplot*line7Width: 2
+\newline
+gnuplot*lin
+e8Width: 2
+\end_layout
+
+\begin_layout Subsection
+The 
+\family typewriter
+IPython.GnuplotRuntime
+\family default
+ module
+\end_layout
+
+\begin_layout Standard
+IPython includes a module called 
+\family typewriter
+Gnuplot2.py
+\family default
+ which extends and improves the default 
+\family typewriter
+Gnuplot
+\family default
+.
+\family typewriter
+py
+\family default
+ (which it still relies upon).
+ For example, the new 
+\family typewriter
+plot
+\family default
+ function adds several improvements to the original making it more convenient
+ for interactive use, and 
+\family typewriter
+hardcopy
+\family default
+ fixes a bug in the original which under some circumstances blocks the creation
+ of PostScript output.
+\end_layout
+
+\begin_layout Standard
+For scripting use, 
+\family typewriter
+GnuplotRuntime.py
+\family default
+ is provided, which wraps 
+\family typewriter
+Gnuplot2.py
+\family default
+ and creates a series of global aliases.
+ These make it easy to control Gnuplot plotting jobs through the Python
+ language.
+\end_layout
+
+\begin_layout Standard
+Below is some example code which illustrates how to configure Gnuplot inside
+ your own programs but have it available for further interactive use through
+ an embedded IPython instance.
+ Simply run this file at a system prompt.
+ This file is provided as 
+\family typewriter
+example-gnuplot.py
+\family default
+ in the examples directory:
+\end_layout
+
+\begin_layout Standard
+\begin_inset ERT
+status open
+
+\begin_layout Standard
+
+
+\backslash
+codelist{examples/example-gnuplot.py}
+\end_layout
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Subsection
+The 
+\family typewriter
+numeric
+\family default
+ profile: a scientific computing environment
+\end_layout
+
+\begin_layout Standard
+The 
+\family typewriter
+numeric
+\family default
+ IPython profile, which you can activate with 
+\family typewriter
+`ipython -p numeric
+\family default
+' will automatically load the IPython Gnuplot extensions (plus Numeric and
+ other useful things for numerical computing), contained in the 
+\family typewriter
+IPython.GnuplotInteractive
+\family default
+ module.
+ This will create the globals 
+\family typewriter
+Gnuplot 
+\family default
+(an alias to the improved Gnuplot2 module), 
+\family typewriter
+gp
+\family default
+ (a Gnuplot active instance), the new magic commands 
+\family typewriter
+%gpc
+\family default
+ and 
+\family typewriter
+%gp_set_instance
+\family default
+ and several other convenient globals.
+ Type 
+\family typewriter
+gphelp()
+\family default
+ for further details.
+\end_layout
+
+\begin_layout Standard
+This should turn IPython into a convenient environment for numerical computing,
+ with all the functions in the NumPy library and the Gnuplot facilities
+ for plotting.
+ Further improvements can be obtained by loading the SciPy libraries for
+ scientific computing, available at 
+\begin_inset LatexCommand \htmlurl{http://scipy.org}
+
+\end_inset
+
+.
+\end_layout
+
+\begin_layout Standard
+If you are in the middle of a working session with numerical objects and
+ need to plot them but you didn't start the 
+\family typewriter
+numeric
+\family default
+ profile, you can load these extensions at any time by typing
+\newline
+
+\family typewriter
+from IPython.GnuplotInteractive import *
+\newline
+
+\family default
+at the IPython prompt.
+ This will allow you to keep your objects intact and start using Gnuplot
+ to view them.
+\end_layout
+
+\begin_layout Section
+Reporting bugs
+\end_layout
+
+\begin_layout Subsection*
+Automatic crash reports
+\end_layout
+
+\begin_layout Standard
+Ideally, IPython itself shouldn't crash.
+ It will catch exceptions produced by you, but bugs in its internals will
+ still crash it.
+\end_layout
+
+\begin_layout Standard
+In such a situation, IPython will leave a file named 
+\family typewriter
+IPython_crash_report.txt
+\family default
+ in your IPYTHONDIR directory (that way if crashes happen several times
+ it won't litter many directories, the post-mortem file is always located
+ in the same place and new occurrences just overwrite the previous one).
+ If you can mail this file to the developers (see sec.
+ 
+\begin_inset LatexCommand \ref{sec:credits}
+
+\end_inset
+
+ for names and addresses), it will help us 
+\emph on
+a lot
+\emph default
+ in understanding the cause of the problem and fixing it sooner.
+\end_layout
+
+\begin_layout Subsection*
+The bug tracker
+\end_layout
+
+\begin_layout Standard
+IPython also has an online bug-tracker, located at 
+\begin_inset LatexCommand \htmlurl{http://projects.scipy.org/ipython/ipython/report/1}
+
+\end_inset
+
+.
+ In addition to mailing the developers, it would be a good idea to file
+ a bug report here.
+ This will ensure that the issue is properly followed to conclusion.
+ To report new bugs you will have to register first.
+\end_layout
+
+\begin_layout Standard
+You can also use this bug tracker to file feature requests.
+\end_layout
+
+\begin_layout Section
+Brief history
+\end_layout
+
+\begin_layout Subsection
+Origins
+\end_layout
+
+\begin_layout Standard
+The current IPython system grew out of the following three projects:
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+ipython by Fernando P
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+'{e}
+\end_layout
+
+\end_inset
+
+rez.
+ I was working on adding Mathematica-type prompts and a flexible configuration
+ system (something better than 
+\family typewriter
+$PYTHONSTARTUP
+\family default
+) to the standard Python interactive interpreter.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+IPP by Janko Hauser.
+ Very well organized, great usability.
+ Had an old help system.
+ IPP was used as the `container' code into which I added the functionality
+ from ipython and LazyPython.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+LazyPython by Nathan Gray.
+ Simple but 
+\emph on
+very
+\emph default
+ powerful.
+ The quick syntax (auto parens, auto quotes) and verbose/colored tracebacks
+ were all taken from here.
+\end_layout
+
+\begin_layout Standard
+When I found out (see sec.
+ 
+\begin_inset LatexCommand \ref{figgins}
+
+\end_inset
+
+) about IPP and LazyPython I tried to join all three into a unified system.
+ I thought this could provide a very nice working environment, both for
+ regular programming and scientific computing: shell-like features, IDL/Matlab
+ numerics, Mathematica-type prompt history and great object introspection
+ and help facilities.
+ I think it worked reasonably well, though it was a lot more work than I
+ had initially planned.
+\end_layout
+
+\begin_layout Subsection
+Current status
+\end_layout
+
+\begin_layout Standard
+The above listed features work, and quite well for the most part.
+ But until a major internal restructuring is done (see below), only bug
+ fixing will be done, no other features will be added (unless very minor
+ and well localized in the cleaner parts of the code).
+\end_layout
+
+\begin_layout Standard
+IPython consists of some 18000 lines of pure python code, of which roughly
+ two thirds is reasonably clean.
+ The rest is, messy code which needs a massive restructuring before any
+ further major work is done.
+ Even the messy code is fairly well documented though, and most of the problems
+ in the (non-existent) class design are well pointed to by a PyChecker run.
+ So the rewriting work isn't that bad, it will just be time-consuming.
+\end_layout
+
+\begin_layout Subsection
+Future
+\end_layout
+
+\begin_layout Standard
+See the separate 
+\family typewriter
+new_design
+\family default
+ document for details.
+ Ultimately, I would like to see IPython become part of the standard Python
+ distribution as a `big brother with batteries' to the standard Python interacti
+ve interpreter.
+ But that will never happen with the current state of the code, so all contribut
+ions are welcome.
+\end_layout
+
+\begin_layout Section
+License
+\end_layout
+
+\begin_layout Standard
+IPython is released under the terms of the BSD license, whose general form
+ can be found at: 
+\begin_inset LatexCommand \htmlurl{http://www.opensource.org/licenses/bsd-license.php}
+
+\end_inset
+
+.
+ The full text of the IPython license is reproduced below:
+\end_layout
+
+\begin_layout Quote
+
+\family typewriter
+\size small
+IPython is released under a BSD-type license.
+\end_layout
+
+\begin_layout Quote
+
+\family typewriter
+\size small
+Copyright (c) 2001, 2002, 2003, 2004 Fernando Perez <fperez@colorado.edu>.
+\end_layout
+
+\begin_layout Quote
+
+\family typewriter
+\size small
+Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and 
+\newline
+Nathaniel Gray <n8gray@ca
+ltech.edu>.
+\end_layout
+
+\begin_layout Quote
+
+\family typewriter
+\size small
+All rights reserved.
+\end_layout
+
+\begin_layout Quote
+
+\family typewriter
+\size small
+Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+\end_layout
+
+\begin_layout Quote
+
+\family typewriter
+\size small
+a.
+ Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+\end_layout
+
+\begin_layout Quote
+
+\family typewriter
+\size small
+b.
+ Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+\end_layout
+
+\begin_layout Quote
+
+\family typewriter
+\size small
+c.
+ Neither the name of the copyright holders nor the names of any contributors
+ to this software may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+\end_layout
+
+\begin_layout Quote
+
+\family typewriter
+\size small
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ 
+\end_layout
+
+\begin_layout Standard
+Individual authors are the holders of the copyright for their code and are
+ listed in each file.
+\end_layout
+
+\begin_layout Standard
+Some files (
+\family typewriter
+DPyGetOpt.py
+\family default
+, for example) may be licensed under different conditions.
+ Ultimately each file indicates clearly the conditions under which its author/au
+thors have decided to publish the code.
+\end_layout
+
+\begin_layout Standard
+Versions of IPython up to and including 0.6.3 were released under the GNU
+ Lesser General Public License (LGPL), available at 
+\begin_inset LatexCommand \htmlurl{http://www.gnu.org/copyleft/lesser.html}
+
+\end_inset
+
+.
+\end_layout
+
+\begin_layout Section
+\begin_inset LatexCommand \label{sec:credits}
+
+\end_inset
+
+Credits
+\end_layout
+
+\begin_layout Standard
+IPython is mainly developed by Fernando P
+\begin_inset ERT
+status collapsed
+
+\begin_layout Standard
+
+
+\backslash
+'{e}
+\end_layout
+
+\end_inset
+
+rez 
+\family typewriter
+<Fernando.Perez@colorado.edu>
+\family default
+, but the project was born from mixing in Fernando's code with the IPP project
+ by Janko Hauser 
+\family typewriter
+<jhauser-AT-zscout.de>
+\family default
+ and LazyPython by Nathan Gray 
+\family typewriter
+<n8gray-AT-caltech.edu>
+\family default
+.
+ For all IPython-related requests, please contact Fernando.
+ 
+\end_layout
+
+\begin_layout Standard
+As of early 2006, the following developers have joined the core team:
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Robert\InsetSpace ~
+Kern 
+\family typewriter
+<rkern-AT-enthought.com>
+\family default
+: co-mentored the 2005 Google Summer of Code project to develop python interacti
+ve notebooks (XML documents) and graphical interface.
+ This project was awarded to the students Tzanko Matev 
+\family typewriter
+<tsanko-AT-gmail.com>
+\family default
+ and Toni Alatalo 
+\family typewriter
+<antont-AT-an.org>
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Brian\InsetSpace ~
+Granger 
+\family typewriter
+<bgranger-AT-scu.edu>
+\family default
+: extending IPython to allow support for interactive parallel computing.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Ville\InsetSpace ~
+Vainio 
+\family typewriter
+<vivainio-AT-gmail.com>
+\family default
+: Ville is the new maintainer for the main trunk of IPython after version
+ 0.7.1.
+\end_layout
+
+\begin_layout Standard
+User or development help should be requested via the IPython mailing lists:
+\end_layout
+
+\begin_layout Description
+User\InsetSpace ~
+list: 
+\begin_inset LatexCommand \htmlurl{http://scipy.net/mailman/listinfo/ipython-user}
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Description
+Developer's\InsetSpace ~
+list: 
+\begin_inset LatexCommand \htmlurl{http://scipy.net/mailman/listinfo/ipython-dev}
+
+\end_inset
+
+
+\end_layout
+
+\begin_layout Standard
+The IPython project is also very grateful to
+\begin_inset Foot
+status collapsed
+
+\begin_layout Standard
+I've mangled email addresses to reduce spam, since the IPython manuals can
+ be accessed online.
+\end_layout
+
+\end_inset
+
+:
+\end_layout
+
+\begin_layout Standard
+Bill Bumgarner 
+\family typewriter
+<bbum-AT-friday.com>
+\family default
+: for providing the DPyGetOpt module which gives very powerful and convenient
+ handling of command-line options (light years ahead of what Python 2.1.1's
+ getopt module does).
+\end_layout
+
+\begin_layout Standard
+Ka-Ping Yee 
+\family typewriter
+<ping-AT-lfw.org>
+\family default
+: for providing the Itpl module for convenient and powerful string interpolation
+ with a much nicer syntax than formatting through the '%' operator.
+\end_layout
+
+\begin_layout Standard
+Arnd Baecker 
+\family typewriter
+<baecker-AT-physik.tu-dresden.de>
+\family default
+: for his many very useful suggestions and comments, and lots of help with
+ testing and documentation checking.
+ Many of IPython's newer features are a result of discussions with him (bugs
+ are still my fault, not his).
+\end_layout
+
+\begin_layout Standard
+Obviously Guido van\InsetSpace ~
+Rossum and the whole Python development team, that goes
+ without saying.
+\end_layout
+
+\begin_layout Standard
+IPython's website is generously hosted at 
+\begin_inset LatexCommand \htmlurl{http://ipython.scipy.org}
+
+\end_inset
+
+ by Enthought (
+\begin_inset LatexCommand \htmlurl{http://www.enthought.com}
+
+\end_inset
+
+).
+ I am very grateful to them and all of the SciPy team for their contribution.
+\end_layout
+
+\begin_layout Standard
+\begin_inset LatexCommand \label{figgins}
+
+\end_inset
+
+Fernando would also like to thank Stephen Figgins 
+\family typewriter
+<fig-AT-monitor.net>
+\family default
+, an O'Reilly Python editor.
+ His Oct/11/2001 article about IPP and LazyPython, was what got this project
+ started.
+ You can read it at: 
+\begin_inset LatexCommand \htmlurl{http://www.onlamp.com/pub/a/python/2001/10/11/pythonnews.html}
+
+\end_inset
+
+.
+\end_layout
+
+\begin_layout Standard
+And last but not least, all the kind IPython users who have emailed new
+ code, bug reports, fixes, comments and ideas.
+ A brief list follows, please let me know if I have ommitted your name by
+ accident: 
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Jack\InsetSpace ~
+Moffit 
+\family typewriter
+<jack-AT-xiph.org>
+\family default
+ Bug fixes, including the infamous color problem.
+ This bug alone caused many lost hours and frustration, many thanks to him
+ for the fix.
+ I've always been a fan of Ogg & friends, now I have one more reason to
+ like these folks.
+\newline
+Jack is also contributing with Debian packaging and many
+ other things.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Alexander\InsetSpace ~
+Schmolck 
+\family typewriter
+<a.schmolck-AT-gmx.net> 
+\family default
+Emacs work, bug reports, bug fixes, ideas, lots more.
+ The ipython.el mode for (X)Emacs is Alex's code, providing full support
+ for IPython under (X)Emacs.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Andrea\InsetSpace ~
+Riciputi 
+\family typewriter
+<andrea.riciputi-AT-libero.it>
+\family default
+ Mac OSX information, Fink package management.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Gary\InsetSpace ~
+Bishop 
+\family typewriter
+<gb-AT-cs.unc.edu>
+\family default
+ Bug reports, and patches to work around the exception handling idiosyncracies
+ of WxPython.
+ Readline and color support for Windows.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Jeffrey\InsetSpace ~
+Collins 
+\family typewriter
+<Jeff.Collins-AT-vexcel.com>
+\family default
+ Bug reports.
+ Much improved readline support, including fixes for Python 2.3.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Dryice\InsetSpace ~
+Liu 
+\family typewriter
+<dryice-AT-liu.com.cn>
+\family default
+ FreeBSD port.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Mike\InsetSpace ~
+Heeter 
+\family typewriter
+<korora-AT-SDF.LONESTAR.ORG>
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Christopher\InsetSpace ~
+Hart 
+\family typewriter
+<hart-AT-caltech.edu>
+\family default
+ PDB integration.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Milan\InsetSpace ~
+Zamazal 
+\family typewriter
+<pdm-AT-zamazal.org>
+\family default
+ Emacs info.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Philip\InsetSpace ~
+Hisley 
+\family typewriter
+<compsys-AT-starpower.net>
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Holger\InsetSpace ~
+Krekel 
+\family typewriter
+<pyth-AT-devel.trillke.net>
+\family default
+ Tab completion, lots more.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Robin\InsetSpace ~
+Siebler 
+\family typewriter
+<robinsiebler-AT-starband.net>
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Ralf\InsetSpace ~
+Ahlbrink
+\family typewriter
+ <ralf_ahlbrink-AT-web.de>
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Thorsten\InsetSpace ~
+Kampe 
+\family typewriter
+<thorsten-AT-thorstenkampe.de>
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Fredrik\InsetSpace ~
+Kant 
+\family typewriter
+<fredrik.kant-AT-front.com>
+\family default
+ Windows setup.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Syver\InsetSpace ~
+Enstad 
+\family typewriter
+<syver-en-AT-online.no>
+\family default
+ Windows setup.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Richard 
+\family typewriter
+<rxe-AT-renre-europe.com>
+\family default
+ Global embedding.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Hayden\InsetSpace ~
+Callow 
+\family typewriter
+<h.callow-AT-elec.canterbury.ac.nz>
+\family default
+ Gnuplot.py 1.6 compatibility.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Leonardo\InsetSpace ~
+Santagada 
+\family typewriter
+<retype-AT-terra.com.br>
+\family default
+ Fixes for Windows installation.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Christopher\InsetSpace ~
+Armstrong 
+\family typewriter
+<radix-AT-twistedmatrix.com>
+\family default
+ Bugfixes.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Francois\InsetSpace ~
+Pinard 
+\family typewriter
+<pinard-AT-iro.umontreal.ca>
+\family default
+ Code and documentation fixes.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Cory\InsetSpace ~
+Dodt 
+\family typewriter
+<cdodt-AT-fcoe.k12.ca.us>
+\family default
+ Bug reports and Windows ideas.
+ Patches for Windows installer.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Olivier\InsetSpace ~
+Aubert 
+\family typewriter
+<oaubert-AT-bat710.univ-lyon1.fr>
+\family default
+ New magics.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+King\InsetSpace ~
+C.\InsetSpace ~
+Shu 
+\family typewriter
+<kingshu-AT-myrealbox.com>
+\family default
+ Autoindent patch.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Chris\InsetSpace ~
+Drexler 
+\family typewriter
+<chris-AT-ac-drexler.de>
+\family default
+ Readline packages for Win32/CygWin.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Gustavo\InsetSpace ~
+Cordova\InsetSpace ~
+Avila 
+\family typewriter
+<gcordova-AT-sismex.com>
+\family default
+ EvalDict code for nice, lightweight string interpolation.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Kasper\InsetSpace ~
+Souren 
+\family typewriter
+<Kasper.Souren-AT-ircam.fr>
+\family default
+ Bug reports, ideas.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Gever\InsetSpace ~
+Tulley 
+\family typewriter
+<gever-AT-helium.com>
+\family default
+ Code contributions.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Ralf\InsetSpace ~
+Schmitt 
+\family typewriter
+<ralf-AT-brainbot.com>
+\family default
+ Bug reports & fixes.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Oliver\InsetSpace ~
+Sander 
+\family typewriter
+<osander-AT-gmx.de>
+\family default
+ Bug reports.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Rod\InsetSpace ~
+Holland 
+\family typewriter
+<rhh-AT-structurelabs.com>
+\family default
+ Bug reports and fixes to logging module.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Daniel\InsetSpace ~
+'Dang'\InsetSpace ~
+Griffith 
+\family typewriter
+<pythondev-dang-AT-lazytwinacres.net>
+\family default
+ Fixes, enhancement suggestions for system shell use.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Viktor\InsetSpace ~
+Ransmayr 
+\family typewriter
+<viktor.ransmayr-AT-t-online.de>
+\family default
+ Tests and reports on Windows installation issues.
+ Contributed a true Windows binary installer.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Mike\InsetSpace ~
+Salib 
+\family typewriter
+<msalib-AT-mit.edu>
+\family default
+ Help fixing a subtle bug related to traceback printing.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+W.J.\InsetSpace ~
+van\InsetSpace ~
+der\InsetSpace ~
+Laan 
+\family typewriter
+<gnufnork-AT-hetdigitalegat.nl>
+\family default
+ Bash-like prompt specials.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Antoon\InsetSpace ~
+Pardon 
+\family typewriter
+<Antoon.Pardon-AT-rece.vub.ac.be>
+\family default
+ Critical fix for the multithreaded IPython.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+John\InsetSpace ~
+Hunter 
+\family typewriter
+<jdhunter-AT-nitace.bsd.uchicago.edu>
+\family default
+ Matplotlib author, helped with all the development of support for matplotlib
+ in IPyhton, including making necessary changes to matplotlib itself.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Matthew\InsetSpace ~
+Arnison 
+\family typewriter
+<maffew-AT-cat.org.au>
+\family default
+ Bug reports, `
+\family typewriter
+%run -d
+\family default
+' idea.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Prabhu\InsetSpace ~
+Ramachandran 
+\family typewriter
+<prabhu_r-AT-users.sourceforge.net>
+\family default
+ Help with (X)Emacs support, threading patches, ideas...
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Norbert\InsetSpace ~
+Tretkowski 
+\family typewriter
+<tretkowski-AT-inittab.de>
+\family default
+ help with Debian packaging and distribution.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+George\InsetSpace ~
+Sakkis <
+\family typewriter
+gsakkis-AT-eden.rutgers.edu>
+\family default
+ New matcher for tab-completing named arguments of user-defined functions.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+J�rgen\InsetSpace ~
+Stenarson 
+\family typewriter
+<jorgen.stenarson-AT-bostream.nu>
+\family default
+ Wildcard support implementation for searching namespaces.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Vivian\InsetSpace ~
+De\InsetSpace ~
+Smedt 
+\family typewriter
+<vivian-AT-vdesmedt.com>
+\family default
+ Debugger enhancements, so that when pdb is activated from within IPython,
+ coloring, tab completion and other features continue to work seamlessly.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Scott\InsetSpace ~
+Tsai 
+\family typewriter
+<scottt958-AT-yahoo.com.tw>
+\family default
+ Support for automatic editor invocation on syntax errors (see 
+\begin_inset LatexCommand \htmlurl{http://www.scipy.net/roundup/ipython/issue36}
+
+\end_inset
+
+).
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Alexander\InsetSpace ~
+Belchenko 
+\family typewriter
+<bialix-AT-ukr.net>
+\family default
+ Improvements for win32 paging system.
+\end_layout
+
+\begin_layout List
+\labelwidthstring 00.00.0000
+Will\InsetSpace ~
+Maier 
+\family typewriter
+<willmaier-AT-ml1.net>
+\family default
+ Official OpenBSD port.
+\end_layout
+
+\end_body
+\end_document
diff --git a/doc/nbexample.py b/doc/nbexample.py
new file mode 100644
index 0000000..9c50f73
--- /dev/null
+++ b/doc/nbexample.py
@@ -0,0 +1,11 @@
+from notebook.markup import rest
+
+rest.title('This is a Python Notebook')
+rest.heading(1,'A first-level heading')
+rest.text("""\
+Some plain text, without any special formatting.
+
+Below, we define a simple function to add two numbers.""")
+
+def add(x,y):
+    return x+y
diff --git a/doc/nbexample_latex.py b/doc/nbexample_latex.py
new file mode 100644
index 0000000..edf6448
--- /dev/null
+++ b/doc/nbexample_latex.py
@@ -0,0 +1,25 @@
+from notebook.markup import latex
+
+latex.document_class('article')
+latex.title('This is a Python Notebook')
+
+latex.section('A section title',label='sec:intro')
+
+latex.text(r"""Below, we define a simple function
+\begin{equation}
+f: (x,y) \rightarrow x+y^2
+\end{equation}""")
+
+def f(x,y):
+    return x+y**2
+
+# since the .text method passes directly to latex, all markup could be input
+# in that way if so desired
+latex.text(r"""
+\section{Another section}
+
+More text...
+
+And now a picture showing our important results...""")
+
+latex.include_graphic('foo.png')
diff --git a/doc/nbexample_output.py b/doc/nbexample_output.py
new file mode 100644
index 0000000..d341045
--- /dev/null
+++ b/doc/nbexample_output.py
@@ -0,0 +1,20 @@
+from notebook.markup import rest
+
+rest.title('This is a Python Notebook')
+rest.text("""\
+Some plain text, without any special formatting.
+
+Below, we define a simple function to add two numbers.""")
+
+def add(x,y):
+    return x+y
+
+rest.text("Let's use it with x=2,y=3:")
+# This simply means that all code until the next markup call is to be executed
+# as a single call.  The editing screen should mark the whole group of lines
+# with a single In[NN] tag (like IPython does, but with multi-line capabilities)
+rest.input()
+add(2,3)
+# This output would appear on-screen (in the editing window) simply marked
+# with an Out[NN] tag
+rest.output("5")
diff --git a/doc/new_design.lyx b/doc/new_design.lyx
new file mode 100644
index 0000000..13e40ae
--- /dev/null
+++ b/doc/new_design.lyx
@@ -0,0 +1,1358 @@
+#LyX 1.3 created this file. For more info see http://www.lyx.org/
+\lyxformat 221
+\textclass article
+\begin_preamble
+\usepackage{ae,aecompl}
+\usepackage{hyperref}
+\usepackage{html}
+\end_preamble
+\language english
+\inputencoding auto
+\fontscheme default
+\graphics default
+\paperfontsize default
+\spacing single 
+\papersize Default
+\paperpackage a4
+\use_geometry 1
+\use_amsmath 0
+\use_natbib 0
+\use_numerical_citations 0
+\paperorientation portrait
+\leftmargin 1.25in
+\topmargin 1in
+\rightmargin 1.25in
+\bottommargin 1in
+\secnumdepth 3
+\tocdepth 3
+\paragraph_separation skip
+\defskip medskip
+\quotes_language english
+\quotes_times 2
+\papercolumns 1
+\papersides 1
+\paperpagestyle default
+
+\layout Title
+
+IPython
+\newline 
+
+\size larger 
+New design notes
+\layout Author
+
+Fernando P�rez
+\layout Section
+
+Introduction
+\layout Standard
+
+This is a draft document with notes and ideas for the IPython rewrite.
+ The section order and structure of this document roughly reflects in which
+ order things should be done and what the dependencies are.
+ This document is mainly a draft for developers, a pdf version is provided
+ with the standard distribution in case regular users are interested and
+ wish to contribute ideas.
+\layout Standard
+
+A tentative plan for the future:
+\layout Itemize
+
+0.6.x series: in practice, enough people are using IPython for real work that
+ I think it warrants a higher number.
+ This series will continue to evolve with bugfixes and incremental improvements.
+\layout Itemize
+
+0.7.x series: (maybe) If resources allow, there may be a branch for 'unstable'
+ development, where the architectural rewrite may take place.
+\layout Standard
+
+However, I am starting to doubt it is feasible to keep two separate branches.
+ I am leaning more towards a 
+\begin_inset ERT
+status Collapsed
+
+\layout Standard
+
+\backslash 
+LyX
+\end_inset 
+
+-like approach, where the main branch slowly transforms and evolves.
+ Having CVS support now makes this a reasonable alternative, as I don't
+ have to make pre-releases as often.
+ The active branch can remain the mainline of development, and users interested
+ in the bleeding-edge stuff can always grab the CVS code.
+\layout Standard
+
+Ideally, IPython should have a clean class setup that would allow further
+ extensions for special-purpose systems.
+ I view IPython as a base system that provides a great interactive environment
+ with full access to the Python language, and which could be used in many
+ different contexts.
+ The basic hooks are there: the magic extension syntax and the flexible
+ system of recursive configuration files and profiles.
+ But with a code as messy as the current one, nobody is going to touch it.
+\layout Section
+
+Immediate TODO and bug list
+\layout Standard
+
+Things that should be done for the current series, before starting major
+ changes.
+\layout Itemize
+
+Fix any bugs reported at the online bug tracker.
+\layout Itemize
+
+History bug: I often see that, under certain circumstances, the input history
+ is incorrect.
+ The problem is that so far, I've failed to find a simple way to reproduce
+ it consistently, so I can't easily track it down.
+ It seems to me that it happens when output is generated multiple times
+ for the same input (for i in range(10): i will do it).
+ But even this isn't reliable...
+ Ultimately the right solution for this is to cleanly separate the dataflow
+ for input/output history management; right now that happens all over the
+ place, which makes the code impossible to debug, and almost guaranteed
+ to be buggy in the first place.
+\layout Itemize
+
+
+\series bold 
+Redesign the output traps.
+
+\series default 
+ They cause problems when users try to execute code which relies on sys.stdout
+ being the 'true' sys.stdout.
+ They also prevent scripts which use raw_input() to work as command-line
+ arguments.
+\newline 
+The best solution is probably to print the banner first, and then just execute
+ all the user code straight with no output traps at all.
+ Whatever comes out comes out.
+ This makes the ipython code actually simpler, and eliminates the problem
+ altogether.
+\newline 
+These things need to be ripped out, they cause no end of problems.
+ For example, if user code requires acces to stdin during startup, the process
+ just hangs indefinitely.
+ For now I've just disabled them, and I'll live with the ugly error messages.
+\layout Itemize
+
+The prompt specials dictionary should be turned into a class which does
+ proper namespace management, since the prompt specials need to be evaluated
+ in a certain namespace.
+ Currently it's just globals, which need to be managed manually by code
+ below.
+ 
+\layout Itemize
+
+Fix coloring of prompts: the pysh color strings don't have any effect on
+ prompt numbers, b/c these are controlled by the global scheme.
+ Make the prompts fully user-definable, colors and all.
+ This is what I said to a user:
+\newline 
+As far as the green 
+\backslash 
+#, this is a minor bug of the coloring code due to the vagaries of history.
+ While the color strings allow you to control the coloring of most elements,
+ there are a few which are still controlled by the old ipython internal
+ coloring code, which only accepts a global 'color scheme' choice.
+ So basically the input/output numbers are hardwired to the choice in the
+ color scheme, and there are only 'Linux', 'LightBG' and 'NoColor' schemes
+ to choose from.
+ 
+\layout Itemize
+
+Clean up FakeModule issues.
+ Currently, unittesting with embedded ipython breaks because a FakeModule
+ instance overwrites __main__.
+ Maybe ipython should revert back to using __main__ directly as the user
+ namespace? Handling a separate namespace is proving 
+\emph on 
+very
+\emph default 
+ tricky in all corner cases.
+\layout Itemize
+
+Make the output cache depth independent of the input one.
+ This way one can have say only the last 10 results stored and still have
+ a long input history/cache.
+\layout Itemize
+
+Fix the fact that importing a shell for embedding screws up the command-line
+ history.
+ This can be done by not importing the history file when the shell is already
+ inside ipython.
+\layout Itemize
+
+Lay out the class structure so that embedding into a gtk/wx/qt app is trivial,
+ much like the multithreaded gui shells now provide command-line coexistence
+ with the gui toolkits.
+ See 
+\begin_inset LatexCommand \url{http://www.livejournal.com/users/glyf/32396.html}
+
+\end_inset 
+
+
+\layout Itemize
+
+Get Holger's completer in, once he adds filename completion.
+\layout Standard
+
+Lower priority stuff:
+\layout Itemize
+
+Add @showopt/@setopt (decide name) for viewing/setting all options.
+ The existing option-setting magics should become aliases for setopt calls.
+\layout Itemize
+
+It would be nice to be able to continue with python stuff after an @ command.
+ For instance "@run something; test_stuff()" in order to test stuff even
+ faster.
+ Suggestion by Kasper Souren <Kasper.Souren@ircam.fr>
+\layout Itemize
+
+Run a 'first time wizard' which configures a few things for the user, such
+ as color_info, editor and the like.
+\layout Itemize
+
+Logging: @logstart and -log should start logfiles in ~.ipython, but with
+ unique names in case of collisions.
+ This would prevent ipython.log files all over while also allowing multiple
+ sessions.
+ Also the -log option should take an optional filename, instead of having
+ a separate -logfile option.
+\newline 
+In general the logging system needs a serious cleanup.
+ Many functions now in Magic should be moved to Logger, and the magic @s
+ should be very simple wrappers to the Logger methods.
+\layout Section
+
+Lighten the code
+\layout Standard
+
+If we decide to base future versions of IPython on Python 2.3, which has
+ the new Optik module (called optparse), it should be possible to drop DPyGetOpt.
+ We should also remove the need for Itpl.
+ Another area for trimming is the Gnuplot stuff: much of that could be merged
+ into the mainline project.
+\layout Standard
+
+Double check whether we really need FlexCompleter.
+ This was written as an enhanced rlcompleter, but my patches went in for
+ python 2.2 (or 2.3, can't remember).
+\layout Standard
+
+With these changes we could shed a fair bit of code from the main trunk.
+\layout Section
+
+Unit testing
+\layout Standard
+
+All new code should use a testing framework.
+ Python seems to have very good testing facilities, I just need to learn
+ how to use them.
+ I should also check out QMTest at 
+\begin_inset LatexCommand \htmlurl{http://www.codesourcery.com/qm/qmtest}
+
+\end_inset 
+
+, it sounds interesting (it's Python-based too).
+\layout Section
+
+Configuration system
+\layout Standard
+
+Move away from the current ipythonrc format to using standard python files
+ for configuration.
+ This will require users to be slightly more careful in their syntax, but
+ reduces code in IPython, is more in line with Python's normal form (using
+ the $PYTHONSTARTUP file) and allows much more flexibility.
+ I also think it's more 'pythonic', in using a single language for everything.
+\layout Standard
+
+Options can be set up with a function call which takes keywords and updates
+ the options Struct.
+\layout Standard
+
+In order to maintain the recursive inclusion system, write an 'include'
+ function which is basically a wrapper around safe_execfile().
+ Also for alias definitions an alias() function will do.
+ All functionality which we want to have at startup time for the users can
+ be wrapped in a small module so that config files look like:
+\layout Standard
+
+
+\family typewriter 
+from IPython.Startup import *
+\newline 
+...
+\newline 
+set_options(automagic=1,colors='NoColor',...)
+\newline 
+...
+\newline 
+include('mysetup.py')
+\newline 
+...
+\newline 
+alias('ls ls --color -l')
+\newline 
+...
+ etc.
+\layout Standard
+
+Also, put 
+\series bold 
+all
+\series default 
+ aliases in here, out of the core code.
+\layout Standard
+
+The new system should allow for more seamless upgrading, so that:
+\layout Itemize
+
+It automatically recognizes when the config files need updating and does
+ the upgrade.
+\layout Itemize
+
+It simply adds the new options to the user's config file without overwriting
+ it.
+ The current system is annoying since users need to manually re-sync their
+ configuration after every update.
+\layout Itemize
+
+It detects obsolete options and informs the user to remove them from his
+ config file.
+\layout Standard
+
+Here's a copy of Arnd Baecker suggestions on the matter:
+\layout Standard
+
+1.) upgrade: it might be nice to have an "auto" upgrade procedure: i.e.
+ imagine that IPython is installed system-wide and gets upgraded, how does
+ a user know, that an upgrade of the stuff in ~/.ipython is necessary ? So
+ maybe one has to a keep a version number in ~/.ipython and if there is a
+ mismatch with the started ipython, then invoke the upgrade procedure.
+\layout Standard
+
+2.) upgrade: I find that replacing the old files in ~/.ipython (after copying
+ them to .old not optimal (for example, after every update, I have to change
+ my color settings (and some others) in ~/.ipython/ipthonrc).
+ So somehow keeping the old files and merging the new features would be
+ nice.
+ (but how to distinguish changes from version to version with changes made
+ by the user ?) For, example, I would have to change in GnuplotMagic.py gnuplot_m
+ouse to 1 after every upgrade ...
+\layout Standard
+
+This is surely a minor point - also things will change during the "BIG"
+ rewrite, but maybe this is a point to keep in mind for this ?
+\layout Standard
+
+3.) upgrade: old, sometimes obsolete files stay in the ~/.ipython subdirectory.
+ (hmm, maybe one could move all these into some subdirectory, but which
+ name for that (via version-number ?) ?)
+\layout Subsection
+
+Command line options
+\layout Standard
+
+It would be great to design the command-line processing system so that it
+ can be dynamically modified in some easy way.
+ This would allow systems based on IPython to include their own command-line
+ processing to either extend or fully replace IPython's.
+ Probably moving to the new optparse library (also known as optik) will
+ make this a lot easier.
+\layout Section
+
+OS-dependent code
+\layout Standard
+
+Options which are OS-dependent (such as colors and aliases) should be loaded
+ via include files.
+ That is, the general file will have:
+\layout Standard
+
+
+\family typewriter 
+if os.name == 'posix':
+\newline 
+include('ipythonrc-posix.py')
+\newline 
+elif os.name == 'nt':
+\newline 
+include('ipythonrc-nt.py')...
+\layout Standard
+
+In the 
+\family typewriter 
+-posix
+\family default 
+, 
+\family typewriter 
+-nt
+\family default 
+, etc.
+ files we'll set all os-specific options.
+\layout Section
+
+Merging with other shell systems
+\layout Standard
+
+This is listed before the big design issues, as it is something which should
+ be kept in mind when that design is made.
+\layout Standard
+
+The following shell systems are out there and I think the whole design of
+ IPython should try to be modular enough to make it possible to integrate
+ its features into these.
+ In all cases IPython should exist as a stand-alone, terminal based program.
+ But it would be great if users of these other shells (some of them which
+ have very nice features of their own, especially the graphical ones) could
+ keep their environment but gain IPython's features.
+\layout List
+\labelwidthstring 00.00.0000
+
+IDLE This is the standard, distributed as part of Python.
+ 
+\layout List
+\labelwidthstring 00.00.0000
+
+pyrepl 
+\begin_inset LatexCommand \htmlurl{http://starship.python.net/crew/mwh/hacks/pyrepl.html}
+
+\end_inset 
+
+.
+ This is a text (curses-based) shell-like replacement which doesn't have
+ some of IPython's features, but has a crucially useful (and hard to implement)
+ one: full multi-line editing.
+ This turns the interactive interpreter into a true code testing and development
+ environment.
+ 
+\layout List
+\labelwidthstring 00.00.0000
+
+PyCrust 
+\begin_inset LatexCommand \htmlurl{http://sourceforge.net/projects/pycrust}
+
+\end_inset 
+
+.
+ Very nice, wxWindows based system.
+\layout List
+\labelwidthstring 00.00.0000
+
+PythonWin 
+\begin_inset LatexCommand \htmlurl{http://starship.python.net/crew/mhammond}
+
+\end_inset 
+
+.
+ Similar to PyCrust in some respects, a very good and free Python development
+ environment for Windows systems.
+\layout Section
+
+Class design
+\layout Standard
+
+This is the big one.
+ Currently classes use each other in a very messy way, poking inside one
+ another for data and methods.
+ ipmaker() adds tons of stuff to the main __IP instance by hand, and the
+ mix-ins used (Logger, Magic, etc) mean the final __IP instance has a million
+ things in it.
+ All that needs to be cleanly broken down with well defined interfaces amongst
+ the different classes, and probably no mix-ins.
+\layout Standard
+
+The best approach is probably to have all the sub-systems which are currently
+ mixins be fully independent classes which talk back only to the main instance
+ (and 
+\series bold 
+not
+\series default 
+ to each other).
+ In the main instance there should be an object whose job is to handle communica
+tion with the sub-systems.
+\layout Standard
+
+I should probably learn a little UML and diagram this whole thing before
+ I start coding.
+\layout Subsection
+
+Magic
+\layout Standard
+
+Now all methods which will become publicly available are called Magic.magic_name,
+ the magic_ should go away.
+ Then, Magic instead of being a mix-in should simply be an attribute of
+ __IP:
+\layout Standard
+
+__IP.Magic = Magic()
+\layout Standard
+
+This will then give all the magic functions as __IP.Magic.name(), which is
+ much cleaner.
+ This will also force a better separation so that Magic doesn't poke inside
+ __IP so much.
+ In the constructor, Magic should get whatever information it needs to know
+ about __IP (even if it means a pointer to __IP itself, but at least we'll
+ know where it is.
+ Right now since it's a mix-in, there's no way to know which variables belong
+ to whom).
+\layout Standard
+
+Build a class MagicFunction so that adding new functions is a matter of:
+\layout Standard
+
+
+\family typewriter 
+my_magic = MagicFunction(category = 'System utilities')
+\newline 
+my_magic.__call__ = ...
+\layout Standard
+
+Features:
+\layout Itemize
+
+The class constructor should automatically register the functions and keep
+ a table with category sections for easy sorting/viewing.
+\layout Itemize
+
+The object interface must allow automatic building of a GUI for them.
+ This requires registering the options the command takes, the number of
+ arguments, etc, in a formal way.
+ The advantage of this approach is that it allows not only to add GUIs to
+ the magics, but also for a much more intelligent building of docstrings,
+ and better parsing of options and arguments.
+\layout Standard
+
+Also think through better an alias system for magics.
+ Since the magic system is like a command shell inside ipython, the relation
+ between these aliases and system aliases should be cleanly thought out.
+\layout Subsection
+
+Color schemes
+\layout Standard
+
+These should be loaded from some kind of resource file so they are easier
+ to modify by the user.
+\layout Section
+
+Hooks
+\layout Standard
+
+IPython should have a modular system where functions can register themselves
+ for certain tasks.
+ Currently changing functionality requires overriding certain specific methods,
+ there should be a clean API for this to be done.
+\layout Subsection
+
+whos hook
+\layout Standard
+
+This was a very nice suggestion from Alexander Schmolck <a.schmolck@gmx.net>:
+\layout Standard
+
+2.
+ I think it would also be very helpful if there where some sort of hook
+ for ``whos`` that let one customize display formaters depending on the
+ object type.
+\layout Standard
+
+For example I'd rather have a whos that formats an array like:
+\layout Standard
+
+
+\family typewriter 
+Variable Type Data/Length
+\newline 
+------------------------------ 
+\newline 
+a array size: 4x3 type: 'Float'
+\layout Standard
+
+than
+\layout Standard
+
+
+\family typewriter 
+Variable Type Data/Length 
+\newline 
+------------------------------
+\newline 
+a array [[ 0.
+ 1.
+ 2.
+ 3<...> 8.
+ 9.
+ 10.
+ 11.]]
+\layout Section
+
+Parallel support
+\layout Standard
+
+For integration with graphical shells and other systems, it will be best
+ if ipython is split into a kernel/client model, much like Mathematica works.
+ This simultaneously opens the door for support of interactive parallel
+ computing.
+ Currenlty %bg provides a threads-based proof of concept, and Brian Granger's
+ XGrid project is a much more realistic such system.
+ The new design should integrates ideas as core elements.
+ Some notes from Brian on this topic:
+\layout Standard
+
+1.
+ How should the remote python server/kernel be designed? Multithreaded?
+ Blocking? Connected/disconnected modes? Load balancing?
+\layout Standard
+
+2.
+ What APi/protocol should the server/kernel expose to clients?
+\layout Standard
+
+3.
+ How should the client classes (which the user uses to interact with the
+ cluster) be designed?
+\layout Standard
+
+4.
+ What API should the client classes expose?
+\layout Standard
+
+5.
+ How should the client API be wrapped in a few simple magic functions?
+\layout Standard
+
+6.
+ How should security be handled?
+\layout Standard
+
+7.
+ How to work around the issues of the GIL and threads?
+\layout Standard
+
+I think the most important things to work out are the client API (#4) the
+ server/kernel API/protocol (#2) and the magic function API (#5).
+ We should let these determine the design and architecture of the components.
+\layout Standard
+
+One other thing.
+ What is your impression of twisted? I have been looking at it and it looks
+ like a _very_ powerful set of tools for this type of stuff.
+ I am wondering if it might make sense to think about using twisted for
+ this project.
+\layout Section
+
+Manuals
+\layout Standard
+
+The documentation should be generated from docstrings for the command line
+ args and all the magic commands.
+ Look into one of the simple text markup systems to see if we can get latex
+ (for reLyXing later) out of this.
+ Part of the build command would then be to make an update of the docs based
+ on this, thus giving more complete manual (and guaranteed to be in sync
+ with the code docstrings).
+\layout Standard
+
+[PARTLY DONE] At least now all magics are auto-documented, works farily
+ well.
+ Limited Latex formatting yet.
+\layout Subsection
+
+Integration with pydoc-help
+\layout Standard
+
+It should be possible to have access to the manual via the pydoc help system
+ somehow.
+ This might require subclassing the pydoc help, or figuring out how to add
+ the IPython docs in the right form so that help() finds them.
+\layout Standard
+
+Some comments from Arnd and my reply on this topic:
+\layout Standard
+
+> ((Generally I would like to have the nice documentation > more easily
+ accessable from within ipython ...
+ > Many people just don't read documentation, even if it is > as good as
+ the one of IPython ))
+\layout Standard
+
+That's an excellent point.
+ I've added a note to this effect in new_design.
+ Basically I'd like help() to naturally access the IPython docs.
+ Since they are already there in html for the user, it's probably a matter
+ of playing a bit with pydoc to tell it where to find them.
+ It would definitely make for a much cleaner system.
+ Right now the information on IPython is:
+\layout Standard
+
+-ipython --help at the command line: info on command line switches 
+\layout Standard
+
+-? at the ipython prompt: overview of IPython 
+\layout Standard
+
+-magic at the ipython prompt: overview of the magic system 
+\layout Standard
+
+-external docs (html/pdf)
+\layout Standard
+
+All that should be better integrated seamlessly in the help() system, so
+ that you can simply say:
+\layout Standard
+
+help ipython -> full documentation access 
+\layout Standard
+
+help magic -> magic overview 
+\layout Standard
+
+help profile -> help on current profile 
+\layout Standard
+
+help -> normal python help access.
+\layout Section
+
+Graphical object browsers
+\layout Standard
+
+I'd like a system for graphically browsing through objects.
+ 
+\family typewriter 
+@obrowse
+\family default 
+ should open a widged with all the things which 
+\family typewriter 
+@who
+\family default 
+ lists, but cliking on each object would open a dedicated object viewer
+ (also accessible as 
+\family typewriter 
+@oview <object>
+\family default 
+).
+ This object viewer could show a summary of what 
+\family typewriter 
+<object>?
+\family default 
+ currently shows, but also colorize source code and show it via an html
+ browser, show all attributes and methods of a given object (themselves
+ openable in their own viewers, since in Python everything is an object),
+ links to the parent classes, etc.
+\layout Standard
+
+The object viewer widget should be extensible, so that one can add methods
+ to view certain types of objects in a special way (for example, plotting
+ Numeric arrays via grace or gnuplot).
+ This would be very useful when using IPython as part of an interactive
+ complex system for working with certain types of data.
+\layout Standard
+
+I should look at what PyCrust has to offer along these lines, at least as
+ a starting point.
+\layout Section
+
+Miscellaneous small things
+\layout Itemize
+
+Collect whatever variables matter from the environment in some globals for
+ __IP, so we're not testing for them constantly (like $HOME, $TERM, etc.)
+\layout Section
+
+Session restoring
+\layout Standard
+
+I've convinced myself that session restore by log replay is too fragile
+ and tricky to ever work reliably.
+ Plus it can be dog slow.
+ I'd rather have a way of saving/restoring the *current* memory state of
+ IPython.
+ I tried with pickle but failed (can't pickle modules).
+ This seems the right way to do it to me, but it will have to wait until
+ someone tells me of a robust way of dumping/reloading *all* of the user
+ namespace in a file.
+\layout Standard
+
+Probably the best approach will be to pickle as much as possible and record
+ what can not be pickled for manual reload (such as modules).
+ This is not trivial to get to work reliably, so it's best left for after
+ the code restructuring.
+\layout Standard
+
+The following issues exist (old notes, see above paragraph for my current
+ take on the issue):
+\layout Itemize
+
+magic lines aren't properly re-executed when a log file is reloaded (and
+ some of them, like clear or run, may change the environment).
+ So session restore isn't 100% perfect.
+\layout Itemize
+
+auto-quote/parens lines aren't replayed either.
+ All this could be done, but it needs some work.
+ Basically it requires re-running the log through IPython itself, not through
+ python.
+\layout Itemize
+
+_p variables aren't restored with a session.
+ Fix: same as above.
+\layout Section
+
+Tips system
+\layout Standard
+
+It would be nice to have a tip() function which gives tips to users in some
+ situations, but keeps track of already-given tips so they aren't given
+ every time.
+ This could be done by pickling a dict of given tips to IPYTHONDIR.
+\layout Section
+
+TAB completer
+\layout Standard
+
+Some suggestions from Arnd Baecker:
+\layout Standard
+
+a) For file related commands (ls, cat, ...) it would be nice to be able to
+ TAB complete the files in the current directory.
+ (once you started typing something which is uniquely a file, this leads
+ to this effect, apart from going through the list of possible completions
+ ...).
+ (I know that this point is in your documentation.)
+\layout Standard
+
+More general, this might lead to something like command specific completion
+ ? 
+\layout Standard
+
+Here's John Hunter's suggestion:
+\layout Standard
+
+The *right way to do it* would be to make intelligent or customizable choices
+ about which namespace to add to the completion list depending on the string
+ match up to the prompt, eg programmed completions.
+ In the simplest implementation, one would only complete on files and directorie
+s if the line preceding the tab press matched 'cd ' or 'run ' (eg you don't
+ want callable showing up in 'cd ca<TAB>')
+\layout Standard
+
+In a more advanced scenario, you might imaging that functions supplied the
+ TAB namespace, and the user could configure a dictionary that mapped regular
+ expressions to namespace providing functions (with sensible defaults).
+ Something like
+\layout Standard
+
+completed = {
+\newline 
+'^cd
+\backslash 
+s+(.*)' : complete_files_and_dirs,
+\newline 
+'^run
+\backslash 
+s+(.*)' : complete_files_and_dirs,
+\newline 
+'^run
+\backslash 
+s+(-.*)' : complete_run_options,
+\newline 
+}
+\layout Standard
+
+I don't know if this is feasible, but I really like programmed completions,
+ which I use extensively in tcsh.
+ My feeling is that something like this is eminently doable in ipython.
+\layout Standard
+
+/JDH
+\layout Standard
+
+For something like this to work cleanly, the magic command system needs
+ also a clean options framework, so all valid options for a given magic
+ can be extracted programatically.
+\layout Section
+
+Debugger
+\layout Standard
+
+Current system uses a minimally tweaked pdb.
+ Fine-tune it a bit, to provide at least:
+\layout Itemize
+
+Tab-completion in each stack frame.
+ See email to Chris Hart for details.
+\layout Itemize
+
+Object information via ? at least.
+ Break up magic_oinfo a bit so that pdb can call it without loading all
+ of IPython.
+ If possible, also have the other magics for object study: doc, source,
+ pdef and pfile.
+\layout Itemize
+
+Shell access via !
+\layout Itemize
+
+Syntax highlighting in listings.
+ Use py2html code, implement color schemes.
+\layout Section
+
+A Python-based system shell - pysh?
+\layout Standard
+
+Note: as of IPython 0.6.1, most of this functionality has actually been implemente
+d.
+\layout Standard
+
+This section is meant as a working draft for discussions on the possibility
+ of having a python-based system shell.
+ It is the result of my own thinking about these issues as much of discussions
+ on the ipython lists.
+ I apologize in advance for not giving individual credit to the various
+ contributions, but right now I don't have the time to track down each message
+ from the archives.
+ So please consider this as the result of a collective effort by the ipython
+ user community.
+\layout Standard
+
+While IPyhton is (and will remain) a python shell first, it does offer a
+ fair amount of system access functionality:
+\layout Standard
+
+- ! and !! for direct system access,
+\layout Standard
+
+- magic commands which wrap various system commands,
+\layout Standard
+
+- @sc and @sx, for shell output capture into python variables,
+\layout Standard
+
+- @alias, for aliasing system commands.
+\layout Standard
+
+This has prompted many users, over time, to ask for a way of extending ipython
+ to the point where it could be used as a full-time replacement over typical
+ user shells like bash, csh or tcsh.
+ While my interest in ipython is such that I'll concentrate my personal
+ efforts on other fronts (debugging, architecture, improvements for scientific
+ use, gui access), I will be happy to do anything which could make such
+ a development possible.
+ It would be the responsibility of someone else to maintain the code, but
+ I would do all necessary architectural changes to ipython for such an extension
+ to be feasible.
+\layout Standard
+
+I'll try to outline here what I see as the key issues which need to be taken
+ into account.
+ This document should be considered an evolving draft.
+ Feel free to submit comments/improvements, even in the form of patches.
+\layout Standard
+
+In what follows, I'll represent the hypothetical python-based shell ('pysh'
+ for now) prompt with '>>'.
+\layout Subsection
+
+Basic design principles
+\layout Standard
+
+I think the basic design guideline should be the following: a hypothetical
+ python system shell should behave, as much as possible, like a normal shell
+ that users are familiar with (bash, tcsh, etc).
+ This means:
+\layout Standard
+
+1.
+ System commands can be issued directly at the prompt with no special syntax:
+\layout Standard
+
+>> ls
+\layout Standard
+
+>> xemacs
+\layout Standard
+
+should just work like a user expects.
+\layout Standard
+
+2.
+ The facilities of the python language should always be available, like
+ they are in ipython:
+\layout Standard
+
+>> 3+4 
+\newline 
+7
+\layout Standard
+
+3.
+ It should be possible to easily capture shell output into a variable.
+ bash and friends use backquotes, I think using a command (@sc) like ipython
+ currently does is an acceptable compromise.
+\layout Standard
+
+4.
+ It should also be possible to expand python variables/commands in the middle
+ of system commands.
+ I thihk this will make it necessary to use $var for name expansions:
+\layout Standard
+
+>> var='hello' # var is a Python variable 
+\newline 
+>> print var hello # This is the result of a Python print command 
+\newline 
+>> echo $var hello # This calls the echo command, expanding 'var'.
+\layout Standard
+
+5.
+ The above capabilities should remain possible for multi-line commands.
+ One of the most annoying things I find about tcsh, is that I never quite
+ remember the syntactic details of looping.
+ I often want to do something at the shell which involves a simple loop,
+ but I can never remember how to do it in tcsh.
+ This often means I just write a quick throwaway python script to do it
+ (Perl is great for this kind of quick things, but I've forgotten most its
+ syntax as well).
+\layout Standard
+
+It should be possible to write code like:
+\layout Standard
+
+>> for ext in ['.jpg','.gif']: 
+\newline 
+..
+ ls file$ext
+\layout Standard
+
+And have it work as 'ls file.jpg;ls file.gif'.
+\layout Subsection
+
+Smaller details 
+\layout Standard
+
+If the above are considered as valid guiding principles for how such a python
+ system shell should behave, then some smaller considerations and comments
+ to keep in mind are listed below.
+\layout Standard
+
+- it's ok for shell builtins (in this case this includes the python language)
+ to override system commands on the path.
+ See tcsh's 'time' vs '/usr/bin/time'.
+ This settles the 'print' issue and related.
+\layout Standard
+
+- pysh should take
+\layout Standard
+
+foo args
+\layout Standard
+
+as a command if (foo args is NOT valid python) and (foo is in $PATH).
+\layout Standard
+
+If the user types
+\layout Standard
+
+>> ./foo args
+\layout Standard
+
+it should be considered a system command always.
+\layout Standard
+
+- _, __ and ___ should automatically remember the previous 3 outputs captured
+ from stdout.
+ In parallel, there should be _e, __e and ___e for stderr.
+ Whether capture is done as a single string or in list mode should be a
+ user preference.
+ If users have numbered prompts, ipython's full In/Out cache system should
+ be available.
+\layout Standard
+
+But regardless of how variables are captured, the printout should be like
+ that of a plain shell (without quotes or braces to indicate strings/lists).
+ The everyday 'feel' of pysh should be more that of bash/tcsh than that
+ of ipython.
+\layout Standard
+
+- filename completion first.
+ Tab completion could work like in ipython, but with the order of priorities
+ reversed: first files, then python names.
+\layout Standard
+
+- configuration via standard python files.
+ Instead of 'setenv' you'd simply write into the os.environ[] dictionary.
+ This assumes that IPython itself has been fixed to be configured via normal
+ python files, instead of the current clunky ipythonrc format.
+\layout Standard
+
+- IPython can already configure the prompt in fairly generic ways.
+ It should be able to generate almost any kind of prompt which bash/tcsh
+ can (within reason).
+\layout Standard
+
+- Keep the Magics system.
+ They provide a lightweight syntax for configuring and modifying the state
+ of the user's session itself.
+ Plus, they are an extensible system so why not give the users one more
+ tool which is fairly flexible by nature? Finally, having the @magic optional
+ syntax allows a user to always be able to access the shell's control system,
+ regardless of name collisions with defined variables or system commands.
+\layout Standard
+
+But we need to move all magic functionality into a protected namespace,
+ instead of the current messy name-mangling tricks (which don't scale well).
+ 
+\layout Section
+
+Future improvements
+\layout Itemize
+
+When from <mod> import * is used, first check the existing namespace and
+ at least issue a warning on screen if names are overwritten.
+\layout Itemize
+
+Auto indent? Done, for users with readline support.
+\layout Subsection
+
+Better completion a la zsh
+\layout Standard
+
+This was suggested by Arnd:
+\layout Standard
+
+> >\SpecialChar ~
+\SpecialChar ~
+\SpecialChar ~
+ More general, this might lead to something like
+\layout Standard
+
+> >\SpecialChar ~
+\SpecialChar ~
+\SpecialChar ~
+ command specific completion ?
+\layout Standard
+
+>
+\layout Standard
+
+> I'm not sure what you mean here.
+\layout Standard
+
+\SpecialChar ~
+
+\layout Standard
+
+Sorry, that was not understandable, indeed ...
+\layout Standard
+
+I thought of something like
+\layout Standard
+
+\SpecialChar ~
+- cd and then use TAB to go through the list of directories
+\layout Standard
+
+\SpecialChar ~
+- ls and then TAB to consider all files and directories
+\layout Standard
+
+\SpecialChar ~
+- cat and TAB: only files (no directories ...)
+\layout Standard
+
+\SpecialChar ~
+
+\layout Standard
+
+For zsh things like this are established by defining in .zshrc
+\layout Standard
+
+\SpecialChar ~
+
+\layout Standard
+
+compctl -g '*.dvi' xdvi
+\layout Standard
+
+compctl -g '*.dvi' dvips
+\layout Standard
+
+compctl -g '*.tex' latex
+\layout Standard
+
+compctl -g '*.tex' tex
+\layout Standard
+
+...
+\layout Section
+
+Outline of steps
+\layout Standard
+
+Here's a rough outline of the order in which to start implementing the various
+ parts of the redesign.
+ The first 'test of success' should be a clean pychecker run (not the mess
+ we get right now).
+\layout Itemize
+
+Make Logger and Magic not be mixins but attributes of the main class.
+ 
+\begin_deeper 
+\layout Itemize
+
+Magic should have a pointer back to the main instance (even if this creates
+ a recursive structure) so it can control it with minimal message-passing
+ machinery.
+ 
+\layout Itemize
+
+Logger can be a standalone object, simply with a nice, clean interface.
+\layout Itemize
+
+Logger currently handles part of the prompt caching, but other parts of
+ that are in the prompts class itself.
+ Clean up.
+\end_deeper 
+\layout Itemize
+
+Change to python-based config system.
+\layout Itemize
+
+Move make_IPython() into the main shell class, as part of the constructor.
+ Do this 
+\emph on 
+after 
+\emph default 
+the config system has been changed, debugging will be a lot easier then.
+\layout Itemize
+
+Merge the embeddable class and the normal one into one.
+ After all, the standard ipython script 
+\emph on 
+is
+\emph default 
+ a python program with IPython embedded in it.
+ There's no need for two separate classes (
+\emph on 
+maybe
+\emph default 
+ keep the old one around for the sake of backwards compatibility).
+\layout Section
+
+Ville Vainio's suggestions
+\layout Standard
+
+Some notes sent in by Ville Vainio 
+\family typewriter 
+<vivainio@kolumbus.fi>
+\family default 
+ on Tue, 29 Jun 2004.
+ Keep here for reference, some of it replicates things already said above.
+\layout Standard
+
+Current ipython seems to "special case" lots of stuff - aliases, magics
+ etc.
+ It would seem to yield itself to a simpler and more extensible architecture,
+ consisting of multple dictionaries, where just the order of search is determine
+d by profile/prefix.
+ All the functionality would just be "pushed" to ipython core, i.e.
+ the objects that represent the functionality are instantiated on "plugins"
+ and they are registered with ipython core.
+ i.e.
+\layout Standard
+
+def magic_f(options, args): pass
+\layout Standard
+
+m = MyMagic(magic_f) m.arghandler = stockhandlers.OptParseArgHandler m.options
+ = ....
+ # optparse options, for easy passing to magic_f and help display
+\layout Standard
+
+# note that arghandler takes a peek at the instance, sees options, and proceeds
+ # accordingly.
+ Various arg handlers can ask for arbitrary options.
+ # some handler might optionally glob the filenames, search data folders
+ for filenames etc.
+\layout Standard
+
+ipythonregistry.register(category = "magic", name = "mymagic", obj = m)
+\layout Standard
+
+I bet most of the current functionality could easily be added to such a
+ registry by just instantiating e.g.
+ "Magic" class and registering all the functions with some sensible default
+ args.
+ Supporting legacy stuff in general would be easy - just implement new handlers
+ (arg and otherwise) for new stuff, and have the old handlers around forever
+ / as long as is deemed appropriate.
+ The 'python' namespace (locals() + globals()) should be special, of course.
+\layout Standard
+
+It should be easy to have arbitrary number of "categories" (like 'magic',
+ 'shellcommand','projectspecific_myproject', 'projectspecific_otherproject').
+ It would only influence the order in which the completions are suggested,
+ and in case of name collision which one is selected.
+ Also, I think all completions should be shown, even the ones in "later"
+ categories in the case of a match in an "earlier" category.
+\layout Standard
+
+The "functionality object" might also have a callable object 'expandarg',
+ and ipython would run it (with the arg index) when tab completion is attempted
+ after typing the function name.
+ It would return the possible completions for that particular command...
+ or None to "revert to default file completions".
+ Such functionality could be useful in making ipython an "operating console"
+ of a sort.
+ I'm talking about:
+\layout Standard
+
+>> lscat reactor # list commands in category - reactor is "project specific"
+ category
+\layout Standard
+
+r_operate
+\layout Standard
+
+>> r_operate <tab> start shutdown notify_meltdown evacuate
+\layout Standard
+
+>> r_operate shutdown <tab>
+\layout Standard
+
+1 2 5 6 # note that 3 and 4 are already shut down
+\layout Standard
+
+>> r_operate shutdown 2
+\layout Standard
+
+Shutting down..
+ ok.
+\layout Standard
+
+>> r_operate start <tab>
+\layout Standard
+
+2 3 4 # 2 was shut down, can be started now
+\layout Standard
+
+>> r_operate start 2
+\layout Standard
+
+Starting....
+ ok.
+\layout Standard
+
+I'm talking about having a super-configurable man-machine language here!
+ Like cmd.Cmd on steroids, as a free addition to ipython!
+\the_end
diff --git a/doc/pycolor.1 b/doc/pycolor.1
new file mode 100644
index 0000000..9483703
--- /dev/null
+++ b/doc/pycolor.1
@@ -0,0 +1,38 @@
+.\"                                      Hey, EMACS: -*- nroff -*-
+.\" First parameter, NAME, should be all caps
+.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
+.\" other parameters are allowed: see man(7), man(1)
+.TH PYCOLOR 1 "May 12, 2007"
+.\" Please adjust this date whenever revising the manpage.
+.\"
+.\" Some roff macros, for reference:
+.\" .nh        disable hyphenation
+.\" .hy        enable hyphenation
+.\" .ad l      left justify
+.\" .ad b      justify to both left and right margins
+.\" .nf        disable filling
+.\" .fi        enable filling
+.\" .br        insert line break
+.\" .sp <n>    insert n+1 empty lines
+.\" for manpage-specific macros, see man(7)
+.SH NAME
+pycolor \- Colorize a python file or stdin using ANSI and print to stdout.
+.SH SYNOPSIS
+.B pycolor
+.RI [ options ]
+.RI [ file ]
+.SH DESCRIPTION
+Prints a colorized version of the input file (or standard input if no file is
+given, or the file name - is given) to standard out.
+.SH OPTIONS
+.TP
+.B \-h, \-\-help
+Output a brief help message.
+.TP
+.B \-s, \-\-scheme <scheme>
+Give the color scheme to use.  Currently only Linux (default),
+LightBG, and NOColor are implemented.
+.SH AUTHOR
+pycolor was written by Fernando Perez <fperez@colorado.edu>.
+This manual page was written by Jack Moffitt <jack@xiph.org>,
+for the Debian project (but may be used by others).
diff --git a/doc/pycon.ico b/doc/pycon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..55ee14afa610b8d540e57ef29faecc31224732bb
GIT binary patch
literal 771
zc$|e&p>D%46g=0HqIRlUG`hgSNRJuqQ}zjEAq7?nI=0aaMG7-2-++rYP^rIAxKAjk
zls(&xn?&7q_Sw06&o8!YKyXXbIUK%6z#Y#I%#``a6u9v*J;E>0zC-IUx#lb$thMYk
zzN2Zv<eIbG@E?-Ag9UJW?qJROrHME?y|}EMd0o2C>BJCa!5F`p3ZR-OXq2@xOw{97
z$%d?3jS|xM62X{Gl*&+7Qk@OM;FL>-QA!!kXiE^0QWeML*~mz;W1=SVDN##rP!;zS
z3`uDB1j$}JByhWV-(+2FKkT1+knbw?H2Lyg53%b3$oHpa-|S8-K9@PLz68IPSJn^U
u?(V=>%}+)0yAhEIL?N^&@WjlRbJ2?rSTI)_+m%h2vpx^^+iPpwzkdLZKh0_Y

literal 0
Hc$@<O00001

diff --git a/doc/update_magic.sh b/doc/update_magic.sh
new file mode 100644
index 0000000..4a7c658
--- /dev/null
+++ b/doc/update_magic.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+ipython --magic_docstrings > magic.tex
\ No newline at end of file
diff --git a/doc/update_manual.py b/doc/update_manual.py
new file mode 100644
index 0000000..2ab5e64
--- /dev/null
+++ b/doc/update_manual.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env ipython
+""" Must be launched via ipython not normal python 
+
+Run by:
+    
+    ipython update_manual.py
+"""
+
+import sys,IPython,re
+
+fil=open("magic.tex","w")
+oldout=sys.stdout
+sys.stdout=fil
+_ip.magic("magic -latex")
+sys.stdout=oldout
+fil.close()
+
+fil=open("manual_base.lyx")
+txt=fil.read()
+fil.close()
+
+manualtext=re.sub("__version__",IPython.__version__,txt)
+fil=open("manual.lyx","w")
+fil.write(manualtext)
+fil.close()
+print "Manual (magic.tex, manual.lyx) succesfully updated, exiting..."
+import os
+os.abort()
diff --git a/doc/update_version.sh b/doc/update_version.sh
new file mode 100644
index 0000000..712d06e
--- /dev/null
+++ b/doc/update_version.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+ver=`ipython -V`
+sed "s/__version__/${ver}/" manual_base.lyx > manual.lyx
diff --git a/eggsetup.py b/eggsetup.py
new file mode 100644
index 0000000..5070bce
--- /dev/null
+++ b/eggsetup.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+"""Wrapper to build IPython as an egg (setuptools format)."""
+
+import os
+import sys
+
+# Add my local path to sys.path
+home = os.environ['HOME']
+sys.path.insert(0,'%s/usr/local/lib/python%s/site-packages' %
+                (home,sys.version[:3]))
+
+# now, import setuptools and call the actual setup
+import setuptools
+print sys.argv
+#sys.argv=['','bdist_egg']
+execfile('setup.py')
+
+# clean up the junk left around by setuptools
+if "develop" not in sys.argv:
+    os.system('rm -rf ipython.egg-info build')
diff --git a/exesetup.py b/exesetup.py
new file mode 100644
index 0000000..1fa7cd6
--- /dev/null
+++ b/exesetup.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+r"""Setup script for exe distribution of IPython (does not require python).
+
+- Requires py2exe
+
+- install pyreadline *package dir* in ipython root directory by running:
+  
+svn co http://ipython.scipy.org/svn/ipython/pyreadline/branches/maintenance_1.3/pyreadline/  
+wget http://ipython.scipy.org/svn/ipython/pyreadline/branches/maintenance_1.3/readline.py
+
+OR (if you want the latest trunk):  
+  
+svn co http://ipython.scipy.org/svn/ipython/pyreadline/trunk/pyreadline
+
+- Create the distribution in 'dist' by running "python exesetup.py py2exe"
+
+- Run ipython.exe to go.
+
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2005 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+# Stdlib imports
+import os
+import sys
+
+from glob import glob
+
+
+# A few handy globals
+isfile = os.path.isfile
+pjoin = os.path.join
+
+from distutils.core import setup
+from distutils import dir_util
+import py2exe
+
+# update the manuals when building a source dist
+# Release.py contains version, authors, license, url, keywords, etc.
+execfile(pjoin('IPython','Release.py'))
+
+# A little utility we'll need below, since glob() does NOT allow you to do
+# exclusion on multiple endings!
+def file_doesnt_endwith(test,endings):
+    """Return true if test is a file and its name does NOT end with any
+    of the strings listed in endings."""
+    if not isfile(test):
+        return False
+    for e in endings:
+        if test.endswith(e):
+            return False
+    return True
+
+
+egg_extra_kwds = {}
+
+# Call the setup() routine which does most of the work
+setup(name             = name,
+    options   = {
+    'py2exe': {
+        'packages' : ['IPython', 'IPython.Extensions', 'IPython.external',
+                      'pyreadline'],
+        'excludes' : ["Tkconstants","Tkinter","tcl",'IPython.igrid','wx',
+                      'wxPython','igrid', 'PyQt4', 'zope', 'Zope', 'Zope2',
+                      '_curses','enthought.traits','gtk','qt', 'pydb','idlelib',                      
+                      ]
+                    
+                     }
+    },
+    version          = version,
+    description      = description,
+    long_description = long_description,
+    author           = authors['Fernando'][0],
+    author_email     = authors['Fernando'][1],
+    url              = url,
+    download_url     = download_url,
+    license          = license,
+    platforms        = platforms,
+    keywords         = keywords,
+    console          = ['ipykit.py'],
+    
+    # extra params needed for eggs
+    **egg_extra_kwds                        
+    )
+
+minimal_conf = """
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+ip.load('ipy_kitcfg')
+import ipy_profile_sh
+"""
+
+if not os.path.isdir("dist/_ipython"):
+    print "Creating simple _ipython dir"
+    os.mkdir("dist/_ipython")
+    open("dist/_ipython/ipythonrc.ini","w").write("# intentionally blank\n")
+    open("dist/_ipython/ipy_user_conf.py","w").write(minimal_conf)
+    if os.path.isdir('bin'):
+        dir_util.copy_tree('bin','dist/bin')
diff --git a/ipykit.py b/ipykit.py
new file mode 100644
index 0000000..a750788
--- /dev/null
+++ b/ipykit.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+""" IPykit launcher
+
+w/o args, this launches a full ipykit session.
+
+If the first arg is a .py script, it will be run WITHOUT ipython,
+to facilitate running python scripts almost normally on machines w/o python
+in their own process (as opposed to %run).
+
+"""
+
+import sys
+if len(sys.argv) > 1 and sys.argv[1].endswith('.py'):
+    # shortcut for running ipykit.exe directly on a .py file - do not bother
+    # starting ipython, just handle as normal python scripts
+    sys.argv = sys.argv[1:]
+    execfile(sys.argv[0])
+else:
+    import IPython  
+    IPython.Shell.start().mainloop()
diff --git a/ipython.py b/ipython.py
new file mode 100644
index 0000000..5be0994
--- /dev/null
+++ b/ipython.py
@@ -0,0 +1,11 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""IPython -- An enhanced Interactive Python
+
+The actual ipython script to be installed with 'python setup.py install' is
+in './scripts' directory. This file is here (ipython source root directory)
+to facilitate non-root 'zero-installation' (just copy the source tree
+somewhere and run ipython.py) and development. """
+
+import IPython.Shell
+IPython.Shell.start().mainloop()
diff --git a/scripts/ipython b/scripts/ipython
new file mode 100644
index 0000000..0f923d9
--- /dev/null
+++ b/scripts/ipython
@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""IPython -- An enhanced Interactive Python
+
+This is just the startup wrapper script, kept deliberately to a minimum.
+
+The shell's mainloop() takes an optional argument, sys_exit (default=0). If
+set to 1, it calls sys.exit() at exit time. You can use the following code in
+your PYTHONSTARTUP file:
+
+import IPython
+IPython.Shell.IPShell().mainloop(sys_exit=1)
+
+[or simply IPython.Shell.IPShell().mainloop(1) ]
+
+and IPython will be your working environment when you start python. The final
+sys.exit() call will make python exit transparently when IPython finishes, so
+you don't have an extra prompt to get out of.
+
+This is probably useful to developers who manage multiple Python versions and
+don't want to have correspondingly multiple IPython versions. Note that in
+this mode, there is no way to pass IPython any command-line options, as those
+are trapped first by Python itself.
+"""
+
+import IPython
+IPython.Shell.start().mainloop()
diff --git a/scripts/ipython_win_post_install.py b/scripts/ipython_win_post_install.py
new file mode 100644
index 0000000..3bc761d
--- /dev/null
+++ b/scripts/ipython_win_post_install.py
@@ -0,0 +1,85 @@
+#!python
+"""Windows-specific part of the installation"""
+
+import os, sys, shutil
+
+def mkshortcut(target,description,link_file,*args,**kw):
+    """make a shortcut if it doesn't exist, and register its creation"""
+    
+    create_shortcut(target, description, link_file,*args,**kw)
+    file_created(link_file)
+
+def install():
+    """Routine to be run by the win32 installer with the -install switch."""
+
+    from IPython.Release import version
+
+    # Get some system constants
+    prefix = sys.prefix
+    python = prefix + r'\python.exe'
+    # Lookup path to common startmenu ...
+    ip_dir = get_special_folder_path('CSIDL_COMMON_PROGRAMS') + r'\IPython'
+    
+    # Some usability warnings at installation time.  I don't want them at the
+    # top-level, so they don't appear if the user is uninstalling.
+    try:
+        import ctypes
+    except ImportError:
+        print ('To take full advantage of IPython, you need ctypes from:\n'
+               'http://sourceforge.net/projects/ctypes')
+
+    try:
+        import win32con
+    except ImportError:
+        print ('To take full advantage of IPython, you need pywin32 from:\n'
+               'http://starship.python.net/crew/mhammond/win32/Downloads.html')
+
+    try:
+        import readline
+    except ImportError:
+        print ('To take full advantage of IPython, you need readline from:\n'
+               'http://sourceforge.net/projects/uncpythontools')
+
+    ipybase = '"'+prefix+r'\scripts\ipython"'
+    # Create IPython entry ...
+    if not os.path.isdir(ip_dir):
+        os.mkdir(ip_dir)
+        directory_created(ip_dir)
+
+    # Create program shortcuts ...
+    f = ip_dir + r'\IPython.lnk'
+    a = ipybase
+    mkshortcut(python,'IPython',f,a)
+
+    f = ip_dir + r'\pysh.lnk'
+    a = ipybase+' -p sh'
+    mkshortcut(python,'IPython command prompt mode',f,a)
+
+    f = ip_dir + r'\scipy.lnk'
+    a = ipybase+' -pylab -p scipy'
+    mkshortcut(python,'IPython scipy profile',f,a)
+
+    # Create documentation shortcuts ...    
+    t = prefix + r'\share\doc\ipython-%s\manual.pdf' % version
+    f = ip_dir + r'\Manual in PDF.lnk'
+    mkshortcut(t,r'IPython Manual - PDF-Format',f)
+
+    t = prefix + r'\share\doc\ipython-%s\manual\manual.html' % version
+    f = ip_dir + r'\Manual in HTML.lnk'
+    mkshortcut(t,'IPython Manual - HTML-Format',f)
+
+    # make ipython.py
+    shutil.copy(prefix + r'\scripts\ipython', prefix + r'\scripts\ipython.py')
+    
+def remove():
+    """Routine to be run by the win32 installer with the -remove switch."""
+    pass
+
+# main()
+if len(sys.argv) > 1:
+    if sys.argv[1] == '-install':
+        install()
+    elif sys.argv[1] == '-remove':
+        remove()
+    else:
+        print "Script was called with option %s" % sys.argv[1]
diff --git a/scripts/irunner b/scripts/irunner
new file mode 100644
index 0000000..c350d39
--- /dev/null
+++ b/scripts/irunner
@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+
+"""Thin wrapper around the IPython irunner module.
+
+Run with --help for details, or see the irunner source."""
+
+from IPython import irunner
+
+irunner.main()
diff --git a/scripts/pycolor b/scripts/pycolor
new file mode 100644
index 0000000..5ef07db
--- /dev/null
+++ b/scripts/pycolor
@@ -0,0 +1,6 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Simple wrapper around PyColorize, which colorizes python sources."""
+
+import IPython.PyColorize
+IPython.PyColorize.main()
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..ed33484
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,180 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Setup script for IPython.
+
+Under Posix environments it works like a typical setup.py script. 
+Under Windows, the command sdist is not supported, since IPython 
+requires utilities, which are not available under Windows."""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2005 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+# Stdlib imports
+import os
+import sys
+
+from glob import glob
+from setupext import install_data_ext
+
+# A few handy globals
+isfile = os.path.isfile
+pjoin = os.path.join
+
+# BEFORE importing distutils, remove MANIFEST. distutils doesn't properly
+# update it when the contents of directories change.
+if os.path.exists('MANIFEST'): os.remove('MANIFEST')
+
+if os.name == 'posix':
+    os_name = 'posix'
+elif os.name in ['nt','dos']:
+    os_name = 'windows'
+else:
+    print 'Unsupported operating system:',os.name
+    sys.exit(1)
+
+# Under Windows, 'sdist' is not supported, since it requires lyxport (and
+# hence lyx,perl,latex,pdflatex,latex2html,sh,...)
+if os_name == 'windows' and 'sdist' in sys.argv:
+    print 'The sdist command is not available under Windows.  Exiting.'
+    sys.exit(1)
+
+from distutils.core import setup
+
+# update the manuals when building a source dist
+if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):
+    from IPython.genutils import target_update
+    # list of things to be updated. Each entry is a triplet of args for
+    # target_update()
+    to_update = [('doc/magic.tex',
+                  ['IPython/Magic.py'],
+                  "cd doc && ./update_magic.sh" ),
+                 
+                 ('doc/manual.lyx',
+                  ['IPython/Release.py','doc/manual_base.lyx'],
+                  "cd doc && ./update_version.sh" ),
+                 
+                 ('doc/manual/manual.html',
+                  ['doc/manual.lyx',
+                   'doc/magic.tex',
+                   'doc/examples/example-gnuplot.py',
+                   'doc/examples/example-embed.py',
+                   'doc/examples/example-embed-short.py',
+                   'IPython/UserConfig/ipythonrc',
+                   ],
+                  "cd doc && "
+                  "lyxport -tt --leave --pdf "
+                  "--html -o '-noinfo -split +1 -local_icons' manual.lyx"),
+                 
+                 ('doc/new_design.pdf',
+                  ['doc/new_design.lyx'],
+                  "cd doc && lyxport -tt --pdf new_design.lyx"),
+
+                 ('doc/ipython.1.gz',
+                  ['doc/ipython.1'],
+                  "cd doc && gzip -9c ipython.1 > ipython.1.gz"),
+
+                 ('doc/pycolor.1.gz',
+                  ['doc/pycolor.1'],
+                  "cd doc && gzip -9c pycolor.1 > pycolor.1.gz"),
+                 ]
+    for target in to_update:
+        target_update(*target)
+
+# Release.py contains version, authors, license, url, keywords, etc.
+execfile(pjoin('IPython','Release.py'))
+
+# A little utility we'll need below, since glob() does NOT allow you to do
+# exclusion on multiple endings!
+def file_doesnt_endwith(test,endings):
+    """Return true if test is a file and its name does NOT end with any
+    of the strings listed in endings."""
+    if not isfile(test):
+        return False
+    for e in endings:
+        if test.endswith(e):
+            return False
+    return True
+
+# I can't find how to make distutils create a nested dir. structure, so
+# in the meantime do it manually. Butt ugly.
+# Note that http://www.redbrick.dcu.ie/~noel/distutils.html, ex. 2/3, contain
+# information on how to do this more cleanly once python 2.4 can be assumed.
+# Thanks to Noel for the tip.
+docdirbase  = 'share/doc/ipython-%s' % version
+manpagebase = 'share/man/man1'
+
+# We only need to exclude from this things NOT already excluded in the
+# MANIFEST.in file.
+exclude     = ('.sh','.1.gz')
+docfiles    = filter(lambda f:file_doesnt_endwith(f,exclude),glob('doc/*'))
+
+examfiles   = filter(isfile, glob('doc/examples/*.py'))
+manfiles    = filter(isfile, glob('doc/manual/*.html')) + \
+              filter(isfile, glob('doc/manual/*.css')) + \
+              filter(isfile, glob('doc/manual/*.png'))
+manpages    = filter(isfile, glob('doc/*.1.gz'))
+cfgfiles    = filter(isfile, glob('IPython/UserConfig/*'))
+scriptfiles = filter(isfile, ['scripts/ipython','scripts/pycolor',
+                              'scripts/irunner'])
+igridhelpfiles = filter(isfile, glob('IPython/Extensions/igrid_help.*'))
+
+# Script to be run by the windows binary installer after the default setup
+# routine, to add shortcuts and similar windows-only things.  Windows
+# post-install scripts MUST reside in the scripts/ dir, otherwise distutils
+# doesn't find them.
+if 'bdist_wininst' in sys.argv:
+    if len(sys.argv) > 2 and ('sdist' in sys.argv or 'bdist_rpm' in sys.argv):
+        print >> sys.stderr,"ERROR: bdist_wininst must be run alone. Exiting."
+        sys.exit(1)
+    scriptfiles.append('scripts/ipython_win_post_install.py')
+
+datafiles = [('data', docdirbase, docfiles),
+             ('data', pjoin(docdirbase, 'examples'),examfiles),
+             ('data', pjoin(docdirbase, 'manual'),manfiles),
+             ('data', manpagebase, manpages),
+             ('lib', 'IPython/UserConfig', cfgfiles),
+             ('data',pjoin(docdirbase, 'extensions'),igridhelpfiles),
+             ]
+
+if 'setuptools' in sys.modules:
+    # setuptools config for egg building
+    egg_extra_kwds = {
+        'entry_points': {
+            'console_scripts': [
+            'ipython = IPython.ipapi:launch_new_instance',
+            'pycolor = IPython.PyColorize:main'
+            ]}
+        }
+    scriptfiles = []
+    # eggs will lack docs, eaxmples
+    datafiles = []
+    
+    #datafiles = [('lib', 'IPython/UserConfig', cfgfiles)]
+else:
+    egg_extra_kwds = {}
+
+
+# Call the setup() routine which does most of the work
+setup(name             = name,
+      version          = version,
+      description      = description,
+      long_description = long_description,
+      author           = authors['Fernando'][0],
+      author_email     = authors['Fernando'][1],
+      url              = url,
+      download_url     = download_url,
+      license          = license,
+      platforms        = platforms,
+      keywords         = keywords,
+      packages         = ['IPython', 'IPython.Extensions', 'IPython.external'],
+      scripts          = scriptfiles,
+      
+      cmdclass         = {'install_data': install_data_ext},
+      data_files       = datafiles,
+      # extra params needed for eggs
+      **egg_extra_kwds                        
+      )
diff --git a/setup_bdist_egg.py b/setup_bdist_egg.py
new file mode 100644
index 0000000..6736e39
--- /dev/null
+++ b/setup_bdist_egg.py
@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+"""Wrapper to build IPython as an egg (setuptools format)."""
+
+import os
+import sys
+
+# Add my local path to sys.path
+home = os.environ['HOME']
+sys.path.insert(0,'%s/usr/local/lib/python%s/site-packages' %
+                (home,sys.version[:3]))
+
+# now, import setuptools and build the actual egg
+import setuptools
+
+sys.argv=['','bdist_egg']
+execfile('setup.py')
+
+# clean up the junk left around by setuptools
+os.system('rm -rf ipython.egg-info')
diff --git a/setupext/__init__.py b/setupext/__init__.py
new file mode 100644
index 0000000..98613c1
--- /dev/null
+++ b/setupext/__init__.py
@@ -0,0 +1,3 @@
+# load extended setup modules for distuils
+
+from install_data_ext import install_data_ext
diff --git a/setupext/install_data_ext.py b/setupext/install_data_ext.py
new file mode 100644
index 0000000..a5f5733
--- /dev/null
+++ b/setupext/install_data_ext.py
@@ -0,0 +1,80 @@
+# install_data_ext.py
+#
+# Subclass of normal distutils install_data command to allow more
+# configurable installation of data files.
+
+import os
+from distutils.command.install_data import install_data
+from distutils.util import change_root, convert_path
+
+class install_data_ext(install_data):
+
+    def initialize_options(self):
+        self.install_base = None
+        self.install_platbase = None
+        self.install_purelib = None
+        self.install_headers = None
+        self.install_lib = None
+        self.install_scripts = None
+        self.install_data = None
+
+        self.outfiles = []
+        self.root = None
+        self.force = 0
+        self.data_files = self.distribution.data_files
+        self.warn_dir = 1
+        
+
+    def finalize_options(self):
+        self.set_undefined_options('install',
+                                   ('root', 'root'),
+                                   ('force', 'force'),
+                                   ('install_base', 'install_base'),
+                                   ('install_platbase',
+                                    'install_platbase'),
+                                   ('install_purelib',
+                                    'install_purelib'),
+                                   ('install_headers',
+                                    'install_headers'),
+                                   ('install_lib', 'install_lib'),
+                                   ('install_scripts',
+                                    'install_scripts'),
+                                   ('install_data', 'install_data'))
+                                   
+
+    def run(self):
+        """
+        This is where the meat is.  Basically the data_files list must
+        now be a list of tuples of 3 entries.  The first
+        entry is one of 'base', 'platbase', etc, which indicates which
+        base to install from.  The second entry is the path to install
+        too.  The third entry is a list of files to install.
+        """
+        for lof in self.data_files:
+            if lof[0]:
+                base = getattr(self, 'install_' + lof[0])
+            else:
+                base = getattr(self, 'install_base')
+            dir = convert_path(lof[1])
+            if not os.path.isabs(dir):
+                dir = os.path.join(base, dir)
+            elif self.root:
+                dir = change_root(self.root, dir)
+            self.mkpath(dir)
+
+            files = lof[2]
+            if len(files) == 0:
+                # If there are no files listed, the user must be
+                # trying to create an empty directory, so add the the
+                # directory to the list of output files.
+                self.outfiles.append(dir)
+            else:
+                # Copy files, adding them to the list of output files.
+                for f in files:
+                    f = convert_path(f)
+                    (out, _) = self.copy_file(f, dir)
+                    #print "DEBUG: ", out  # dbg
+                    self.outfiles.append(out)
+                    
+
+        return self.outfiles
diff --git a/test/manualtest_repr_tb.py b/test/manualtest_repr_tb.py
new file mode 100644
index 0000000..93dff69
--- /dev/null
+++ b/test/manualtest_repr_tb.py
@@ -0,0 +1,16 @@
+"""This should be run directly from ipython, and it should NOT crash.
+
+It can't currently be run via runtests b/c exception handling changes there,
+and this is precisely testing exception handling problems."""
+
+ipmagic('xmode verbose')
+
+src = """
+class suck(object):
+    def __repr__(self):
+        raise ValueError("who needs repr anyway")
+
+suck()
+"""
+
+__IPYTHON__.runlines(src)
diff --git a/test/runtests.py b/test/runtests.py
new file mode 100644
index 0000000..36160ab
--- /dev/null
+++ b/test/runtests.py
@@ -0,0 +1,31 @@
+""" Run ipython unit tests
+
+This should be launched from inside ipython by "%run runtests.py"
+or through ipython command line "ipython runtests.py".
+
+"""
+
+from IPython.external.path import path
+import pprint,os
+import IPython.ipapi
+ip = IPython.ipapi.get()
+
+def main():
+    all = path('.').files('test_*py')
+    results = {}
+    res_exc = [None]
+    def exchook(self,*e):
+        res_exc[0] = [e]
+    ip.IP.set_custom_exc((Exception,), exchook)
+    startdir = os.getcwd()
+    for test in all:
+        print test
+        res_exc[0] = 'ok'
+        os.chdir(startdir)
+        ip.runlines(test.text())
+        results[str(test)] = res_exc[0]
+        
+    os.chdir(startdir)
+    pprint.pprint(results)
+        
+main()
diff --git a/test/test_autocall.ipy b/test/test_autocall.ipy
new file mode 100644
index 0000000..2f40785
--- /dev/null
+++ b/test/test_autocall.ipy
@@ -0,0 +1,24 @@
+def f1(a,b,c):
+  return a+b+c
+
+
+def f2(a):
+  return a + a
+  
+
+;f2 a b c
+assert _ == "a b ca b c"
+
+,f1 a b c
+assert _ == 'abc'
+print _
+
+/f1 1,2,3
+assert _ == 6
+
+/f2 4
+assert _ == 8
+
+del f1
+del f2
+
diff --git a/test/test_cd.ipy b/test/test_cd.ipy
new file mode 100644
index 0000000..eee6ace
--- /dev/null
+++ b/test/test_cd.ipy
@@ -0,0 +1,18 @@
+# assumes there is /tmp and /opt
+
+def curpath():
+    cwd = os.path.splitdrive(os.getcwd())[1].replace('\\','/')
+    print cwd
+    return cwd
+
+import os
+cd /
+assert curpath() == '/'
+%cd /tmp
+assert curpath() == '/tmp'
+pushd /opt
+assert curpath() == '/opt'
+popd
+assert curpath() == '/tmp'
+
+
diff --git a/test/test_completer.py b/test/test_completer.py
new file mode 100644
index 0000000..0ba66c3
--- /dev/null
+++ b/test/test_completer.py
@@ -0,0 +1,37 @@
+"""
+comp
+"""
+
+# The prefilter always ends in a call to some self.handle_X method.  We swap
+# all of those out so that we can capture which one was called.
+
+import sys
+sys.path.append('..')
+import IPython
+import IPython.ipapi
+    
+IPython.Shell.start()
+
+ip = IPython.ipapi.get()
+
+completer = ip.IP.Completer
+
+print completer
+
+def do_test(text, line):
+    def get_endix():
+        idx = len(line)
+        print "Call endidx =>",idx        
+        return idx
+    def get_line_buffer():
+        print "Lbuf =>",line
+        return line
+    completer.get_line_buffer = get_line_buffer
+    completer.get_endidx = get_endix
+    l = completer.all_completions(text)
+    return l
+    
+l = do_test ('p', 'print p')
+assert 'pow' in l
+l = do_test ('p', 'import p')
+assert 'pprint' in l
\ No newline at end of file
diff --git a/test/test_embed.py b/test/test_embed.py
new file mode 100644
index 0000000..ef62718
--- /dev/null
+++ b/test/test_embed.py
@@ -0,0 +1,32 @@
+""" An example of one way to embed IPython in your own application 
+
+This basically means starting up IPython with some of your programs objects visible in the IPython 
+user namespace.
+
+"""
+
+import sys
+sys.path.append('..')
+
+import IPython.ipapi
+
+my_ns = dict(a=10)
+
+ses = IPython.ipapi.make_session(my_ns)
+
+# Now get the ipapi instance, to be stored somewhere in your program for manipulation of the running 
+# IPython session. See http://ipython.scipy.org/moin/IpythonExtensionApi
+
+ip = ses.IP.getapi()   
+
+# let's play with the ipapi a bit, creating a magic function for a soon-to-be-started IPython
+def mymagic_f(self,s):
+    print "mymagic says",s
+
+ip.expose_magic("mymagic",mymagic_f)
+
+# And finally, start the IPython interaction! This will block until you say Exit.
+
+ses.mainloop()
+
+print "IPython session finished! namespace content:",my_ns
diff --git a/test/test_handlers.py b/test/test_handlers.py
new file mode 100644
index 0000000..495239b
--- /dev/null
+++ b/test/test_handlers.py
@@ -0,0 +1,202 @@
+"""Test the various handlers which do the actual rewriting of the line."""
+
+from StringIO import StringIO
+import sys
+sys.path.append('..')
+
+failures = []
+num_tests = 0
+
+def run(tests):
+    """Loop through a list of (pre, post) inputs, where pre is the string
+    handed to ipython, and post is how that string looks after it's been
+    transformed (i.e. ipython's notion of _i)"""
+    for pre, post in tests:
+        global num_tests
+        num_tests += 1        
+        ip.runlines(pre)
+        ip.runlines('_i')  # Not sure why I need this...
+        actual = ip.user_ns['_i']
+        if actual != None:
+            actual = actual.rstrip('\n')
+        if actual != post:
+            failures.append('Expected %r to become %r, found %r' % (
+                pre, post, actual))
+
+
+# Shutdown stdout/stderr so that ipython isn't noisy during tests.  Have to
+# do this *before* importing IPython below.
+#
+# NOTE: this means that, if you stick print statements into code as part of
+# debugging, you won't see the results (unless you comment out some of the
+# below).  I keep on doing this, so apparently it's easy.  Or I am an idiot.
+old_stdout = sys.stdout
+old_stderr = sys.stderr
+
+sys.stdout = StringIO()
+sys.stderr = StringIO()
+
+import IPython
+import IPython.ipapi
+
+IPython.Shell.start()
+ip = IPython.ipapi.get()
+
+class CallableIndexable(object):
+    def __getitem__(self, idx): return True
+    def __call__(self, *args, **kws): return True
+
+    
+try:
+    # alias expansion
+    
+    # We're using 'true' as our syscall of choice because it doesn't
+    # write anything to stdout.
+
+    # Turn off actual execution of aliases, because it's noisy
+    old_system_cmd = ip.system
+    ip.system = lambda cmd: None
+    
+    
+    ip.IP.alias_table['an_alias'] = (0, 'true')
+    # These are useful for checking a particular recursive alias issue
+    ip.IP.alias_table['top'] = (0, 'd:/cygwin/top')
+    ip.IP.alias_table['d'] =   (0, 'true')
+    run([("an_alias",    '_ip.system("true ")'),     # alias
+         # Below: recursive aliases should expand whitespace-surrounded
+         # chars, *not* initial chars which happen to be aliases:
+         ("top",         '_ip.system("d:/cygwin/top ")'),
+         ])
+    ip.system = old_system_cmd
+
+
+    call_idx = CallableIndexable()
+    ip.to_user_ns('call_idx')
+
+    # For many of the below, we're also checking that leading whitespace
+    # turns off the esc char, which it should unless there is a continuation
+    # line.
+    run([('"no change"', '"no change"'),             # normal
+         ("!true",       '_ip.system("true")'),      # shell_escapes
+         ("!! true",     '_ip.magic("sx  true")'),   # shell_escapes + magic
+         ("!!true",      '_ip.magic("sx true")'),    # shell_escapes + magic
+         ("%lsmagic",    '_ip.magic("lsmagic ")'),   # magic
+         ("lsmagic",     '_ip.magic("lsmagic ")'),   # magic
+         ("a = b # PYTHON-MODE", '_i'),          # emacs -- avoids _in cache
+
+         # post-esc-char whitespace goes inside
+         ("! true",   '_ip.system(" true")'),  
+
+         # Leading whitespace generally turns off escape characters
+         (" ! true",     ' ! true'),  
+         (" !true",      ' !true'),  
+
+         # handle_help
+
+         # These are weak tests -- just looking at what the help handlers
+         # logs, which is not how it really does its work.  But it still
+         # lets us check the key paths through the handler.
+        
+         ("x=1 # what?", "x=1 # what?"), # no help if valid python
+         ("len?",  "#?len"),             # this is what help logs when it runs
+         ("len??", "#?len?"),                           
+         ("?len",  "#?len"),                            
+         ])
+
+    # multi_line_specials
+    ip.options.multi_line_specials = 0
+    # W/ multi_line_specials off, leading ws kills esc chars/autoexpansion
+    run([
+        ('if 1:\n    !true',    'if 1:\n    !true'),
+        ('if 1:\n    lsmagic',  'if 1:\n    lsmagic'),
+        ('if 1:\n    an_alias', 'if 1:\n    an_alias'),
+        ])
+
+    ip.options.multi_line_specials = 1
+    # initial indents must be preserved.
+    run([
+         ('if 1:\n    !true',    'if 1:\n    _ip.system("true")'),
+         ('if 1:\n    lsmagic',  'if 1:\n    _ip.magic("lsmagic ")'),
+         ('if 1:\n    an_alias', 'if 1:\n    _ip.system("true ")'),
+         # Weird one
+         ('if 1:\n    !!true',   'if 1:\n    _ip.magic("sx true")'),
+         
+
+         # Even with m_l_s on, all esc_chars except ! are off
+         ('if 1:\n    %lsmagic', 'if 1:\n    %lsmagic'),
+         ('if 1:\n    /fun 1 2', 'if 1:\n    /fun 1 2'), 
+         ('if 1:\n    ;fun 1 2', 'if 1:\n    ;fun 1 2'),
+         ('if 1:\n    ,fun 1 2', 'if 1:\n    ,fun 1 2'),
+         ('if 1:\n    ?fun 1 2', 'if 1:\n    ?fun 1 2'),
+         # What about !!  
+         ])
+
+         
+    # Objects which are instances of IPyAutocall are *always* autocalled
+    import IPython.ipapi
+    class Autocallable(IPython.ipapi.IPyAutocall):
+        def __call__(self):
+            return "called"
+    
+    autocallable = Autocallable()
+    ip.to_user_ns('autocallable')
+
+    # auto 
+    ip.options.autocall = 0
+    # Only explicit escapes or instances of IPyAutocallable should get
+    # expanded
+    run([
+        ('len "abc"',       'len "abc"'),        
+        ('autocallable',    'autocallable()'),     
+        (",list 1 2 3",     'list("1", "2", "3")'),
+        (";list 1 2 3",     'list("1 2 3")'),      
+        ("/len range(1,4)", 'len(range(1,4))'),
+        ])
+    ip.options.autocall = 1
+    run([
+        (",list 1 2 3", 'list("1", "2", "3")'),
+        (";list 1 2 3", 'list("1 2 3")'),      
+        ("/len range(1,4)", 'len(range(1,4))'),
+        ('len "abc"', 'len("abc")'),
+        ('len "abc";', 'len("abc");'),  # ; is special -- moves out of parens
+        # Autocall is turned off if first arg is [] and the object
+        # is both callable and indexable.  Like so:
+        ('len [1,2]', 'len([1,2])'),      # len doesn't support __getitem__...
+        ('call_idx [1]', 'call_idx [1]'), # call_idx *does*..
+        ('call_idx 1', 'call_idx(1)'),
+        ('len', 'len '), # only at 2 does it auto-call on single args
+        ])
+
+    ip.options.autocall = 2
+    run([
+        (",list 1 2 3", 'list("1", "2", "3")'),
+        (";list 1 2 3", 'list("1 2 3")'),      
+        ("/len range(1,4)", 'len(range(1,4))'),
+        ('len "abc"', 'len("abc")'),
+        ('len "abc";', 'len("abc");'),
+        ('len [1,2]', 'len([1,2])'),   
+        ('call_idx [1]', 'call_idx [1]'),
+        ('call_idx 1', 'call_idx(1)'),
+        # This is what's different:
+        ('len', 'len()'), # only at 2 does it auto-call on single args
+        ])
+    ip.options.autocall = 1
+
+    # Ignoring handle_emacs, 'cause it doesn't do anything.
+finally:
+    sys.stdout = old_stdout
+    sys.stderr = old_stderr
+
+
+
+
+num_f = len(failures)
+#if verbose:
+#    print
+
+
+print "%s tests run, %s failure%s" % (num_tests,
+                                      num_f,
+                                      num_f != 1 and "s" or "")
+for f in failures:
+    print f
diff --git a/test/test_ihist.ipy b/test/test_ihist.ipy
new file mode 100644
index 0000000..6f9bce6
--- /dev/null
+++ b/test/test_ihist.ipy
@@ -0,0 +1,2 @@
+1+2
+assert _ == 3
diff --git a/test/test_ipapi.py b/test/test_ipapi.py
new file mode 100644
index 0000000..8bd3561
--- /dev/null
+++ b/test/test_ipapi.py
@@ -0,0 +1,54 @@
+import sys
+sys.path.append('..')
+
+import IPython.ipapi
+IPython.ipapi.make_session()
+ip = IPython.ipapi.get()
+
+def test_runlines():
+    import textwrap
+    ip.runlines(['a = 10', 'a+=1'])
+    ip.runlines('assert a == 11\nassert 1')
+
+    assert ip.user_ns['a'] == 11
+    complex = textwrap.dedent("""\
+    if 1:
+        print "hello"
+        if 1:
+            print "world"
+        
+    if 1:
+        print "foo"
+    if 1:
+        print "bar"
+
+    if 1:
+        print "bar"
+    
+    """)
+
+    
+    ip.runlines(complex)
+    
+
+def test_db():
+    ip.db['__unittest_'] = 12
+    assert ip.db['__unittest_'] == 12
+    del ip.db['__unittest_']
+    assert '__unittest_' not in ip.db
+
+def test_defalias():
+    slot = [None]
+    # test callable alias
+    def cb(localip,s):
+        assert localip is ip
+        slot[0] = s
+    
+    ip.defalias('testalias', cb)
+    ip.runlines('testalias foo bar')
+    assert slot[0] == 'testalias foo bar'
+        
+
+test_runlines()
+test_db()
+test_defalias
diff --git a/test/test_irunner.py b/test/test_irunner.py
new file mode 100644
index 0000000..e5f4ca1
--- /dev/null
+++ b/test/test_irunner.py
@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+"""Test suite for the irunner module.
+
+Not the most elegant or fine-grained, but it does cover at least the bulk
+functionality."""
+
+# Global to make tests extra verbose and help debugging
+VERBOSE = True
+
+# stdlib imports
+import cStringIO as StringIO
+import sys
+import unittest
+
+# IPython imports
+from IPython import irunner
+
+# Testing code begins
+class RunnerTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.out = StringIO.StringIO()
+        #self.out = sys.stdout
+
+    def _test_runner(self,runner,source,output):
+        """Test that a given runner's input/output match."""
+        
+        runner.run_source(source)
+        out = self.out.getvalue()
+        #out = ''
+        # this output contains nasty \r\n lineends, and the initial ipython
+        # banner.  clean it up for comparison
+        output_l = output.split()
+        out_l = out.split()
+        mismatch  = 0
+        #if len(output_l) != len(out_l):
+        #    self.fail('mismatch in number of lines')
+        for n in range(len(output_l)):
+            # Do a line-by-line comparison
+            ol1 = output_l[n].strip()
+            ol2 = out_l[n].strip()
+            if ol1 != ol2:
+                mismatch += 1
+                if VERBOSE:
+                    print '<<< line %s does not match:' % n
+                    print repr(ol1)
+                    print repr(ol2)
+                    print '>>>'
+        self.assert_(mismatch==0,'Number of mismatched lines: %s' %
+                     mismatch)
+
+    def testIPython(self):
+        """Test the IPython runner."""
+        source = """
+print 'hello, this is python'
+
+# some more code
+x=1;y=2
+x+y**2
+
+# An example of autocall functionality
+from math import *
+autocall 1
+cos pi
+autocall 0
+cos pi
+cos(pi)
+
+for i in range(5):
+    print i,
+
+print "that's all folks!"
+
+%Exit
+"""
+        output = """\
+In [1]: print 'hello, this is python'
+hello, this is python
+
+
+# some more code
+In [2]: x=1;y=2
+
+In [3]: x+y**2
+Out[3]: 5
+
+
+# An example of autocall functionality
+In [4]: from math import *
+
+In [5]: autocall 1
+Automatic calling is: Smart
+
+In [6]: cos pi
+------> cos(pi)
+Out[6]: -1.0
+
+In [7]: autocall 0
+Automatic calling is: OFF
+
+In [8]: cos pi
+------------------------------------------------------------
+   File "<ipython console>", line 1
+     cos pi
+          ^
+<type 'exceptions.SyntaxError'>: invalid syntax
+
+
+In [9]: cos(pi)
+Out[9]: -1.0
+
+
+In [10]: for i in range(5):
+   ....:     print i,
+   ....:
+0 1 2 3 4
+
+In [11]: print "that's all folks!"
+that's all folks!
+
+
+In [12]: %Exit
+"""
+        runner = irunner.IPythonRunner(out=self.out)
+        self._test_runner(runner,source,output)
+
+    def testPython(self):
+        """Test the Python runner."""
+        runner = irunner.PythonRunner(out=self.out)
+        source = """
+print 'hello, this is python'
+
+# some more code
+x=1;y=2
+x+y**2
+
+from math import *
+cos(pi)
+
+for i in range(5):
+    print i,
+
+print "that's all folks!"
+        """
+        output = """\
+>>> print 'hello, this is python'
+hello, this is python
+
+# some more code
+>>> x=1;y=2
+>>> x+y**2
+5
+
+>>> from math import *
+>>> cos(pi)
+-1.0
+
+>>> for i in range(5):
+...     print i,
+...
+0 1 2 3 4
+>>> print "that's all folks!"
+that's all folks!
+"""
+        self._test_runner(runner,source,output)
+        
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_prefilter.py b/test/test_prefilter.py
new file mode 100644
index 0000000..53fffca
--- /dev/null
+++ b/test/test_prefilter.py
@@ -0,0 +1,440 @@
+"""
+Test which prefilter transformations get called for various input lines.
+Note that this does *not* test the transformations themselves -- it's just
+verifying that a particular combination of, e.g. config options and escape
+chars trigger the proper handle_X transform of the input line.
+
+Usage: run from the command line with *normal* python, not ipython:
+> python test_prefilter.py
+
+Fairly quiet output by default.  Pass in -v to get everyone's favorite dots.
+"""
+
+# The prefilter always ends in a call to some self.handle_X method.  We swap
+# all of those out so that we can capture which one was called.
+
+import sys
+sys.path.append('..')
+import IPython
+import IPython.ipapi
+
+verbose = False
+if len(sys.argv) > 1:
+    if sys.argv[1] == '-v':
+        sys.argv = sys.argv[:-1]  # IPython is confused by -v, apparently
+        verbose = True
+    
+IPython.Shell.start()
+
+ip = IPython.ipapi.get()
+
+# Collect failed tests + stats and print them at the end
+failures = []
+num_tests = 0
+
+# Store the results in module vars as we go
+last_line      = None
+handler_called = None
+def install_mock_handler(name):
+    """Swap out one of the IP.handle_x methods with a function which can
+    record which handler was called and what line was produced. The mock
+    handler func always returns '', which causes ipython to cease handling
+    the string immediately.  That way, that it doesn't echo output, raise
+    exceptions, etc.  But do note that testing multiline strings thus gets
+    a bit hard."""    
+    def mock_handler(self, line, continue_prompt=None,
+                     pre=None,iFun=None,theRest=None,
+                     obj=None):
+        #print "Inside %s with '%s'" % (name, line)
+        global last_line, handler_called
+        last_line = line
+        handler_called = name
+        return ''
+    mock_handler.name = name
+    setattr(IPython.iplib.InteractiveShell, name, mock_handler)
+
+install_mock_handler('handle_normal')
+install_mock_handler('handle_auto')
+install_mock_handler('handle_magic')
+install_mock_handler('handle_help')
+install_mock_handler('handle_shell_escape')
+install_mock_handler('handle_alias')
+install_mock_handler('handle_emacs')
+
+
+def reset_esc_handlers():
+    """The escape handlers are stored in a hash (as an attribute of the
+    InteractiveShell *instance*), so we have to rebuild that hash to get our
+    new handlers in there."""
+    s = ip.IP
+    s.esc_handlers = {s.ESC_PAREN  : s.handle_auto,
+                      s.ESC_QUOTE  : s.handle_auto,
+                      s.ESC_QUOTE2 : s.handle_auto,
+                      s.ESC_MAGIC  : s.handle_magic,
+                      s.ESC_HELP   : s.handle_help,
+                      s.ESC_SHELL  : s.handle_shell_escape,
+                      s.ESC_SH_CAP : s.handle_shell_escape,
+                      }
+reset_esc_handlers()
+    
+# This is so I don't have to quote over and over.  Gotta be a better way.
+handle_normal       = 'handle_normal'
+handle_auto         = 'handle_auto'
+handle_magic        = 'handle_magic'
+handle_help         = 'handle_help'
+handle_shell_escape = 'handle_shell_escape'
+handle_alias        = 'handle_alias'
+handle_emacs        = 'handle_emacs'
+
+def check(assertion, failure_msg):
+    """Check a boolean assertion and fail with a message if necessary. Store
+    an error essage in module-level failures list in case of failure.  Print
+    '.' or 'F' if module var Verbose is true.
+    """
+    global num_tests
+    num_tests += 1
+    if assertion:
+        if verbose:
+            sys.stdout.write('.')
+            sys.stdout.flush()        
+    else:
+        if verbose:
+            sys.stdout.write('F')
+            sys.stdout.flush()
+        failures.append(failure_msg)
+    
+
+def check_handler(expected_handler, line):
+    """Verify that the expected hander was called (for the given line,
+    passed in for failure reporting).
+    
+    Pulled out to its own function so that tests which don't use
+    run_handler_tests can still take advantage of it."""
+    check(handler_called == expected_handler,
+          "Expected %s to be called for %s, "
+          "instead %s called" % (expected_handler,
+                                 repr(line),
+                                 handler_called))
+    
+
+def run_handler_tests(h_tests):
+    """Loop through a series of (input_line, handler_name) pairs, verifying
+    that, for each ip calls the given handler for the given line. 
+
+    The verbose complaint includes the line passed in, so if that line can
+    include enough info to find the error, the tests are modestly
+    self-documenting.
+    """    
+    for ln, expected_handler in h_tests:
+        global handler_called
+        handler_called = None
+        ip.runlines(ln)
+        check_handler(expected_handler, ln)
+
+def run_one_test(ln, expected_handler):
+    run_handler_tests([(ln, expected_handler)])
+    
+
+# =========================================
+# Tests
+# =========================================
+
+
+# Fundamental escape characters + whitespace & misc
+# =================================================
+esc_handler_tests = [
+    ( '?thing',    handle_help,  ),
+    ( 'thing?',    handle_help ),  # '?' can trail...
+    ( 'thing!',    handle_normal), # but only '?' can trail
+    ( '   ?thing', handle_normal), # leading whitespace turns off esc chars
+    ( '!ls',       handle_shell_escape),
+    ( '! true',    handle_shell_escape),
+    ( '!! true',   handle_shell_escape),
+    ( '%magic',    handle_magic),
+    # XXX Possibly, add test for /,; once those are unhooked from %autocall
+    ( 'emacs_mode # PYTHON-MODE', handle_emacs ),
+    ( ' ',         handle_normal), 
+
+    # Trailing qmark combos.  Odd special cases abound
+
+    # ! always takes priority!
+    ( '!thing?',      handle_shell_escape), 
+    ( '!thing arg?',  handle_shell_escape),
+    ( '!!thing?',     handle_shell_escape),
+    ( '!!thing arg?', handle_shell_escape),
+    ( '    !!thing arg?', handle_shell_escape),
+
+    # For all other leading esc chars, we always trigger help
+    ( '%cmd?',     handle_help),
+    ( '%cmd ?',    handle_help),
+    ( '/cmd?',     handle_help),
+    ( '/cmd ?',    handle_help),
+    ( ';cmd?',     handle_help),
+    ( ',cmd?',     handle_help),
+    ]
+run_handler_tests(esc_handler_tests)
+
+
+
+# Shell Escapes in Multi-line statements
+# ======================================
+#
+# We can't test this via runlines, since the hacked-over-for-testing
+# handlers all return None, so continue_prompt never becomes true.  Instead
+# we drop into prefilter directly and pass in continue_prompt.
+
+old_mls = ip.options.multi_line_specials
+for ln in [ '    !ls $f multi_line_specials %s',
+            '    !!ls $f multi_line_specials %s',  # !! escapes work on mls
+            # Trailing ? doesn't trigger help:            
+            '    !ls $f multi_line_specials %s ?', 
+            '    !!ls $f multi_line_specials %s ?',
+            ]:
+    ip.options.multi_line_specials = 1
+    on_ln = ln % 'on'
+    ignore = ip.IP.prefilter(on_ln, continue_prompt=True)
+    check_handler(handle_shell_escape, on_ln)
+
+    ip.options.multi_line_specials = 0
+    off_ln = ln % 'off'
+    ignore = ip.IP.prefilter(off_ln, continue_prompt=True)
+    check_handler(handle_normal, off_ln)
+
+ip.options.multi_line_specials = old_mls
+
+
+# Automagic
+# =========
+
+# Pick one magic fun and one non_magic fun, make sure both exist
+assert hasattr(ip.IP, "magic_cpaste")
+assert not hasattr(ip.IP, "magic_does_not_exist")
+ip.options.autocall = 0 # gotta have this off to get handle_normal
+ip.options.automagic = 0
+run_handler_tests([
+    # Without automagic, only shows up with explicit escape
+    ( 'cpaste', handle_normal),
+    ( '%cpaste', handle_magic),
+    ( '%does_not_exist', handle_magic),
+    ])
+ip.options.automagic = 1
+run_handler_tests([
+    ( 'cpaste',          handle_magic),
+    ( '%cpaste',         handle_magic),
+    ( 'does_not_exist',  handle_normal),
+    ( '%does_not_exist', handle_magic),
+    ( 'cd /',            handle_magic),
+    ( 'cd = 2',          handle_normal),
+    ( 'r',               handle_magic),
+    ( 'r thing',         handle_magic),
+    ( 'r"str"',          handle_normal),
+    ])
+
+# If next elt starts with anything that could be an assignment, func call,
+# etc, we don't call the magic func, unless explicitly escaped to do so.
+#magic_killing_tests = []
+#for c in list('!=()<>,'):
+#    magic_killing_tests.append(('cpaste %s killed_automagic' % c, handle_normal))
+#    magic_killing_tests.append(('%%cpaste %s escaped_magic' % c,   handle_magic))
+#run_handler_tests(magic_killing_tests)
+
+# magic on indented continuation lines -- on iff multi_line_specials == 1
+ip.options.multi_line_specials = 0
+ln = '    cpaste multi_line off kills magic'
+ignore = ip.IP.prefilter(ln, continue_prompt=True)
+check_handler(handle_normal, ln)
+
+ip.options.multi_line_specials = 1
+ln = '    cpaste multi_line on enables magic'
+ignore = ip.IP.prefilter(ln, continue_prompt=True)
+check_handler(handle_magic, ln)
+
+# user namespace shadows the magic one unless shell escaped
+ip.user_ns['cpaste']     = 'user_ns'
+run_handler_tests([
+    ( 'cpaste',    handle_normal),
+    ( '%cpaste',   handle_magic)])
+del ip.user_ns['cpaste']
+
+
+
+# Check for !=() turning off .ofind
+# =================================
+class AttributeMutator(object):
+    """A class which will be modified on attribute access, to test ofind"""
+    def __init__(self):
+        self.called = False
+
+    def getFoo(self): self.called = True
+    foo = property(getFoo)
+
+attr_mutator = AttributeMutator()
+ip.to_user_ns('attr_mutator')
+
+ip.options.autocall = 1 
+
+run_one_test('attr_mutator.foo should mutate', handle_normal)
+check(attr_mutator.called, 'ofind should be called in absence of assign characters')
+
+for c in list('!=()<>+*/%^&|'): 
+    attr_mutator.called = False
+    run_one_test('attr_mutator.foo %s should *not* mutate' % c, handle_normal)
+    run_one_test('attr_mutator.foo%s should *not* mutate' % c, handle_normal)
+    
+    check(not attr_mutator.called,
+          'ofind should not be called near character %s' % c)
+
+
+
+# Alias expansion
+# ===============
+
+# With autocall on or off, aliases should be shadowed by user, internal and
+# __builtin__ namespaces
+#
+# XXX Can aliases have '.' in their name?  With autocall off, that works,
+# with autocall on, it doesn't.  Hmmm.
+import __builtin__
+for ac_state in [0,1]:
+    ip.options.autocall = ac_state
+    ip.IP.alias_table['alias_cmd'] = 'alias_result'
+    ip.IP.alias_table['alias_head.with_dot'] = 'alias_result'
+    run_handler_tests([
+        ("alias_cmd",           handle_alias),
+        # XXX See note above
+        #("alias_head.with_dot unshadowed, autocall=%s" % ac_state, handle_alias), 
+        ("alias_cmd.something aliases must match whole expr", handle_normal),
+        ("alias_cmd /", handle_alias),
+        ])
+
+    for ns in [ip.user_ns, ip.IP.internal_ns, __builtin__.__dict__ ]:
+        ns['alias_cmd'] = 'a user value'
+        ns['alias_head'] = 'a user value'
+        run_handler_tests([
+            ("alias_cmd",           handle_normal),
+            ("alias_head.with_dot", handle_normal)])
+        del ns['alias_cmd']
+        del ns['alias_head']
+
+ip.options.autocall = 1
+
+
+
+
+# Autocall
+# ========
+
+# For all the tests below, 'len' is callable / 'thing' is not
+
+# Objects which are instances of IPyAutocall are *always* autocalled
+import IPython.ipapi
+class Autocallable(IPython.ipapi.IPyAutocall):
+    def __call__(self):
+        return "called"
+    
+autocallable = Autocallable()
+ip.to_user_ns('autocallable')
+
+
+# First, with autocalling fully off
+ip.options.autocall = 0
+run_handler_tests( [
+    # With no escapes, no autocalling expansions happen, callable or not,
+    # unless the obj extends IPyAutocall
+    ( 'len autocall_0',     handle_normal),
+    ( 'thing autocall_0',   handle_normal),
+    ( 'autocallable',       handle_auto),
+    
+    # With explicit escapes, callable and non-callables both get expanded,
+    # regardless of the %autocall setting:
+    ( '/len autocall_0',    handle_auto),
+    ( ',len autocall_0 b0', handle_auto),
+    ( ';len autocall_0 b0', handle_auto),
+    
+    ( '/thing autocall_0',    handle_auto),
+    ( ',thing autocall_0 b0', handle_auto),
+    ( ';thing autocall_0 b0', handle_auto),
+
+    # Explicit autocall should not trigger if there is leading whitespace
+    ( ' /len autocall_0',    handle_normal),
+    ( ' ;len autocall_0',    handle_normal),
+    ( ' ,len autocall_0',    handle_normal),
+    ( ' / len autocall_0',   handle_normal),
+
+    # But should work if the whitespace comes after the esc char
+    ( '/ len autocall_0',    handle_auto),
+    ( '; len autocall_0',    handle_auto),
+    ( ', len autocall_0',    handle_auto),
+    ( '/  len autocall_0',   handle_auto),
+    ])
+
+
+# Now, with autocall in default, 'smart' mode
+ip.options.autocall = 1 
+run_handler_tests( [
+    # Autocalls without escapes -- only expand if it's callable
+    ( 'len a1',       handle_auto),
+    ( 'thing a1',     handle_normal),
+    ( 'autocallable', handle_auto),
+
+    # As above, all explicit escapes generate auto-calls, callable or not
+    ( '/len a1',      handle_auto),
+    ( ',len a1 b1',   handle_auto),
+    ( ';len a1 b1',   handle_auto),
+    ( '/thing a1',    handle_auto),
+    ( ',thing a1 b1', handle_auto),
+    ( ';thing a1 b1', handle_auto),
+
+    # Autocalls only happen on things which look like funcs, even if
+    # explicitly requested. Which, in this case means they look like a
+    # sequence of identifiers and . attribute references. Possibly the
+    # second of these two should trigger handle_auto.  But not for now.
+    ( '"abc".join range(4)',   handle_normal),
+    ( '/"abc".join range(4)',  handle_normal),
+    ])
+
+
+# No tests for autocall = 2, since the extra magic there happens inside the
+# handle_auto function, which our test doesn't examine.
+
+# Note that we leave autocall in default, 1, 'smart' mode
+
+
+# Autocall / Binary operators
+# ==========================
+
+# Even with autocall on, 'len in thing' won't transform.
+# But ';len in thing' will
+
+# Note, the tests below don't check for multi-char ops. It could.
+
+# XXX % is a binary op and should be in the list, too, but fails
+bin_ops = list(r'<>,&^|*/+-') + 'is not in and or'.split()
+bin_tests = []
+for b in bin_ops:
+    bin_tests.append(('len %s binop_autocall'  % b, handle_normal))
+    bin_tests.append((';len %s binop_autocall' % b, handle_auto))
+    bin_tests.append((',len %s binop_autocall' % b, handle_auto))
+    bin_tests.append(('/len %s binop_autocall' % b, handle_auto))
+    
+# Who loves auto-generating tests? 
+run_handler_tests(bin_tests)
+
+
+# Possibly add tests for namespace shadowing (really ofind's business?).
+#
+# user > ipython internal > python builtin > alias > magic
+
+
+# ============
+# Test Summary
+# ============
+num_f = len(failures)
+if verbose:
+    print 
+print "%s tests run, %s failure%s" % (num_tests,
+                                      num_f,
+                                      num_f != 1 and "s" or "")
+for f in failures:
+    print f
+
diff --git a/test/test_shell_options.py b/test/test_shell_options.py
new file mode 100644
index 0000000..fd00112
--- /dev/null
+++ b/test/test_shell_options.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+"""A few unit tests for the Shell module.
+"""
+
+from unittest import TestCase, main
+
+from IPython import Shell
+
+try:
+    import matplotlib
+    has_matplotlib = True
+except ImportError:
+    has_matplotlib = False
+
+class ShellTestBase(TestCase):
+    def _test(self,argv,ans):
+        shell = Shell._select_shell(argv)
+        err = 'Got %s != %s' % (shell,ans)
+        self.failUnlessEqual(shell,ans,err)
+
+class ArgsTestCase(ShellTestBase):
+    def test_plain(self):
+        self._test([],Shell.IPShell)
+
+    def test_tkthread(self):
+        self._test(['-tkthread'],Shell.IPShell)
+
+    def test_gthread(self):
+        self._test(['-gthread'],Shell.IPShellGTK)
+
+    def test_qthread(self):
+        self._test(['-qthread'],Shell.IPShellQt)
+
+    def test_q4thread(self):
+        self._test(['-q4thread'],Shell.IPShellQt4)
+
+    def test_wthread(self):
+        self._test(['-wthread'],Shell.IPShellWX)
+
+if has_matplotlib:
+    class MplArgsTestCase(ShellTestBase):
+        def setUp(self):
+            self.backend = matplotlib.rcParams['backend']
+
+        def tearDown(self):
+            matplotlib.rcParams['backend'] = self.backend
+
+        def _test(self,argv,ans):
+            shell = Shell._select_shell(argv)
+            err = 'Got %s != %s' % (shell,ans)
+            self.failUnlessEqual(shell,ans,err)
+
+        def test_tk(self):
+            matplotlib.rcParams['backend'] = 'TkAgg'
+            self._test(['-pylab'],Shell.IPShellMatplotlib)
+
+        def test_ps(self):
+            matplotlib.rcParams['backend'] = 'PS'
+            self._test(['-pylab'],Shell.IPShellMatplotlib)
+
+        def test_gtk(self):
+            matplotlib.rcParams['backend'] = 'GTKAgg'
+            self._test(['-pylab'],Shell.IPShellMatplotlibGTK)
+
+        def test_gtk_2(self):
+            self._test(['-gthread','-pylab'],Shell.IPShellMatplotlibGTK)
+            self.failUnlessEqual(matplotlib.rcParams['backend'],'GTKAgg')
+            
+        def test_qt(self):
+            matplotlib.rcParams['backend'] = 'QtAgg'
+            self._test(['-pylab'],Shell.IPShellMatplotlibQt)
+            
+        def test_qt_2(self):
+            self._test(['-qthread','-pylab'],Shell.IPShellMatplotlibQt)
+            self.failUnlessEqual(matplotlib.rcParams['backend'],'QtAgg')
+            
+        def test_qt4(self):
+            matplotlib.rcParams['backend'] = 'Qt4Agg'
+            self._test(['-pylab'],Shell.IPShellMatplotlibQt4)
+
+        def test_qt4_2(self):
+            self._test(['-q4thread','-pylab'],Shell.IPShellMatplotlibQt4)
+            self.failUnlessEqual(matplotlib.rcParams['backend'],'Qt4Agg')
+            
+        def test_wx(self):
+            matplotlib.rcParams['backend'] = 'WxAgg'
+            self._test(['-pylab'],Shell.IPShellMatplotlibWX)
+            
+        def test_wx_2(self):
+            self._test(['-pylab','-wthread'],Shell.IPShellMatplotlibWX)
+            self.failUnlessEqual(matplotlib.rcParams['backend'],'WXAgg')
+            
+
+main()
diff --git a/test/test_shouldfail.ipy b/test/test_shouldfail.ipy
new file mode 100644
index 0000000..128f229
--- /dev/null
+++ b/test/test_shouldfail.ipy
@@ -0,0 +1,3 @@
+# this will fail w/ assertionerror
+cd /
+assert os.getcwd() == '/does/not/exist'
diff --git a/test/test_wildcard.py b/test/test_wildcard.py
new file mode 100644
index 0000000..1e0ee6c
--- /dev/null
+++ b/test/test_wildcard.py
@@ -0,0 +1,100 @@
+# -*- coding: UTF-8 -*-
+import sys, unittest
+sys.path.append ('..')
+
+from IPython import wildcard
+
+class obj_t(object):
+    pass
+
+root=obj_t()
+l=["arna","abel","ABEL","active","bob","bark","abbot"]
+q=["kate","loop","arne","vito","lucifer","koppel"]
+for x in l:
+    o=obj_t()
+    setattr(root,x,o)
+    for y in q:
+        p=obj_t()
+        setattr(o,y,p)
+root._apan=obj_t()
+root._apan.a=10
+root._apan._a=20
+root._apan.__a=20
+root.__anka=obj_t()
+root.__anka.a=10
+root.__anka._a=20
+root.__anka.__a=20
+
+root._APAN=obj_t()
+root._APAN.a=10
+root._APAN._a=20
+root._APAN.__a=20
+root.__ANKA=obj_t()
+root.__ANKA.a=10
+root.__ANKA._a=20
+root.__ANKA.__a=20
+
+class Tests (unittest.TestCase):
+    def test_case(self):
+        ns=root.__dict__
+        tests=[
+         ("a*",     ["abbot","abel","active","arna",]),
+         ("?b*.?o*",["abbot.koppel","abbot.loop","abel.koppel","abel.loop",]),
+         ("_a*",    []),
+         ("_*anka", ["__anka",]),
+         ("_*a*",   ["__anka",]),
+        ]
+        for pat,res in tests:
+            res.sort()
+            a=wildcard.list_namespace(ns,"all",pat,ignore_case=False,show_all=False).keys()
+            a.sort()
+            self.assertEqual(a,res)
+
+    def test_case_showall(self):
+        ns=root.__dict__
+        tests=[
+         ("a*",     ["abbot","abel","active","arna",]),
+         ("?b*.?o*",["abbot.koppel","abbot.loop","abel.koppel","abel.loop",]),
+         ("_a*",    ["_apan"]),
+         ("_*anka", ["__anka",]),
+         ("_*a*",   ["__anka","_apan",]),
+        ]
+        for pat,res in tests:
+            res.sort()
+            a=wildcard.list_namespace(ns,"all",pat,ignore_case=False,show_all=True).keys()
+            a.sort()
+            self.assertEqual(a,res)
+
+
+    def test_nocase(self):
+        ns=root.__dict__
+        tests=[
+         ("a*",     ["abbot","abel","ABEL","active","arna",]),
+         ("?b*.?o*",["abbot.koppel","abbot.loop","abel.koppel","abel.loop","ABEL.koppel","ABEL.loop",]),
+         ("_a*",    []),
+         ("_*anka", ["__anka","__ANKA",]),
+         ("_*a*",   ["__anka","__ANKA",]),
+        ]
+        for pat,res in tests:
+            res.sort()
+            a=wildcard.list_namespace(ns,"all",pat,ignore_case=True,show_all=False).keys()
+            a.sort()
+            self.assertEqual(a,res)
+
+    def test_nocase_showall(self):
+        ns=root.__dict__
+        tests=[
+         ("a*",     ["abbot","abel","ABEL","active","arna",]),
+         ("?b*.?o*",["abbot.koppel","abbot.loop","abel.koppel","abel.loop","ABEL.koppel","ABEL.loop",]),
+         ("_a*",    ["_apan","_APAN"]),
+         ("_*anka", ["__anka","__ANKA",]),
+         ("_*a*",   ["__anka","__ANKA","_apan","_APAN"]),
+        ]
+        for pat,res in tests:
+            res.sort()
+            a=wildcard.list_namespace(ns,"all",pat,ignore_case=True,show_all=True).keys()
+            a.sort()
+            self.assertEqual(a,res)
+            
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/tools/bkp.py b/tools/bkp.py
new file mode 100644
index 0000000..71b0e27
--- /dev/null
+++ b/tools/bkp.py
@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+"""Backup directories using rsync. Quick and dirty.
+
+backup.py config_file final_actions
+"""
+
+#----------------------------------------------------------------------------
+# configure in this section
+
+# all dirs relative to current dir.
+
+# output directory for backups
+outdir = ''
+
+# list directories to backup as a dict with 1 or 0 values for
+# recursive (or not) descent:
+to_backup = {}
+
+# list exclude patterns here (space-separated):
+# if the pattern ends with a / then it will only match a directory, not a
+# file, link or device.
+# see man rsync for more details on the exclude patterns
+exc_pats = '#*#  *~  *.pyc *.pyo *.o '
+
+# global options for rsync
+rsync_opts='-v -t -a --delete --delete-excluded'
+
+#----------------------------------------------------------------------------
+# real code begins
+import os,string,re,sys
+from IPython.genutils import *
+from IPython.Itpl import itpl
+
+# config file can redefine final actions
+def final():
+    pass
+
+# load config from cmd line config file or default bkprc.py
+try:
+    execfile(sys.argv[1])
+except:
+    try:
+        execfile('bkprc.py')
+    except IOError:
+        print 'You need to provide a config file: bkp.py rcfile'
+        sys.exit()
+
+# make output dir if needed
+outdir = os.path.expanduser(outdir)
+try:
+    os.makedirs(outdir)
+except OSError:  # raised if dir already exists -> no need to make it
+    pass
+
+# build rsync command and call:
+exclude = re.sub(r'([^\s].*?)(\s|$)',r'--exclude "\1"\2',exc_pats)
+rsync = itpl('rsync $rsync_opts $exclude')
+
+# the same can also be done with lists (keep it for reference):
+#exclude = string.join(['--exclude "'+p+'"' for p in qw(exc_pats)])
+
+# rsync takes -r as a flag, not 0/1 so translate:
+rec_flag = {0:'',1:'-r'}
+
+# loop over user specified directories calling rsync
+for bakdir,rec in to_backup.items():
+    bakdir = os.path.expanduser(bakdir)
+    xsys(itpl('$rsync $rec_flag[rec] $bakdir $outdir'),
+         debug=0,verbose=1,header='\n### ')
+
+# final actions?
+final()
diff --git a/tools/bkp.sh b/tools/bkp.sh
new file mode 100644
index 0000000..5954e34
--- /dev/null
+++ b/tools/bkp.sh
@@ -0,0 +1,22 @@
+#!/bin/sh
+
+# Simple backup script for ipython, to keep around a static copy of the whole
+# project at the current version point.  We do this by exporting from SVN.
+
+# Config here
+IPYTHONSVN=$HOME/ipython/svn/ipython/trunk
+BACKUPDIR=$HOME/ipython/backup
+
+####
+# Code begins
+IPVERSION=`ipython -Version`
+IPX=ipython-$IPVERSION
+ARCHIVE=$BACKUPDIR/$IPX.tgz
+
+svn export $IPYTHONSVN $IPX
+
+tar czf $ARCHIVE $IPX
+
+rm -rf $IPX
+
+echo "Backup left in: $ARCHIVE"
diff --git a/tools/bkprc.py b/tools/bkprc.py
new file mode 100644
index 0000000..81e04f0
--- /dev/null
+++ b/tools/bkprc.py
@@ -0,0 +1,22 @@
+# config file for a quick'n dirty backup script that uses rsync
+
+# output directory for backups
+outdir = '~/tmp'
+
+# list directories to backup as a dict with 1 or 0 values for
+# recursive (or not) descent:
+to_backup = {'~/ipython/ipython':1}
+
+# exclude patterns. anything ending in / is considered a directory
+exc_pats = '#*#  *~ *.o *.pyc *.pyo MANIFEST *.pdf *.flc build/ dist/ ' \
+' doc/manual/ doc/manual.lyx ChangeLog.* magic.tex *.1.gz '
+
+# final actions after doing the backup
+def final():
+    dbg = 0
+    version = bq('ipython -V')
+    out_tgz = outdir+'/ipython-'+version+'.tgz'
+    xsys(itpl('cd $outdir; pwd;tar -czf $out_tgz ipython'),debug=dbg,verbose=1)
+    #xsys(itpl('cp $out_tgz /mnt/card/fperez/ipython'),debug=dbg,verbose=1)
+    xsys(itpl('mv $out_tgz ~/ipython/backup'),debug=dbg,verbose=1)
+    xsys(itpl('rm -rf ${outdir}/ipython'),debug=dbg,verbose=1)
diff --git a/tools/check_sources.py b/tools/check_sources.py
new file mode 100644
index 0000000..2b21cae
--- /dev/null
+++ b/tools/check_sources.py
@@ -0,0 +1,15 @@
+from IPython.external.path import path
+fs = path('..').walkfiles('*.py')
+
+for f in fs:
+    errs = ''
+    cont = f.bytes()
+    if '\t' in cont:
+        errs+='t'
+
+    if '\r' in cont:
+        errs+='r'
+        
+    if errs:
+        print "%3s" % errs, f
+    
\ No newline at end of file
diff --git a/tools/ipsvnc b/tools/ipsvnc
new file mode 100644
index 0000000..77d8014
--- /dev/null
+++ b/tools/ipsvnc
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+"""Simple svn commit wrapper which emails a given list of people.
+
+Usage:
+
+  ipsvnc [args]
+
+This is equivalent to doing
+
+  svn commit [args]
+
+If the commit operation is successful (the script asks for confirmation), a
+hardwired list of maintainers is informed of the commit.
+
+This is a poor-man's substitute for a proper svn post-commit hook with an
+ipython-svn email list, which we're waiting to get soon.  It should be removed
+once that facility is in place.
+
+This only works on a unix box which can send mail by itself."""
+
+import os
+import commands
+import sys
+import time
+
+# Package maintainers to be alerted
+maintainers = ['fperez@colorado.edu', 'rkern@ucsd.edu', 'antont@an.org',
+               'tsanko@gmail.com']
+
+#maintainers = ['fperez@colorado.edu']  # dbg
+
+# Assemble command line back, before passing it to svn
+svnargs = []
+for arg in sys.argv[1:]:
+    if ' ' in arg:
+        svnargs.append('"%s"' % arg)
+    else:
+        svnargs.append(arg)
+svnargs = ' '.join(svnargs)
+
+#print 'SVN args: <%s>' % svnargs; sys.exit()  # dbg
+
+# perform commit
+print 'Performing SVN commit, this may take some time...'
+os.system('svn commit %s' % svnargs)
+svntime = time.asctime()
+print 'Getting SVN log and version info...'
+svnstatus = commands.getoutput('svn log -r HEAD')
+svnversion = commands.getoutput('svnversion .').split(':')[-1]
+
+# Confirm with user (trying to get the status from the svn commit blocks
+# silently, I don't care to debug it)
+ans = raw_input('If commit was succesful, proceed '
+                'with email notification? [Y/n] ')
+if ans.lower().startswith('n'):
+    print "Exiting now..."
+    sys.exit(1)
+else:
+    print "OK.  Emailing maintainers..."
+
+# Send emails
+subject = "[IPython SVN] New commit performed by %s" % os.getlogin()
+body = """\
+Commit performed at: %s
+
+SVN arguments used: %s
+
+SVN Version: %s
+
+This version probably points to this changeset:
+http://projects.scipy.org/ipython/ipython/changeset/%s
+
+Current SVN status after last commit:
+%s""" % (svntime,svnargs,svnversion,svnversion,svnstatus)
+
+for maint in maintainers:
+    print "Emailing",maint
+    os.system('echo "%s" | mail -s "%s" %s' % (body, subject,maint))
diff --git a/tools/lyxport b/tools/lyxport
new file mode 100644
index 0000000..0cc6a5f
--- /dev/null
+++ b/tools/lyxport
@@ -0,0 +1,1049 @@
+#!/usr/bin/env perl
+#
+#*****************************************************************************
+#
+#   lyxport - script for exporting lyx docs to HTML, PostScript and PDF
+#
+#   Inspired on the lyx2html script by Steffen Evers (tron@cs.tu-berlin.de)
+#   (many thanks to him).
+#
+#      Copyright (C) 2001  Fernando Pérez (Fernando.Perez@colorado.edu)
+#
+#*****************************************************************************
+#
+#      This program is free software; you can redistribute it and/or modify
+#      it under the terms of the GNU General Public License as published by
+#      the Free Software Foundation; either version 2 of the License, or
+#      (at your option) any later version.
+#
+#      This program is distributed in the hope that it will be useful,
+#      but WITHOUT ANY WARRANTY; without even the implied warranty of
+#      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#      GNU General Public License for more details.
+#
+#      If you do not have a copy of the GNU General Public License, write
+#      to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge,
+#      MA 02139, USA.
+#
+#      If the author of this software was too lazy to include the full GPL
+#      text along with the code, you can find it at:
+#
+#                 http://www.gnu.org/copyleft/gpl.html
+#
+#*****************************************************************************
+
+=pod
+
+=head1 NAME
+
+B<lyxport> - Export a LyX or LaTeX file to HTML, PostScript and PDF.
+
+=head1 SYNOPSIS
+
+B<lyxport> [options] F<file>
+
+Perl script which takes a LyX or LaTeX file as its only argument and produces
+HTML, PostScript and PDF versions of the document. The name is short for "lyx
+export".
+
+You can call B<lyxport> with a filename with or without extension: F<file>,
+F<file.lyx> and F<file.tex> will all work. B<lyxport> will update the LaTeX
+file if there is a corresponding LyX file with a newer timestamp.
+
+Use B<lyxport --help> for more information, and B<lyxport --man> for a full
+man page.
+
+=cut
+
+#*****************************************************************************
+# modify here the command names to suit your local conditions
+my %cmd= (
+	  lyx => "/usr/bin/lyx",
+	  latex => "latex",
+	  latex2html => "latex2html",
+	  dvips => "dvips",
+	  pdflatex => "pdflatex",
+	  epstopdf => "epstopdf"
+	 );
+
+#************ DO NOT CHANGE ANYTHING BELOW THIS ULESS YOU *REALLY* KNOW
+#************ WHAT YOU ARE DOING.
+
+#*****************************************************************************
+# modules and globals
+use strict;
+use File::Copy;
+use File::Basename;
+my (%opt);                   # command line options
+my $version = "0.3.2";        # keep this up to date with the docs (at end)!
+
+#*****************************************************************************
+# "main" (simple minded way to keep variable scoping under control)
+main();
+
+sub main {
+    my ($runs,			# number of latex runs
+	$file_in,		# input filename as given at cmd line
+	$file_base,		# base (no extension) name of file to work on
+	$lyx_time,		# timestamps of lyx/tex files
+	$tex_time,
+	$l2h_file,               # tex file cleaned up for latex2html
+	$targets_built,
+	$targets_failed,
+	$status,                 # status string for diagnostics printing
+	@latex_from_lyx         # LaTeX files was created from LyX file
+       );
+
+    #------------------------------------------------------------------------
+    # code begins
+
+    cmdline_process(\%opt,\$file_in);
+
+    # set defaults and filenames needed throughout
+    $runs=$opt{runs};
+    set_cmd_defaults(\%cmd);
+    $file_base=check_file_exists($file_in);
+    # various filenames (with extensions)
+    my @exts=qw(lyx tex aux dvi log ps pdf out toc);
+    my ($lyx,$tex,$aux,$dvi,$log,$ps,$pdf,$out,$toc) = map { "$file_base.$_" } @exts;
+
+    # first, if tex file is older than lyx file, update
+    @latex_from_lyx=update_tex($lyx,$tex);
+
+    if ($opt{clean}) {
+	lyxport_info("Cleanup of old auxiliary files requested");
+	safe_system("rm -rf $file_base");
+	unlink ($aux,$log,$out,$toc);
+    }
+
+    # run latex for both html (needs .aux file) and ps (needs .dvi)
+    if ($opt{html} or $opt{ps}) {
+	run_latex("$cmd{latex} -interaction=nonstopmode",$tex,\$runs);
+    }
+    # now make targets
+    if ($opt{html}) {
+	make_html($tex,$file_base,$opt{opts_l2h},\$status,
+		  \$targets_built,\$targets_failed);
+    }
+    if ($opt{ps}) {
+	make_ps($dvi,$ps,$file_base,\$status,\$targets_built,\$targets_failed);
+    }
+    if ($opt{pdf}) {
+	make_pdf($tex,$pdf,\$runs,$file_base,
+		 \$status,\$targets_built,\$targets_failed);
+    }
+
+    #cleanup before exiting and print some diagnostics info
+    unless ($opt{debug}) {
+	unlink ($dvi,$log,$out);
+    }
+    # extra cleanup
+    if ($opt{tidy}) {
+	print "tidy up $opt{tidy},$aux,$log,$out,$toc,@latex_from_lyx\n";
+	tidy_up($opt{tidy},$aux,$log,$out,$toc,@latex_from_lyx);
+    }
+    final_diagnostics($file_in,$status,$targets_built,$targets_failed);
+    exit(0);
+} # end of main()
+
+#*****************************************************************************
+# subroutines
+
+#-----------------------------------------------------------------------------
+sub make_html {
+    my($tex,$html_dir,$opts_l2h,$stat_ref,$built_ref,$failed_ref)=@_;
+    my($success);
+
+    lyxport_info("Making HTML");
+    run_latex2html($tex,$opts_l2h);
+    $success=check_targets("${html_dir}/${html_dir}.html",'HTML',
+			   $built_ref,$failed_ref);
+    if ($success) {$$stat_ref .= "Target HTML built in directory $html_dir\n" }
+} # end of make_html()
+
+#-----------------------------------------------------------------------------
+sub make_ps {
+    my($dvi,$ps,$html_dir,$stat_ref,$built_ref,$failed_ref)=@_;
+    my($success);
+
+    lyxport_info("Making PostScript");
+    safe_system("$cmd{dvips} $dvi -o $ps");
+    $success=check_targets($ps,'PostScript',$built_ref,$failed_ref);
+    if ($success and not $opt{leave}) {
+	move2html_dir('PostScript',$ps,$html_dir,$stat_ref,$built_ref);
+    }
+} # end of make_ps()
+
+#-----------------------------------------------------------------------------
+sub make_pdf {
+    my($tex,$pdf,$runs_ref,$html_dir,$stat_ref,$built_ref,$failed_ref)=@_;
+    my($success);
+
+    lyxport_info("Making PDF");
+    run_pdflatex($tex,$pdf,$runs_ref);
+    $success=check_targets($pdf,'PDF',$built_ref,$failed_ref);
+    if ($success and not $opt{leave}) {
+	move2html_dir('PDF',$pdf,$html_dir,$stat_ref,$built_ref);
+    }
+} # end of make_pdf()
+
+#-----------------------------------------------------------------------------
+# move a given target to the html dir, only if it exists. leaves diagnostics 
+# info in a status string
+sub move2html_dir {
+    my($name,$file,$dir,$stat_ref,$html_status_ref)=@_;
+
+    if ($$html_status_ref =~ /HTML/) {
+	safe_system("mv $file $dir");
+	$$stat_ref .= "Target $name moved to directory $dir\n";
+    } else {
+	$$stat_ref .= "Target $name left in current directory\n";
+    }
+} # end of move2html_dir()
+
+#-----------------------------------------------------------------------------
+# make sure that the tex file is up to date vs the lyx original before starting
+# returns a list of the included .tex files which were generated (besides the main one)
+sub update_tex {
+    my($lyx,$tex)=@_;
+    my($lyx_time,$tex_time);
+    my(@lyx_out,@made_tex,$lc);
+
+    @made_tex=();
+    unless (-e $lyx) {
+	print "LyX file not found. Working off the LaTeX file alone.\n\n";
+	return;
+    }
+    $lyx_time=(stat($lyx))[9];
+    $tex_time=(stat($tex))[9];
+    if ($lyx_time>$tex_time or not(-e $tex)) { 
+	lyxport_info("LaTeX file outdated or not existent, regenerating it...");
+	unlink $tex;
+	@lyx_out=`$cmd{lyx} -dbg latex --export latex $lyx 2>&1 `;
+	# try again without -dbg option: LyX has a bug here! Note that this will
+	# disable the ability to remove extra .tex files generated from \include
+	# statements. But at least it will work, until they fix the bug in LyX.
+	unless (-e $tex) {
+	    @lyx_out=`$cmd{lyx} --export latex $lyx 2>&1 `;
+	}
+	# end of ugly workaround
+	unless (-e $tex) {die "Aborting: couldn't create LaTeX file with LyX.\n\n"};
+	push (@made_tex,$tex);
+	# find whether lyx made auxiliary (included) .tex files and report
+	foreach $lc (0..$#lyx_out-1) {
+	    $_=$lyx_out[$lc];
+	    if (/^incfile:.*\.lyx/) { 
+		$lyx_out[$lc+1] =~ /^writefile:(.*)$/;
+		push (@made_tex,basename($1));
+	    }
+	}
+	if (@made_tex) {
+	    lyxport_info("Made LaTeX included files: @made_tex");
+	}
+	lyxport_info("Done with LaTeX generation. Moving on.");
+    }
+    return @made_tex;
+} # end of update_tex()
+
+#-----------------------------------------------------------------------------
+# run latex on a file as many times as needed
+# if the given # of runs is > 0, that many are done; otherwise latex is run
+# as many times as needed until cross-references work.
+# can be used to run either normal latex or pdflatex
+sub run_latex {
+    my($latex_cmd,$file,$runs_ref)=@_;
+
+    # pre-determined # of runs
+    if ($$runs_ref > 0) {
+	foreach (1..$$runs_ref) {
+	    lyxport_info("$latex_cmd run # $$runs_ref");
+	    safe_system("$latex_cmd $file");
+	}
+    }
+    # or make as many runs as needed to get things right (not very robust...)
+    else {
+	$$runs_ref=0;
+	while (1) {
+	    $$runs_ref++;
+	    lyxport_info("$latex_cmd run # $$runs_ref");
+	    $_ = `$latex_cmd $file`;
+	    print;
+	    last unless (/Rerun to get cross-references right/m or 
+			 /^No file .*\.toc.$/m);
+	}
+    }
+} # end of run_latex()
+
+#-----------------------------------------------------------------------------
+# cleanup the tex code so that latex2html doesn't get too confused
+# this is essentially a Perl version (made with s2p) of Steffan Effer's
+# original improvetex sed script, part of his lyx2html script collection
+sub improve_tex4html {
+    my ($texfile,$newfile)=@_;
+    my ($len1,$pflag);
+    my $printit=1;
+    local *OLD,*NEW;
+
+    open(OLD,"< $texfile") || die "Can't read from file $texfile: $!\n";
+    open(NEW,"> $newfile") || die "Can't write to file $newfile: $!\n";
+    select(NEW) || die "Can't make $newfile default filehandle: $!\n";
+
+# code generated by s2p follows. Emacs can't reindent it properly!
+# this code is ugly (once in Perl, original sed was ok). Clean it up...
+$pflag=$\; # save print flag
+$\="\n";
+LINE:
+while (<OLD>) {
+    chomp;
+    # remove pagerefs over two lines (senseless in HTML)
+    if (/on *$\|on *page *$/) {
+	$_ .= "\n";
+	$len1 = length;
+	$_ .= <OLD>;
+	chop if $len1 < length;
+	s/on *\n*page *\n*\\pageref{[^}]*}/\n/g;
+    }
+    # remove regular pagerefs (senseless in HTML)
+    s/on *page *\\pageref{[^}]*}//g;
+    # comment out redefintion of url tag (confuses latex2html)
+    if (/^\\IfFileExists{url.sty}/) {
+	s/^/%/;
+	print;
+	$_ = <OLD>;
+	s/^/%/;
+    }
+    # remove empty pages
+    if (/^\\thispagestyle{empty}~\\newpage$/) {
+        $printit = 0;
+        next LINE;
+    }
+    if (/^\\thispagestyle{empty}~$/) {
+        $printit = 0;
+        next LINE;
+    }
+    # remove custom latex commands for fancyheaders
+    s/\\fancyhead[^{]*{[^{}]*([^{}]*{[^{}]*})*[^{}]*}*//g;
+    s/\\thispagestyle{[^{}]*}//g;
+    # change documentclass from scrbook to book
+    s/^(\\documentclass[^{}]*{)scrbook}/$1book}/;
+    # comment out unsupported packages
+    s/^(\\usepackage\[T1\]{fontenc})/%$1/;
+    s/^(\\usepackage{a4wide})/%$1/;
+    s/^(\\usepackage{fancyhdr})/%$1/;
+    s/^(\\usepackage{ae)/%$1/;
+    s/^(\\pagestyle{fancy})/%$1/;
+    # the geometry package doesn't make sense in html
+    s/^(\\usepackage{geometry})/%$1/;
+    s/^(\\geometry)/%$1/;
+    # comment out ident/skip block command (produces error message; why?)
+    s/^(\\setlength\\parskip{.*})/%$1/;
+    s/^(\\setlength\\parindent{.*})/%$1/;
+} continue {
+    if ($printit) { print }
+    else { $printit++ }
+}
+close(OLD);
+close(NEW);
+select(STDOUT);
+$\=$pflag; # restore defaults
+}  # end of improve_tex4html()
+
+#-----------------------------------------------------------------------------
+sub run_latex2html {
+    my ($tex,$latex2html_opts)=@_;
+    my ($l2h_file,$symlink_exists,$htmldir);
+
+    ($htmldir=$tex) =~ s/\.tex$//;
+    $l2h_file="${tex}_#tmp_2html#";
+    improve_tex4html($tex,$l2h_file);
+    # add index support
+    my $xtraargs = "";
+    my $idx = "$htmldir.idx";
+    if(-e $idx ) {
+            $xtraargs .= "-index $idx";
+    }
+    safe_system("$cmd{latex2html} $xtraargs $latex2html_opts $l2h_file");
+    unless ($opt{debug}) {
+	unlink($l2h_file,"$htmldir/labels.pl");
+    }
+
+    # latex2html always leaves 2 copies of the file (one as file.html, one as 
+    # index.html). In systems that support symlinks, remove one and replace it 
+    # with a link:
+    $symlink_exists = eval { symlink("",""); 1 };
+    if ($symlink_exists) {
+	unlink("$htmldir/index.html");
+	symlink("$htmldir.html","$htmldir/index.html");
+    }
+} # end of run_latex2html()
+
+#-----------------------------------------------------------------------------
+# remove calls to eps figures if they have an accompanying tiff, jpg or png
+sub improve_tex_figs {
+    my ($tex,$textmp)=@_;
+    local (*TEX,*TMP);
+
+    # begin changes to tex file
+    my ($printit,$figname,$fignoneps,$figbase,$figext,$fignew,@figlist,@tmpfiles);
+    open(TEX,"< $tex") || die "Can't read from LaTeX file $tex: $!\n";
+    open(TMP,"> $textmp") || die "Can't write to temp file $textmp: $!\n";
+    $printit=1;
+    while (<TEX>) {
+	if (/includegraphics{([^\}]*)/) {
+	    $figname=$1;
+	    # remove .eps from fig name and make a .pdf version if necessary
+	    if ($figname =~ /\.eps$/i) {
+		($figbase = $figname) =~ s/\.eps$//i;
+		# now we need to find if there's any non-eps figure for this file:
+		# pdflatex can handle jpegs, tiffs, etc. So we only need to build
+		# an associated pdf if there is no other figure file for pdflatex
+		# to work with
+		@figlist=grep {/\.jpe?g$|\.tiff?$|\.png$|\.pdf$/i} <$figbase.*>;
+		if (@figlist > 1) {
+		    lyxport_info("Problem! More than one figure file found: @figlist");
+		    die "I don't know what to do here. Sorry, aborting...\n\n";
+		} elsif (@figlist==1) {
+		    # problem: pdftex only recognizes jpg (not jpeg, not JPG, etc)
+		    # and tif (not tiff, not TIF, etc). It also gets confused by files
+		    # called a.b.c.jpg (it thinks .b.c.jpg is the extension). argh!!!
+		    ($fignoneps)=(@figlist);
+		    # so first, extract the 3 or 4 letter extension and lowercase it
+		    $fignoneps =~ /.*\.(....??)$/;
+		    ($figext = $1) =~ tr/[A-Z]/[a-z]/;
+		    # and remove any periods from the base of the name (replace by _)
+		    $figbase =~ s/\./_/g;
+		    $fignew="$figbase.$figext";
+		    if ($fignoneps =~ /\.JPE?G$|\.TIFF?$|\.PNG$|\.PDF$/) {
+			lyxport_info("pdflatex only recognizes the following extensions:\n".
+				     "pdf, png, jpg, tif. (all lowercase, no variations like jpeg or tiff).\n".
+				     "lyxport will make a copy of $fignoneps to $fignew so that pdflatex is happy");
+			copy($fignoneps,$fignew);
+			push(@tmpfiles,$fignew);
+		    }
+		    s/$figname/$fignew/;  # in $_, for printing to temp file
+		} else {
+		    s/$figname/$figbase.pdf/;
+		    lyxport_info("Making PDF figure <$figbase.pdf> from <$figname>");
+		    safe_system("$cmd{epstopdf} $figname");
+		}
+
+	    }
+	}
+    } continue {
+	if ($printit) { print TMP $_}
+	else { $printit++ }
+    }
+    close(TEX);
+    close(TMP);
+    return @tmpfiles;
+}  # end of improve_tex_figs()
+
+#-----------------------------------------------------------------------------
+# Make the pdf directly from the latex file
+# Notes: for this to work ok, the following must have been done:
+# 1. ~/.dvipsrc file must contain the lines
+#    p+ psfonts.cmz
+#    p+ psfonts.amz
+# 2. The latex preamble of the lyx file must have
+#    \usepackage{ae,aecompl}
+# This is so that T1 encoded fonts come out looking good in the final pdf.
+sub run_pdflatex {
+    my ($tex,$pdf,$runs_ref)=@_;
+    my ($texbase,$tmpbase,$textmp,@tmpfiles,@extensions,$printit);
+    local *TEX,*TMP;
+
+    # first fix references to eps figures (make sure that pdf versions exist!!!)
+    # make all changes in a temp tex file
+    ($texbase=$tex) =~ s/\.tex$//;
+    $tmpbase = "${texbase}_#tmp_pdf#";
+    @extensions=qw(tex aux out toc log);
+    ($textmp,@tmpfiles)= map { "${tmpbase}.$_" } @extensions;
+
+    push(@tmpfiles,improve_tex_figs($tex,$textmp));
+    # now run the actual pdflatex converter
+    run_latex("$cmd{pdflatex} -interaction=nonstopmode",$textmp,$runs_ref);
+    rename( "${tmpbase}.pdf",$pdf);
+    unless ($opt{debug}) { unlink ($textmp,@tmpfiles,"texput.log"); }
+} # end of run_pdflatex()
+
+#-----------------------------------------------------------------------------
+# general utility routines (not related to latex/html/pdf) follow
+
+#-------------------------------------------------------------------------
+sub cmdline_process{
+    my($opt_ref,$file_ref)=@_;
+
+    # modules
+    no strict "vars";  # avoid some unpleasant warnings while checking options
+
+    use Getopt::Long;
+    # allow bundling of single letter options (-a -b == -ab)
+    Getopt::Long::Configure ("bundling");
+    use Pod::Usage;
+
+    # note: the second name for each option (after |) is an alias for user
+    # convenience only. Internally, the only created hash entries use the *first*
+    # name as a key (i.e. $opt{h} doesn't exist, $opt{html} is set with -h or --html)
+    my(@option_list) = qw(html|h ps|p pdf|f leave
+			  runs|r=i opts_l2h|o=s clean|c tidy|t+
+			  cld|l debug|d help man|m version|v);
+
+    # debug mode overrides all post-run cleanup options
+    if ($opt{debug}) { $opt{t}=0 }
+
+    # default: a negative # of runs means auto-detect
+    $$opt_ref{runs}= -99;
+    # dash options first
+    GetOptions($opt_ref,@option_list)  ||  pod2usage(-verbose => 0);
+
+    # execute all possible "die" modes first
+    cmdline_debug(%$opt_ref) if ($$opt_ref{cld});
+    pod2usage(-verbose => 1)  if ($$opt_ref{help});
+    pod2usage(-verbose => 2)  if ($$opt_ref{man});
+    die "\nlyxport: version $version\n\n" if ($$opt_ref{version});
+
+    ## Now get filename (only ONE)
+    pod2usage(-verbose => 0, -message =>
+	      "\nERROR: lyxport works with exactly ONE file at a time.\n")
+      if (@ARGV != 1);
+    ($$file_ref)=@ARGV;
+
+    # choose whether to make all targets or just the explicitly specified ones
+    unless ($$opt_ref{html} or $$opt_ref{ps} or $$opt_ref{pdf}) {
+	$$opt_ref{html}=$$opt_ref{ps}=$$opt_ref{pdf}=1;
+    }
+} # end of cmdline_process()
+
+#-----------------------------------------------------------------------------
+# quick and dirty hash printing by key/value pairs
+sub print_hash {
+    my($key_msg,$val_msg,%hash)=@_;
+    my($op,$val);
+
+    while ( ($op,$val)=each(%hash) ) {print "$key_msg $op $val_msg $val\n" }
+} # end of print_hash()
+
+#-----------------------------------------------------------------------------
+sub cmdline_debug{
+    my(%opt)=@_;
+
+    print "\nlyxport command line debug mode\n";
+    print "-------------------------------\n\n";
+    print "This is a dump of your command line options, as key-value pairs:\n\n";
+    print_hash("","->",%opt);
+    print "\nExiting...\n\n";
+    exit;
+} # end of cmdline_debug()
+
+#-----------------------------------------------------------------------------
+# execute a system call but die with some info if return value is non-zero
+sub safe_system {
+    my $error;
+
+    $error=system(@_)/256;
+    if ($error) {
+	print "\nERROR: Command\n   @_\nfailed.\n";
+    }
+    return $error;
+} # end of safe_system()
+
+#-----------------------------------------------------------------------------
+# check that the command names specified at the top exist in the system, 
+# otherwise choose bare defaults and hope for the best.
+sub set_cmd_defaults {
+    my ($cmd)=@_;
+    my ($prog,$cmd_name);
+
+    print "\n";
+    while (($prog,$cmd_name)=each(%cmd)) {
+	print "Checking for program <$prog>, as <$cmd_name>... \n";
+	if (system("which $cmd_name")/256) {
+	    $$cmd{$prog}=$prog;
+	    print "Not found. Reverting to default name $prog.\n";
+	} else { print "OK, found it.\n" }
+    }
+    print "\nDone configuring command names\n\n";
+} # end of set_cmd_defaults()
+
+#-----------------------------------------------------------------------------
+# make sure there's either a .lyx or a .tex file to work with
+# returns a stripped name (without .lyx or .tex extension) of the file
+sub check_file_exists {
+    my($file_in)=@_;
+    my($base_file);
+
+    $_=$file_in;
+    if    (/\.lyx$/) { s/\.lyx$// }
+    elsif (/\.tex$/) { s/\.tex$// }
+    $base_file=$_;
+    unless (-e "${base_file}.lyx" or -e "${base_file}.tex") {
+	die "I can't find a LyX or LaTeX file to work with!\nAborting...\n\n";
+    }
+    return $base_file;
+} # end of check_file_exists()
+
+#-----------------------------------------------------------------------------
+sub check_targets{
+    my($file,$tag,$built,$failed)=@_;
+    my($success)=0;
+
+    $tag .= ' ';
+    if (-s $file) { $$built .= $tag; $success=1; }
+    else { $$failed .= $tag }
+    return $success;
+} # end of check_targets()
+
+#-----------------------------------------------------------------------------
+# do extra cleaning of aux, toc, log files generated during running
+sub tidy_up {
+    my($tidy,$aux,$log,$out,$toc,@latex_from_lyx)=@_;
+
+    lyxport_info("Cleanup of leftover auxiliary files");
+    print "Removing files: $aux, $log, $out, $toc\n";
+    unlink ($aux,$log,$out,$toc);
+    if ($tidy>1 and @latex_from_lyx) {
+	lyxport_info("Extra cleanup: removing LaTeX file(s) @latex_from_lyx");
+	unlink(@latex_from_lyx);
+	foreach (@latex_from_lyx) {
+	    s/\.tex$/\.aux/;
+	    if (-e) {
+		print "Removing aux file $_\n";
+		unlink($_);
+	    }
+	}
+    }
+} # end of tidy_up()
+
+#-----------------------------------------------------------------------------
+sub lyxport_info {
+    my ($target)=@_;
+
+    print "\n",'*'x75,"\n";
+    print "<lyxport> $target\n\n";
+} # end of lyxport_info()
+
+#-----------------------------------------------------------------------------
+sub final_diagnostics{
+    my($file_in,$status,$targets_built,$targets_failed)=@_;
+
+    lyxport_info("All done!");
+    print "Input file: $file_in\n\n";
+    print "Targets built : $targets_built\n\n";
+    if ($targets_failed) {
+	print "PROBLEM!\nTargets failed: $targets_failed\n\n";
+    }
+    print "Diagnostics of build process:\n\n$status\nBye!\n\n";
+} # end of final_diagnostics()
+
+
+#************************ end of code for <lyxport> *******************
+
+__END__
+
+=pod
+
+=head1 DESCRIPTION
+
+=head2 Purpose
+
+LyX ( http://www.lyx.org ) is a wonderful document processor, which can produce
+from a single source multiple versions for different purposes: a PostScript
+file for printing on a Unix-type system, a PDF file for distribution across
+multiple operating systems, or an HTML file for Internet display. It
+accomplishes this by exporting its own file format to a LaTeX file and then
+running various converters on this resulting file.
+
+However, it turns out that this process isn't exactly foolproof, as these
+converters have all sorts of little quirks which can produce anything from
+surprises in the way the final result looks like to outright failure of the
+export process. The purpose of B<lyxport> is to serve as a "smart wrapper"
+around those export facilities which LyX normally uses, trying to massage the
+LaTeX file that everything starts from in the hopes of having better success
+in producing HTML and PDF (PostScript usually poses no problems). 
+
+B<lyxport> also allows you to keep around only the LyX file, and possibly any
+ancillary figure files. B<lyxport> takes care of generating (and removing
+afterwards if instructed to do so) any intermediate files necessary for the
+export process.
+
+For example, in order to make PDF from a LaTeX file, any included eps figures
+need to be converted to pdf format. But LyX likes to have the figures in eps
+format for on-screen display, which is a great feature to have. B<lyxport>
+allows you to keep your LyX file as usual (with references to .eps figures)
+and will make .pdf versions of any included figure on the fly as needed. You
+can even ask it to remove those pdf files after it finishes, if you really
+want to maintain a minimum of files around (though it will have to remake them
+again if you ever need to update your pdf exported document).
+
+=head2 Command line use
+
+If you simply type B<lyxport> F<file>, it will try to make PostScript, HTML,
+and PDF versions of your file, putting them all in a single directory named
+F<file> (without a .lyx or .tex extension if your file had one). But it has
+L<command line options|OPTIONS AND ARGUMENTS> for making only the
+formats you want, and fairly detailed control over its behavior.
+
+=head2 If you don't have LyX
+
+Despite its name, if you are a regular LaTeX user and don't even have LyX
+installed in your system, B<lyxport> can still be useful to you. In fact,
+B<lyxport> only uses LyX once in each run: if there is no F<file.tex> or if
+F<file.lyx> file is newer than F<file.tex>, B<lyxport> updates F<file.tex>
+from F<file.lyx>. But if there is no F<file.lyx> at all it will simply use
+F<file.tex> and proceed with all its functionality intact.
+
+=cut
+###########################################################################
+=pod
+
+=head1 OPTIONS AND ARGUMENTS
+
+Single letter options (preceded by a single dash B<->) can be bundled: B<-pf>
+is equivalent to B<-p -f>. Long options (preceded by two dashes B<-->) can be
+abbreviated to as few letters as needed to clear ambiguity.
+
+=over
+
+=item B<-r --runs> I<NUM>
+
+Set number of latex runs by hand (otherwise auto-determined).
+
+=item B<-o --opts_l2h> I<'string'>
+
+String with options to be passed to B<latex2html>. This string should be
+protected by single quotes to allow double quotes inside of it.
+
+For example, if you want to pass to B<latex2html> the option B<-info "my
+info"> you can do so with B<lyxport -o ' -info "my info" '> (the extra spaces
+around the quote marks are not needed, they are here only for the sake of
+clarity).
+
+B<latex2html> has I<many> command-line options. For a project you are working
+constantly on, it may be more convenient to permanently set some of those
+options via a file called F<.latex2html-init> which B<latex2html> always
+reads at startup. See the B<latex2html> man page or the excellent online
+documentation kept at http://www-texdev.mpce.mq.edu.au/l2h/docs/manual for
+full details.
+
+=item B<-h --html>
+
+Export to HTML.
+
+=item B<-p --ps>
+
+Export to PostScript.
+
+=item B<-f --pdf>
+
+Export to PDF. See below the section L<PDF GENERATION> for details on how to
+obtain nice-looking PDF from your LaTeX sources.
+
+If none of the three above options is specified, the default behavior is to
+export I<all> three formats. If any is given, then only those formats
+explicitly specified will be produced (e.g. B<-h -f> makes HTML and PDF only,
+but not PostScript).
+
+=item B<--leave>
+
+By default lyxport moves the resulting PostScript and PDF files into the
+directory containing the HTML results (if it was created). This option tells
+it to leave them in the current directory.
+
+=item B<-c --clean>
+
+Do a clean start export, removing first any html directory, .aux, .log
+and .toc files which may have been left from previous runs.
+
+=item B<-t --tidy>
+
+B<lyxport> will tidy up I<after> itself, removing .aux, .log and .toc files left
+in the current directory. Use this only for "final" publication of documents, as
+those files are otherwise useful to shorten the time of runs.
+
+This option is incremental: you can call it twice (you can bundle it as
+B<-tt>). If called twice, B<lyxport> will remove also the LaTeX file
+associated with your LyX file, but I<only if> B<lyxport> I<itself created it
+in the same run>. This behavior is meant to be a safety net, so that
+B<lyxport> doesn't accidentally remove LaTeX files which you may have manually
+modified in some way.
+
+So if this option is called twice, you can start with a LyX file named F<file.lyx>
+and end up only with your original file plus a single directory named F<file> which 
+will contain F<file.html>, F<file.ps> and F<file.pdf> (plus some ancillary stuff for
+the html version). This mode of operation is obviously provided for the neatness
+freaks amongst us.
+
+=item B<-d --debug>
+
+Debugging mode: B<lyxport> will leave I<all> temporary files it creates lying
+around. If a particular target refuses to build, you can then try to run the
+respective commands on the temporary files manually, and possibly diagnose the
+source of the problem.
+
+This option will override any calls made to option B<--tidy>.
+
+=item B<-l --cld>
+
+Special command-line debugging mode: only prints (in a rather primitive form)
+the names and values of all command-line options which were set. Useful for
+finding problems with complicated option strings being passed to
+B<latex2html>.
+
+=item B<--help>
+
+Print this help and quit.
+
+=item B<-m --man>
+
+Print a complete man page. B<lyxport> is documented using embedded pod
+strings, so you can see its full documentation using the command B<perldoc
+lyxport>.
+
+You can also convert this documentation to other formats using the
+I<pod2_anything> family of converters (L<pod2html>, L<pod2latex>, L<pod2man>
+and L<pod2text>). See their respective man pages for details.
+
+Note that if you installed B<lyxport> properly, you should already have a man
+page available, plus html and plain text versions of the documents. These are
+by default installed to a directory named F</usr/local/doc/lyxport-XXX>, where
+F<XXX> is the version number. At installation time, you may manually change
+the F</usr/local> prefix. Consult your local documents or ask your system
+administrator for details on the specifics of your configuration.
+
+=item B<-v --version>
+
+Print version information and quit.
+
+=item B<filename>
+
+The given filename may have a .lyx or .tex extension (or none at
+all). I<lyxport> will update the tex file from the lyx file if necessary.
+
+B<lyxport> accepts only I<one> filename at a time.
+
+=back
+
+=cut
+###########################################################################
+=pod
+
+=head1 INTEGRATION WITH LyX
+
+If you find that B<lyxport> is more succesful in exporting your files than
+LyX's default calls to B<latex2html> and B<pdflatex>, you can modify LyX to
+use B<lyxport> as its conversion routine. For LyX versions 1.1.6 and above, go
+to C<< Edit->Preferences->Converters->Converters >> and specify B<lyxport> as your
+converter for C<< LaTeX->HTML >> and C<< LaTeX->PDF >>. LyX's convention
+is to call B<$$i> the current file.
+
+For example, if you want to setup B<lyxport> to be your PDF export filter
+under LyX, in the C<Converters> dialog, in the C<< LaTeX->PDF(pdflatex) >>
+option, set:
+
+    lyxport --pdf $$i
+
+This way you'll be able to export to pdf directly from within LyX, even if
+your figures are in eps format.
+
+LyX's C<Converters> dialog is a bit confusing: after making changes, you must
+first press the C<Modify> button for your changes to actually be recorded, and
+then C<Save>.
+
+You can similarly set up B<lyxport> to be your LaTeX to HTML converter.
+
+For LyX versions earlier than 1.1.6 (which didn't have the new Preferences
+dialog) these same options can be configured via your LyX defaults file. See
+the LyX documentation for details.
+
+=cut
+###########################################################################
+=pod
+
+=head1 PDF GENERATION
+
+=head2 Fonts
+
+Normally PDF documents made on Unix-type systems from LaTeX sources produce
+horrible looking fonts when viewed with Adobe's own Acrobat Reader. I don't
+know the many intricacies of the problem (you can search for the details on
+your own). I'll simply list here the trick that has helped I<me> solve the
+font problem. Try it, your mileage may vary.
+
+=over
+
+=item 1
+
+In your home directory, make (or modify it if it already exists) a file
+named F<.dvipsrc> which must contain the lines:
+
+    p+ psfonts.cmz
+    p+ psfonts.amz
+
+=item 2
+
+Make sure that the LaTeX preamble of your LyX file (or the part before
+C<\begin{document}> if you are using straight LaTeX files) contains:
+
+    \usepackage[T1]{fontenc}
+    \usepackage{ae,aecompl}
+
+This will guarantee that T1 encoded fonts come out looking good in the final PDF.
+
+=back
+
+=head2 Figures
+
+B<pdflatex> (if I understand correctly) only accepts filenames with a single
+B<.> in them, and only uses graphic files with extensions pdf, png, jpg and
+tif (all lowercase). B<lyxport> will do its best to analyze your latex file
+and try to change references to figures to accommodate B<pdflatex>, by
+creating temporary copies of your image files if necessary.
+
+Ideally, you should be able to have for example a figure called F<fig.1.JPG>
+along with a F<fig.1.eps> (for B<lyx> to preview it), and B<lyxport> would
+export a pdf document without leaving any more files after itself, even though
+it temporarily had to create F<fig_1.jpg> to make B<pdflatex> happy. As I
+said, ideally... If things don't quite work, try the B<--debug> option. If you
+find a fix for the problem, mail it to me: fperez@pizero.colorado.edu
+
+=head2 Links
+
+In order for URLs and similar elements to produce proper active links in the
+PDF document, you need to include in your LaTeX preamble the line
+
+    \usepackage{hyperref}
+
+=cut
+###########################################################################
+=pod
+
+=head1 REQUIRES
+
+B<lyxport> relies on some programs listed below, for the reasons indicated:
+
+=over
+
+=item B<lyx>
+
+To make LaTeX files from LyX files. Tested with lyx version 1.1.6fix1, should
+work with earlier versions (perhaps with minor changes to the way LyX is called).
+
+=item B<latex>
+
+To produce PostScript and for latex2html to work properly (cross-references).
+
+=item B<dvips>
+
+For making PostScript output.
+
+=item B<latex2html>
+
+For generating HTML from latex sources.
+
+=item B<pdflatex>
+
+For making PDF output from a latex file with proper cross-referencing and
+internal document links.
+
+=item B<epstopdf>
+
+A Perl script to automatically generate pdf versions of eps figures included
+in lyx files. It is more robust in its handling of various eps quirks than a
+straight call to B<ps2pdf>.
+
+=item B<perl>
+
+Well, it's a Perl script after all, isn't it?
+
+=back
+
+However, partial use of B<lyxport> is still possible without some of these
+components. If for example you don't have B<latex2html> in your system, you
+can still use B<lyxport> to produce PostScript and PDF. Various combinations
+are possible.
+
+=head2 Portability
+
+There are calls in B<lyxport> to some Unix commands like B<rm -rf>. For this
+reason it is not totally portable. These calls are however reasonably few and
+could be eliminated if there is enough demand by replacing them with
+equivalent Perl code. It's just more work...
+
+=cut
+###########################################################################
+=pod
+
+=head1 TO DO
+
+=over
+
+=item *
+
+Build rpm for more convenient installation.
+
+=item *
+
+Clean up the C<improve_tex4html()> code for readability.
+
+=back
+
+=cut
+###########################################################################
+=pod
+
+=head1 VERSION
+
+This is B<lyxport> version 0.3.1
+
+=cut
+###########################################################################
+=pod
+
+=head1 AUTHOR
+
+Fernando Pérez E<lt>fperez@pizero.colorado.eduE<gt>.
+
+Please email me with comments, suggestions, bugfixes, etc.
+
+The most current version of B<lyxport> should always be available at
+http://www-hep.colorado.edu/~fperez/lyxport
+
+=cut
+###########################################################################
+=pod
+
+=head1 ACKNOWLEDGEMENTS
+
+Inspired on the B<lyx2html> script by Steffen Evers
+E<lt>tron@cs.tu-berlin.deE<gt>.  Some of the code is a blatant ripoff of
+Steffen's code, using B<s2p> to get Perl versions of his original B<sed>
+scripts.
+
+=cut
+###########################################################################
+=pod
+
+
+=head1 COPYRIGHT AND DISCLAIMER
+
+This program is Copyright 2001 by Fernando Pérez.
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+If you do not have a copy of the GNU General Public License write to
+the Free Software Foundation, Inc., 675 Mass Ave, Cambridge,
+MA 02139, USA.
+
+If the author of this software was too lazy to include the full GPL text along
+with the code, you can find it at: http://www.gnu.org/copyleft/gpl.html
+
+=cut
+#************************** end of file <lyxport> **********************
diff --git a/tools/make_tarball.py b/tools/make_tarball.py
new file mode 100644
index 0000000..80bd309
--- /dev/null
+++ b/tools/make_tarball.py
@@ -0,0 +1,28 @@
+import os,sys,shutil
+
+repo = "http://ipython.scipy.org/svn/ipython/ipython/branches/0.7.3"
+basename = 'ipython'
+workdir = './mkdist'
+
+workdir = os.path.abspath(workdir)
+
+print "working at",workdir
+def oscmd(c):
+    print ">",c
+    s = os.system(c)
+    if s:
+        print "Error",s
+        sys.exit(s)
+
+
+assert not os.path.isdir(workdir)
+os.mkdir(workdir)
+os.chdir(workdir)
+
+oscmd('svn export %s %s' % (repo,basename))
+ver = os.popen('svnversion ../..').read().strip()
+tarname = '%s.r%s.tgz' % (basename, ver)
+oscmd('tar czvf ../%s %s' % (tarname, basename))
+print "Produced: ",os.path.abspath('../' + tarname)
+os.chdir('/')
+shutil.rmtree(workdir)
diff --git a/tools/mkrel.py b/tools/mkrel.py
new file mode 100644
index 0000000..4d3b056
--- /dev/null
+++ b/tools/mkrel.py
@@ -0,0 +1,39 @@
+""" Create ipykit and exe installer
+
+requires py2exe
+
+"""
+#!/bin/sh
+# IPython release script
+
+
+import os
+import distutils.dir_util
+import sys
+
+execfile('../IPython/Release.py')
+
+def c(cmd):
+    print ">",cmd
+    os.system(cmd)
+
+ipykit_name = "ipykit-%s" % version
+
+
+os.chdir('..')
+if os.path.isdir('dist'):
+    distutils.dir_util.remove_tree('dist')
+if os.path.isdir(ipykit_name):
+    distutils.dir_util.remove_tree(ipykit_name)
+
+c("python exesetup.py py2exe")
+
+os.rename('dist',ipykit_name)
+
+c("zip -r %s.zip %s" % (ipykit_name, ipykit_name))
+
+c("python setup.py bdist_wininst --install-script=ipython_win_post_install.py")
+
+os.chdir("dist")
+#c("svn export http://ipython.scipy.org/svn/ipython/ipython/trunk ipython")
+#c("zip -r ipython_svn.zip ipython")
diff --git a/tools/release b/tools/release
new file mode 100644
index 0000000..030fa53
--- /dev/null
+++ b/tools/release
@@ -0,0 +1,99 @@
+#!/bin/sh
+# IPython release script
+
+PYVER=`python -V 2>&1 | awk '{print $2}' | awk -F '.' '{print $1$2}' `
+version=`ipython -Version`
+ipdir=~/ipython/ipython
+
+echo
+echo "Releasing IPython version $version"
+echo "=================================="
+
+echo "Marking ChangeLog with release information and making NEWS file..."
+
+# Stamp changelog and save a copy of the status at each version, in case later
+# we want the NEWS file to start from a point before the very last release (if
+# very small interim releases have no significant changes).
+
+cd $ipdir/doc
+cp ChangeLog ChangeLog.old
+cp ChangeLog ChangeLog.$version
+daystamp=`date +%Y-%m-%d`
+echo $daystamp " ***" Released version $version > ChangeLog
+echo >> ChangeLog
+cat ChangeLog.old >> ChangeLog
+rm ChangeLog.old
+
+# Build NEWS file
+echo "Changes between the last two releases (major or minor)" > NEWS
+echo "Note that this is an auto-generated diff of the ChangeLogs" >> NEWS
+echo >> NEWS
+diff ChangeLog.previous ChangeLog | grep -v '^0a' | sed 's/^> //g' >> NEWS
+cp ChangeLog ChangeLog.previous
+
+# Clean up build/dist directories
+rm -rf $ipdir/build/*
+rm -rf $ipdir/dist/*
+
+# Perform local backup
+cd $ipdir/tools
+./bkp.sh
+
+# Build source and binary distros
+cd $ipdir
+./setup.py sdist --formats=gztar
+
+# Build version-specific RPMs, where we must use the --python option to ensure
+# that the resulting RPM is really built with the requested python version (so
+# things go to lib/python2.X/...)
+python2.4 ./setup.py bdist_rpm --binary-only --release=py24 --python=/usr/bin/python2.4
+python2.5 ./setup.py bdist_rpm --binary-only --release=py25 --python=/usr/bin/python2.5
+
+# Build eggs
+python2.4 ./eggsetup.py bdist_egg
+python2.5 ./eggsetup.py bdist_egg
+
+# Call the windows build separately, so that the extra Windows scripts don't
+# get pulled into Unix builds (setup.py has code which checks for
+# bdist_wininst)
+./setup.py bdist_wininst --install-script=ipython_win_post_install.py
+
+# Change name so retarded Vista runs the installer correctly
+rename 's/win32/win32-setup/' $ipdir/dist/*.exe
+
+# Register with the Python Package Index (PyPI)
+echo "Registering with PyPI..."
+cd $ipdir
+./setup.py register
+
+# Upload all files
+cd $ipdir/dist
+echo "Uploading distribution files..."
+scp * ipython@ipython.scipy.org:www/dist/
+
+echo "Uploading backup files..."
+cd ~/ipython/backup
+scp `ls -1tr | tail -1` ipython@ipython.scipy.org:www/backup/
+
+echo "Updating webpage..."
+cd $ipdir/doc
+www=~/ipython/homepage
+cp ChangeLog NEWS $www
+rm -rf $www/doc/*
+cp -r manual.pdf manual/ $www/doc
+cd $www
+./update
+
+# Alert package maintainers
+echo "Alerting package maintainers..."
+maintainers='fperez@colorado.edu ariciputi@users.sourceforge.net jack@xiph.org tretkowski@inittab.de dryice@hotpop.com willmaier@ml1.net'
+#maintainers='fperez@colorado.edu'
+
+for email in $maintainers
+    do
+	echo "Emailing $email..."
+	mail -s "[Package maintainer notice] A new IPython is out. Version: $version" \
+    $email < NEWS
+    done
+
+echo "Done!"
diff --git a/tools/run_ipy_in_profiler.py b/tools/run_ipy_in_profiler.py
new file mode 100644
index 0000000..bcd0ef7
--- /dev/null
+++ b/tools/run_ipy_in_profiler.py
@@ -0,0 +1,16 @@
+import cProfile as profile
+import sys
+#import profile
+
+def main():
+    import IPython.ipapi
+    print "Entering ipython for profiling. Type 'Exit' for profiler report"
+    IPython.ipapi.launch_new_instance()
+
+if len(sys.argv) == 1:   
+    profile.run('main()', 'ipython_profiler_results')
+
+import pstats
+p = pstats.Stats(len(sys.argv) >1 and sys.argv[1] or 'ipython_profiler_results')
+p.sort_stats('time').print_stats(30)
+
diff --git a/tools/testrel b/tools/testrel
new file mode 100644
index 0000000..1265337
--- /dev/null
+++ b/tools/testrel
@@ -0,0 +1,28 @@
+#!/bin/sh
+
+# release test
+
+cd ~/ipython/ipython
+
+# clean up build/dist directories
+rm -rf build/*
+rm -rf dist/*
+
+# build source distros
+./setup.py sdist --formats=gztar
+
+# Build rpms
+python2.4 ./setup.py bdist_rpm --binary-only --release=py24 --python=/usr/bin/python2.4
+python2.5 ./setup.py bdist_rpm --binary-only --release=py25 --python=/usr/bin/python2.5
+
+# Build eggs
+python2.4 ./eggsetup.py bdist_egg
+python2.5 ./eggsetup.py bdist_egg
+
+# Call the windows build separately, so that the extra Windows scripts don't
+# get pulled into Unix builds (setup.py has code which checks for
+# bdist_wininst)
+./setup.py bdist_wininst --install-script=ipython_win_post_install.py
+
+# Change name so retarded Vista runs the installer correctly
+rename 's/win32/win32-setup/' dist/*.exe
diff --git a/tools/testupload b/tools/testupload
new file mode 100644
index 0000000..7024e67
--- /dev/null
+++ b/tools/testupload
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+# clean public testing/ dir and upload
+#ssh "rm -f ipython@ipython.scipy.org:www/dist/testing/*"
+cd ~/ipython/ipython/dist
+scp * ipython@ipython.scipy.org:www/dist/testing/
diff --git a/tools/update_revnum.py b/tools/update_revnum.py
new file mode 100644
index 0000000..7191114
--- /dev/null
+++ b/tools/update_revnum.py
@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+""" Change the revision number in Release.py """
+
+import os
+import re
+
+rev = os.popen('svnversion ..').read().strip()
+
+print "current rev is",rev
+assert ':' not in rev
+
+rfile = open('../IPython/Release.py').read()
+newcont = re.sub(r'revision\s*=.*', "revision = '%s'" % rev, rfile)
+open('../IPython/Release.py','w').write(newcont)
diff --git a/win32_manual_post_install.py b/win32_manual_post_install.py
new file mode 100644
index 0000000..0ec8886
--- /dev/null
+++ b/win32_manual_post_install.py
@@ -0,0 +1,141 @@
+#!python
+"""Windows-specific part of the installation"""
+
+import os, sys
+
+try:
+    import shutil,pythoncom
+    from win32com.shell import shell
+    import _winreg as wreg
+except ImportError:
+    print """
+You seem to be missing the PythonWin extensions necessary for automatic
+installation.  You can get them (free) from
+http://starship.python.net/crew/mhammond/
+
+Please see the manual for details if you want to finish the installation by
+hand, or get PythonWin and repeat the procedure.
+
+Press <Enter> to exit this installer."""
+    raw_input()
+    sys.exit()
+
+
+def make_shortcut(fname,target,args='',start_in='',comment='',icon=None):
+    """Make a Windows shortcut (.lnk) file.
+
+    make_shortcut(fname,target,args='',start_in='',comment='',icon=None)
+
+    Arguments:
+        fname - name of the final shortcut file (include the .lnk)
+        target - what the shortcut will point to
+        args - additional arguments to pass to the target program
+        start_in - directory where the target command will be called
+        comment - for the popup tooltips
+        icon - optional icon file. This must be a tuple of the type 
+        (icon_file,index), where index is the index of the icon you want
+        in the file. For single .ico files, index=0, but for icon libraries
+        contained in a single file it can be >0.
+    """
+
+    shortcut = pythoncom.CoCreateInstance(
+        shell.CLSID_ShellLink, None,
+        pythoncom.CLSCTX_INPROC_SERVER, shell.IID_IShellLink
+    )
+    shortcut.SetPath(target)
+    shortcut.SetArguments(args)
+    shortcut.SetWorkingDirectory(start_in)
+    shortcut.SetDescription(comment)
+    if icon:
+        shortcut.SetIconLocation(*icon)
+    shortcut.QueryInterface(pythoncom.IID_IPersistFile).Save(fname,0)
+
+
+def run(wait=0):
+    # Find where the Start Menu and My Documents are on the filesystem
+    key = wreg.OpenKey(wreg.HKEY_CURRENT_USER,
+                       r'Software\Microsoft\Windows\CurrentVersion'
+                       r'\Explorer\Shell Folders')
+
+    programs_dir = wreg.QueryValueEx(key,'Programs')[0]
+    my_documents_dir = wreg.QueryValueEx(key,'Personal')[0]
+    key.Close()
+
+    # Find where the 'program files' directory is
+    key = wreg.OpenKey(wreg.HKEY_LOCAL_MACHINE,
+                       r'SOFTWARE\Microsoft\Windows\CurrentVersion')
+
+    program_files_dir = wreg.QueryValueEx(key,'ProgramFilesDir')[0]
+    key.Close()
+
+
+    # File and directory names
+    ip_dir = program_files_dir + r'\IPython'
+    ip_prog_dir = programs_dir + r'\IPython'
+    doc_dir = ip_dir+r'\doc'
+    ip_filename = ip_dir+r'\IPython_shell.py'
+    pycon_icon = doc_dir+r'\pycon.ico'
+
+    if not os.path.isdir(ip_dir):
+        os.mkdir(ip_dir)
+
+    # Copy startup script and documentation
+    shutil.copy(sys.prefix+r'\Scripts\ipython',ip_filename)
+    if os.path.isdir(doc_dir):
+        shutil.rmtree(doc_dir)
+    shutil.copytree('doc',doc_dir)
+
+    # make shortcuts for IPython, html and pdf docs.
+    print 'Making entries for IPython in Start Menu...',
+
+    # Create .bat file in \Scripts
+    fic = open(sys.prefix + r'\Scripts\ipython.bat','w')
+    fic.write('"' + sys.prefix + r'\python.exe' + '" -i ' + '"' +
+              sys.prefix + r'\Scripts\ipython" %*')
+    fic.close()
+
+    # Create .bat file in \\Scripts
+    fic = open(sys.prefix + '\\Scripts\\ipython.bat','w')
+    fic.write('"' + sys.prefix + '\\python.exe' + '" -i ' + '"' + sys.prefix + '\\Scripts\ipython" %*')
+    fic.close()
+
+    # Create shortcuts in Programs\IPython:
+    if not os.path.isdir(ip_prog_dir):
+        os.mkdir(ip_prog_dir)
+    os.chdir(ip_prog_dir)
+
+    man_pdf = doc_dir + r'\manual.pdf'
+    man_htm = doc_dir + r'\manual\manual.html'
+
+    make_shortcut('IPython.lnk',sys.executable, '"%s"' % ip_filename,
+                  my_documents_dir,
+                  'IPython - Enhanced python command line interpreter',
+                  (pycon_icon,0))
+    make_shortcut('pysh.lnk',sys.executable, '"%s" -p pysh' % ip_filename,
+                  my_documents_dir,
+                  'pysh - a system shell with Python syntax (IPython based)',
+                  (pycon_icon,0))
+    make_shortcut('Manual in HTML format.lnk',man_htm,'','',
+                  'IPython Manual - HTML format')
+    make_shortcut('Manual in PDF format.lnk',man_pdf,'','',
+                  'IPython Manual - PDF format')
+
+    print """Done.
+
+I created the directory %s. There you will find the
+IPython startup script and manuals.
+
+An IPython menu was also created in your Start Menu, with entries for
+IPython itself and the manual in HTML and PDF formats.
+
+For reading PDF documents you need the freely available Adobe Acrobat
+Reader. If you don't have it, you can download it from:
+http://www.adobe.com/products/acrobat/readstep2.html
+""" % ip_dir
+
+    if wait:
+        print "Finished with IPython installation. Press Enter to exit this installer.",
+        raw_input()
+
+if __name__ == '__main__':
+    run()