initialization (no svn history)

.hgignore

@@ -0,0 +1,18 b''
+syntax: glob
+
+*~
+*.tmp
+*.pyc
+*.bak
+*.tgz
+*.org
+*.rej
+.svn/
+.bzr/
+.settings/
+.project
+*.diff
+IPython_crash_report.txt
+
+syntax: regexp
+.*\#.*\#$

ChangeLog

@@ -0,0 +1,1 b''
+link doc/ChangeLog
  No newline at end of file

IPython/ColorANSI.py

@@ -0,0 +1,170 b''
+# -*- coding: utf-8 -*-
+"""Tools for coloring text in ANSI terminals.
+
+$Id: ColorANSI.py 2167 2007-03-21 06:57:50Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2002-2006 Fernando Perez. <[e-mail]>
+#
+#  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]

IPython/ConfigLoader.py

@@ -0,0 +1,116 b''
+# -*- coding: utf-8 -*-
+"""Configuration loader
+
+$Id: ConfigLoader.py 1005 2006-01-12 08:39:26Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
+#
+#  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

IPython/CrashHandler.py

@@ -0,0 +1,228 b''
+# -*- coding: utf-8 -*-
+"""sys.excepthook for IPython itself, leaves a detailed report on disk.
+
+$Id: CrashHandler.py 2908 2007-12-30 21:07:46Z vivainio $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+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)

IPython/DPyGetOpt.py

@@ -0,0 +1,693 b''
+# -*- coding: utf-8 -*-
+"""DPyGetOpt -- Demiurge Python GetOptions Module
+
+ $Id: DPyGetOpt.py 2872 2007-11-25 17:58:05Z fperez $
+
+This module is modeled after perl's Getopt::Long module-- which
+is, in turn, modeled after GNU's extended getopt() function.
+
+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 <[e-mail]>
+#
+#
+# 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 <[e-mail]>'
+__license__ = 'MIT'
+__version__ = '1.2'
+
+# Modified to use re instead of regex and regsub modules.
+# 2001/5/7, Jonathan Hogg <[e-mail]>
+
+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)

IPython/Debugger.py

@@ -0,0 +1,517 b''
+# -*- coding: utf-8 -*-
+"""
+Pdb debugger class.
+
+Modified from the standard pdb.Pdb class to avoid including readline, so that
+the command line completion of other programs which include this isn't
+damaged.
+
+In the future, this class will be expanded with improvements over the standard
+pdb.
+
+The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor
+changes. Licensing should therefore be under the standard Python terms.  For
+details on the PSF (Python Software Foundation) standard license, see:
+
+http://www.python.org/2.2.3/license.html
+
+$Id: Debugger.py 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. <[e-mail]>
+#
+#
+#*****************************************************************************
+
+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)

IPython/Extensions/InterpreterExec.py

@@ -0,0 +1,259 b''
+# -*- 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 <[e-mail]>
+#       Copyright (C) 2004-2006 Fernando Perez <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__ = 'W.J. van der Laan <[e-mail]>, '\
+             '%s <%s>' %  Release.authors['Fernando']
+__license__ = Release.license
+
+# TODO: deprecated
+def prefilter_shell(self,line,continuation):
+    """Alternate prefilter, modified for shell-like functionality.
+
+    - 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

IPython/Extensions/InterpreterPasteInput.py

@@ -0,0 +1,122 b''
+# -*- 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 <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+# This file is an example of how to modify IPython's line-processing behavior
+# without touching the internal code. We'll define an alternate pre-processing
+# stage which allows a special form of input (which is invalid Python syntax)
+# 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.'

IPython/Extensions/PhysicalQInput.py

@@ -0,0 +1,83 b''
+# -*- 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 <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+# This file is an example of how to modify IPython's line-processing behavior
+# without touching the internal code. We'll define an alternate pre-processing
+# stage which allows a special form of input (which is invalid Python syntax)
+# 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.'

IPython/Extensions/PhysicalQInteractive.py

@@ -0,0 +1,88 b''
+# -*- 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 <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+from Scientific.Physics.PhysicalQuantities import PhysicalQuantity
+
+# This code can be set up to work with Numeric or with math for providing the
+# 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')

IPython/Extensions/__init__.py

@@ -0,0 +1,13 b''
+# -*- 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 ='.
+"""

IPython/Extensions/astyle.py

@@ -0,0 +1,398 b''
+"""
+``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")

IPython/Extensions/clearcmd.py

@@ -0,0 +1,66 b''
+# -*- 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')
+    
+
+
+

IPython/Extensions/envpersist.py

@@ -0,0 +1,90 b''
+# -*- 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')
+

IPython/Extensions/ext_rescapture.py

@@ -0,0 +1,66 b''
+# -*- 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)     

IPython/Extensions/ibrowse.py

@@ -0,0 +1,1767 b''
+# -*- 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)

IPython/Extensions/igrid.py

@@ -0,0 +1,1126 b''
+# -*- 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
+

IPython/Extensions/igrid_help.css

@@ -0,0 +1,45 b''
+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;
+}

IPython/Extensions/igrid_help.html

@@ -0,0 +1,86 b''
+<?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>

IPython/Extensions/ipipe.py

@@ -0,0 +1,2292 b''
+# -*- 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()

IPython/Extensions/ipy_app_completers.py

@@ -0,0 +1,17 b''
+""" 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')

IPython/Extensions/ipy_completers.py

@@ -0,0 +1,359 b''
+#!/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))
+

IPython/Extensions/ipy_constants.py

@@ -0,0 +1,669 b''
+""" 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 ([e-mail])
+
+# 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... """
+

IPython/Extensions/ipy_defaults.py

@@ -0,0 +1,62 b''
+""" 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)
+    
+    

IPython/Extensions/ipy_editors.py

@@ -0,0 +1,84 b''
+""" '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

IPython/Extensions/ipy_exportdb.py

@@ -0,0 +1,76 b''
+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
+    

IPython/Extensions/ipy_extutil.py

@@ -0,0 +1,43 b''
+""" 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')

IPython/Extensions/ipy_fsops.py

@@ -0,0 +1,244 b''
+""" 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

IPython/Extensions/ipy_gnuglobal.py

@@ -0,0 +1,38 b''
+#!/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')
+

IPython/Extensions/ipy_kitcfg.py

@@ -0,0 +1,80 b''
+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()
+
+

IPython/Extensions/ipy_legacy.py

@@ -0,0 +1,62 b''
+""" 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)

IPython/Extensions/ipy_leo.py

@@ -0,0 +1,215 b''
+""" 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()
[e-mail]_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)

IPython/Extensions/ipy_p4.py

@@ -0,0 +1,47 b''
+# -*- 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')
+

IPython/Extensions/ipy_profile_doctest.py

@@ -0,0 +1,46 b''
+"""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()

IPython/Extensions/ipy_profile_none.py

@@ -0,0 +1,4 b''
+""" Config file for 'default' profile """
+
+# get various stuff that are there for historical / familiarity reasons
+import ipy_legacy
  No newline at end of file

IPython/Extensions/ipy_profile_scipy.py

@@ -0,0 +1,25 b''
+""" 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()

IPython/Extensions/ipy_profile_sh.py

@@ -0,0 +1,226 b''
+"""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()

IPython/Extensions/ipy_profile_zope.py

@@ -0,0 +1,317 b''
+# -*- 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 <[e-mail]>"""
+__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 :

IPython/Extensions/ipy_pydb.py

@@ -0,0 +1,31 b''
+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)    
+
+    
+    
+    

IPython/Extensions/ipy_rehashdir.py

@@ -0,0 +1,140 b''
+# -*- 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)

IPython/Extensions/ipy_render.py

@@ -0,0 +1,68 b''
+#!/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

IPython/Extensions/ipy_server.py

@@ -0,0 +1,38 b''
+""" 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

IPython/Extensions/ipy_signals.py

@@ -0,0 +1,62 b''
+""" 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

IPython/Extensions/ipy_stock_completers.py

@@ -0,0 +1,17 b''
+""" 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')

IPython/Extensions/ipy_system_conf.py

@@ -0,0 +1,24 b''
+""" 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')

IPython/Extensions/ipy_traits_completer.py

@@ -0,0 +1,184 b''
+"""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'

IPython/Extensions/ipy_which.py

@@ -0,0 +1,76 b''
+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)        
+        

IPython/Extensions/ipy_workdir.py

@@ -0,0 +1,43 b''
+#!/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)

IPython/Extensions/jobctrl.py

@@ -0,0 +1,162 b''
+""" 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()

IPython/Extensions/ledit.py

@@ -0,0 +1,98 b''
+""" 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

IPython/Extensions/numeric_formats.py

@@ -0,0 +1,43 b''
+# -*- 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

IPython/Extensions/pickleshare.py

@@ -0,0 +1,359 b''
+#!/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 <[e-mail]>
+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()
+    
+    

IPython/Extensions/pspersistence.py

@@ -0,0 +1,183 b''
+# -*- 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)

IPython/Extensions/win32clip.py

@@ -0,0 +1,45 b''
+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 )

IPython/FakeModule.py

@@ -0,0 +1,43 b''
+# -*- 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. <[e-mail]>
+#
+#  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)

IPython/Gnuplot2.py

@@ -0,0 +1,666 b''
+# -*- 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 <[e-mail]>
+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> ************************

IPython/GnuplotInteractive.py

@@ -0,0 +1,148 b''
+# -*- 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> *******************

IPython/GnuplotRuntime.py

@@ -0,0 +1,147 b''
+# -*- 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> ******************

IPython/Itpl.py

@@ -0,0 +1,284 b''
+# -*- 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 <[e-mail]>
+#
+#
+# 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 <[e-mail]>'
+__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

IPython/Logger.py

@@ -0,0 +1,270 b''
+# -*- 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 <[e-mail]> and
+#       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+#****************************************************************************
+# Modules and globals
+
+from IPython import Release
+__author__  = '%s <%s>\n%s <%s>' % \
+              ( Release.authors['Janko'] + Release.authors['Fernando'] )
+__license__ = Release.license
+
+# Python standard modules
+import 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