Reorganized the directory for ipython/ to have its own dir, which is a bit

more consistent with the SVN book recommended layout.

IPython/ColorANSI.py

@@ -0,0 +1,155 b''
+# -*- coding: utf-8 -*-
+"""Tools for coloring text in ANSI terminals.
+
+$Id: ColorANSI.py 410 2004-11-04 07:58:17Z 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.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+__all__ = ['TermColors','InputTermColors','ColorScheme','ColorSchemeTable']
+
+import os
+from UserDict import UserDict
+
+from IPython.Struct 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.
+    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)
+        
+class ColorSchemeTable(UserDict):
+    """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.
+        """
+        
+        UserDict.__init__(self)
+        if scheme_list is None:
+            self.active_scheme_name = ''
+            self.active_colors = None
+        else:
+            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 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_list = self.keys()
+        if case_sensitive:
+            valid_schemes = scheme_list
+            scheme_test = scheme
+        else:
+            valid_schemes = [s.lower() for s in scheme_list]
+            scheme_test = scheme.lower()
+        try:
+            scheme_idx = valid_schemes.index(scheme_test)
+        except ValueError:
+            raise ValueError,'Unrecognized color scheme: ' + scheme + \
+                  '\nValid schemes: '+str(scheme_list).replace("'', ",'')
+        else:
+            active = scheme_list[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 525 2005-02-19 10:53:12Z fperez $"""
+
+#*****************************************************************************
+#       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
+
+import os
+from pprint import pprint
+import exceptions
+
+from IPython import ultraTB
+from IPython.Struct 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,109 b''
+# -*- coding: utf-8 -*-
+"""sys.excepthook for IPython itself, leaves a detailed report on disk.
+
+$Id: CrashHandler.py 410 2004-11-04 07:58:17Z fperez $"""
+
+#*****************************************************************************
+#       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
+__version__ = Release.version
+
+#****************************************************************************
+# Required modules
+
+# From the standard library
+import os,sys
+from pprint import pprint,pformat
+
+# Homebrewed
+from IPython.genutils import *
+from IPython.Itpl import Itpl,itpl,printpl
+from IPython import ultraTB
+from IPython.ultraTB import ColorScheme,ColorSchemeTable  # too long names
+
+#****************************************************************************
+class CrashHandler:
+    """sys.excepthook for IPython itself, leaves a detailed report on disk."""
+
+    def __init__(self,IP):
+        self.IP = IP  # IPython instance
+        self.bug_contact = Release.authors['Fernando'][0]
+        self.mailto = Release.authors['Fernando'][1]
+
+    def __call__(self,etype, evalue, etb):
+
+        # 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()
+        self.report_name = os.path.join(rptdir,'IPython_crash_report.txt')
+        self.TBhandler = ultraTB.VerboseTB(color_scheme=color_scheme,long_header=1)
+        traceback = self.TBhandler.text(etype,evalue,etb,context=31)
+
+        # print traceback to screen
+        print >> sys.stderr, traceback
+
+        # and generate a complete report on disk
+        try:
+            report = open(self.report_name,'w')
+        except:
+            print >> sys.stderr, 'Could not create crash report on disk.'
+            return
+
+        msg = itpl('\n'+'*'*70+'\n'
+"""
+Oops, IPython 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 traceback above this text.
+  - A copy of your input history during this session.
+  - Data on your current IPython configuration.
+
+It was left in the file named:
+\t'$self.report_name'
+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.bug_contact at $self.mailto
+with the subject 'IPython Crash Report'.
+
+If you want to do it now, the following command will work (under Unix):
+mail -s 'IPython Crash Report' $self.mailto < $self.report_name
+
+To ensure accurate tracking of this issue, please file a report about it at:
+http://www.scipy.net/roundup/ipython  (IPython's online bug tracker).
+""")
+        print >> sys.stderr, msg
+
+        sec_sep = '\n\n'+'*'*75+'\n\n'
+        report.write('*'*75+'\n\n'+'IPython post-mortem report\n\n')
+        report.write('IPython version: %s \n\n' % __version__)
+        report.write('Platform info  : os.name -> %s, sys.platform -> %s' %
+                     (os.name,sys.platform) )
+        report.write(sec_sep+'Current user configuration structure:\n\n')
+        report.write(pformat(self.IP.rc.dict()))
+        report.write(sec_sep+'Crash traceback:\n\n' + traceback)
+        try:
+            report.write(sec_sep+"History of session input:")
+            for line in self.IP.user_ns['_ih']:
+                report.write(line)
+            report.write('\n*** Last line of input (may not be in above history):\n')
+            report.write(self.IP._last_input_line+'\n')
+        except:
+            pass
+        report.close()

IPython/DPyGetOpt.py

@@ -0,0 +1,671 b''
+# -*- coding: utf-8 -*-
+"""DPyGetOpt -- Demiurge Python GetOptions Module
+
+ $Id: DPyGetOpt.py 389 2004-10-09 07:59:30Z 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 389 2004-10-09 07:59:30Z 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 string
+import re
+import sys
+import types
+
+arg_error  = 'DPyGetOpt Argument Error'
+spec_error = 'DPyGetOpt Specification Error'
+term_error = 'DPyGetOpt Termination Error'
+
+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 spec_error 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 spec_error, 'Alias \'' + name + '\' for \'' + realName + \
+						'\' already used for another option or alias.'
+			else:
+				raise spec_error, '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 spec_error, 'Negated alias \'' + name + '\' for \'' + realName + \
+							'\' already used for another option or alias.'
+				else:
+					raise spec_error, '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 spec_error, '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 spec_error, 'Invalid configuration for option \'' + option + '\''
+
+				# determine mode
+				required = match.group('required')
+				if required == '=':
+					argMode = ArgRequired
+				elif required == ':':
+					argMode = ArgOptional
+				else:
+					raise spec_error, '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 spec_error, '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 term_error 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 term_error, '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 arg_error, 'Illegal option \'' + arg + '\''
+			elif len(tuples) > 1:
+				raise arg_error, '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 arg_error, '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 arg_error, 'Invalid argument to option \'' + arg + \
+									'\';  should be \'' + optType + '\''
+						else:
+							optionValue = optDefault
+				except arg_error:
+					raise arg_error, sys.exc_value
+				except:
+					raise arg_error, '(' + 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 arg_error, '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:
+		print 'EXCEPTION (should be \'foo\' already used..): ' + sys.exc_value
+
+	try:
+		DPyGetOpt(['foo|bar|apple=s@', 'baz|apple!'])
+	except:
+		print 'EXCEPTION (should be duplicate alias/name error): ' + sys.exc_value
+
+	x = DPyGetOpt(['apple|atlas=i@', 'application|executable=f@'])
+	try:
+		x.processArguments(['-app', '29.3'])
+	except:
+		print 'EXCEPTION (should be ambiguous argument): ' +	sys.exc_value
+
+	x = DPyGetOpt(['foo'], ['antigravity', 'antithesis'])
+	try:
+		x.processArguments(['-foo', 'anti'])
+	except:
+		print 'EXCEPTION (should be ambiguous terminator): ' + sys.exc_value
+
+	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,53 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 590 2005-05-30 06:26:51Z fperez $"""
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = 'Python'
+
+import pdb,bdb,cmd,os,sys
+
+class Pdb(pdb.Pdb):
+    """Modified Pdb class, does not load readline."""
+    def __init__(self):
+        bdb.Bdb.__init__(self)
+        cmd.Cmd.__init__(self,completekey=None) # don't load readline
+        self.prompt = '(Pdb) '
+        self.aliases = {}
+
+        # Read $HOME/.pdbrc and ./.pdbrc
+        self.rcLines = []
+        if os.environ.has_key('HOME'):
+            envHome = os.environ['HOME']
+            try:
+                rcFile = open(os.path.join(envHome, ".pdbrc"))
+            except IOError:
+                pass
+            else:
+                for line in rcFile.readlines():
+                    self.rcLines.append(line)
+                rcFile.close()
+        try:
+            rcFile = open(".pdbrc")
+        except IOError:
+            pass
+        else:
+            for line in rcFile.readlines():
+                self.rcLines.append(line)
+            rcFile.close()

IPython/Extensions/InterpreterExec.py

@@ -0,0 +1,270 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 573 2005-04-08 08:38:09Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2004 W.J. van der Laan <[e-mail]>
+#       Copyright (C) 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__ = 'W.J. van der Laan <[e-mail]>, '\
+             '%s <%s>' %  Release.authors['Fernando']
+__license__ = Release.license
+
+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.
+
+print """\
+Welcome to pysh, a set of extensions to IPython for shell usage.
+help(pysh) -> help on the installed shell extensions and syntax.
+"""
+
+#  Set the 'cd' command to quiet mode, a more shell-like behavior
+__IPYTHON__.default_option('cd','-q')
+
+# Load all of $PATH as aliases
+if os.name == 'posix':
+    # %rehash is very fast, but it doesn't check for executability, it simply
+    # dumps everything in $PATH as an alias. Use rehashx if you want more
+    # checks.
+    __IPYTHON__.magic_rehash()
+else:
+    # Windows users: the list of extensions considered executable is read from
+    # the environment variable 'pathext'.  If this is undefined, IPython
+    # defaults to EXE, COM and BAT.
+    # %rehashx is the one which does extension analysis, at the cost of
+    # being much slower than %rehash.
+    __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*)([\?\w\.\-\+]+\w*\s*)(\(?.*$)')
+
+# Namespace cleanup
+del re

IPython/Extensions/InterpreterPasteInput.py

@@ -0,0 +1,91 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.
+"""
+#*****************************************************************************
+#       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_paste(self,line,continuation):
+    """Alternate prefilter for input of pasted code from an interpreter.
+    """
+
+    from re import match
+
+    if match(r'^>>> |^\.\.\. ',line):
+        # 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[4:],continuation)
+    elif line.strip() == '...':
+        return self._prefilter('',continuation)
+    else:
+        return self._prefilter(line,continuation)
+            
+# Rebind this to be the new IPython prefilter:
+from IPython.iplib import InteractiveShell
+InteractiveShell.prefilter = prefilter_paste
+
+# Clean up the namespace.
+del InteractiveShell,prefilter_paste
+
+# Just a heads up at the console
+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/numeric_formats.py

@@ -0,0 +1,41 b''
+# -*- coding: utf-8 -*-
+"""
+Extension for printing Numeric Arrays in flexible ways.
+"""
+
+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/FakeModule.py

@@ -0,0 +1,48 b''
+# -*- coding: utf-8 -*-
+"""
+Class which mimics a module.
+
+Needed to allow pickle to correctly resolve namespaces during IPython
+sessions.
+
+$Id: FakeModule.py 410 2004-11-04 07:58:17Z 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.
+#*****************************************************************************
+
+class FakeModule:
+    """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):
+
+        # It seems pydoc (and perhaps others) needs any module instance to
+        # implement a __nonzero__ method, so we add it if missing:
+        if '__nonzero__' not in adict:
+            def __nonzero__():
+                return 1
+            adict['__nonzero__'] = __nonzero__
+
+            self.__dict__ = adict
+
+    def __getattr__(self,key):
+        try:
+            return self.__dict__[key]
+        except KeyError, e:
+            raise AttributeError("FakeModule object has no attribute %s" % e)
+
+    def __str__(self):
+        return "<IPython.FakeModule instance>"
+
+    def __repr__(self):
+        return str(self)

IPython/FlexCompleter.py

@@ -0,0 +1,198 b''
+# -*- coding: utf-8 -*-
+"""Word completion for GNU readline 2.0.
+
+---------------------------------------------------------------------------
+NOTE: This version is a re-implementation of rlcompleter with selectable
+namespace.
+
+The problem with rlcompleter is that it's hardwired to work with
+__main__.__dict__, and in some cases one may have 'sandboxed' namespaces. So
+this class is a ripoff of rlcompleter, with the namespace to work in as an
+optional parameter.
+
+This class can be used just like rlcompleter, but the Completer class now has
+a constructor with the optional 'namespace' parameter.
+
+A patch has been submitted to Python@sourceforge for these changes to go in
+the standard Python distribution.
+
+The patch went in for Python 2.3.  Once IPython drops support for Python 2.2,
+this file can be significantly reduced.
+---------------------------------------------------------------------------
+
+Original rlcompleter documentation:
+
+This requires the latest extension to the readline module (the
+completes keywords, built-ins and globals in __main__; when completing
+NAME.NAME..., it evaluates (!) the expression up to the last dot and
+completes its attributes.
+
+It's very cool to do "import string" type "string.", hit the
+completion key (twice), and see the list of names defined by the
+string module!
+
+Tip: to use the tab key as the completion key, call
+
+    readline.parse_and_bind("tab: complete")
+
+Notes:
+
+- Exceptions raised by the completer function are *ignored* (and
+generally cause the completion to fail).  This is a feature -- since
+readline sets the tty device in raw (or cbreak) mode, printing a
+traceback wouldn't work well without some complicated hoopla to save,
+reset and restore the tty state.
+
+- The evaluation of the NAME.NAME... form may cause arbitrary
+application defined code to be executed if an object with a
+__getattr__ hook is found.  Since it is the responsibility of the
+application (or the user) to enable this feature, I consider this an
+acceptable risk.  More complicated expressions (e.g. function calls or
+indexing operations) are *not* evaluated.
+
+- GNU readline is also used by the built-in functions input() and
+raw_input(), and thus these also benefit/suffer from the completer
+features.  Clearly an interactive application can benefit by
+specifying its own completer function and using raw_input() for all
+its input.
+
+- When the original stdin is not a tty device, GNU readline is never
+used, and this module (and the readline module) are silently inactive.
+
+"""
+
+#*****************************************************************************
+#
+# Since this file is essentially a minimally modified copy of the rlcompleter
+# module which is part of the standard Python distribution, I assume that the
+# proper procedure is to maintain its copyright as belonging to the Python
+# Software Foundation:
+#
+#       Copyright (C) 2001 Python Software Foundation, www.python.org
+#
+#  Distributed under the terms of the Python Software Foundation license.
+#
+#  Full text available at:
+#
+#                  http://www.python.org/2.1/license.html
+#
+#*****************************************************************************
+
+import readline
+import __builtin__
+import __main__
+
+__all__ = ["Completer"]
+
+class Completer:
+    def __init__(self, namespace = None):
+        """Create a new completer for the command line.
+
+        Completer([namespace]) -> completer instance.
+
+        If unspecified, the default namespace where completions are performed
+        is __main__ (technically, __main__.__dict__). Namespaces should be
+        given as dictionaries.
+
+        Completer instances should be used as the completion mechanism of
+        readline via the set_completer() call:
+
+        readline.set_completer(Completer(my_namespace).complete)
+        """
+        
+        if namespace and type(namespace) != type({}):
+            raise TypeError,'namespace must be a dictionary'
+
+        # Don't bind to namespace quite yet, but flag whether the user wants a
+        # specific namespace or to use __main__.__dict__. This will allow us
+        # to bind to __main__.__dict__ at completion time, not now.
+        if namespace is None:
+            self.use_main_ns = 1
+        else:
+            self.use_main_ns = 0
+            self.namespace = namespace
+
+    def complete(self, text, state):
+        """Return the next possible completion for 'text'.
+
+        This is called successively with state == 0, 1, 2, ... until it
+        returns None.  The completion should begin with 'text'.
+
+        """
+        if self.use_main_ns:
+            self.namespace = __main__.__dict__
+            
+        if state == 0:
+            if "." in text:
+                self.matches = self.attr_matches(text)
+            else:
+                self.matches = self.global_matches(text)
+        try:
+            return self.matches[state]
+        except IndexError:
+            return None
+
+    def global_matches(self, text):
+        """Compute matches when text is a simple name.
+
+        Return a list of all keywords, built-in functions and names currently
+        defined in self.namespace that match.
+
+        """
+        import keyword
+        matches = []
+        n = len(text)
+        for list in [keyword.kwlist,
+                     __builtin__.__dict__.keys(),
+                     self.namespace.keys()]:
+            for word in list:
+                if word[:n] == text and word != "__builtins__":
+                    matches.append(word)
+        return matches
+
+    def attr_matches(self, text):
+        """Compute matches when text contains a dot.
+
+        Assuming the text is of the form NAME.NAME....[NAME], and is
+        evaluatable in self.namespace, it will be evaluated and its attributes
+        (as revealed by dir()) are used as possible completions.  (For class
+        instances, class members are are also considered.)
+
+        WARNING: this can still invoke arbitrary C code, if an object
+        with a __getattr__ hook is evaluated.
+
+        """
+        import re
+
+        # Another option, seems to work great. Catches things like ''.<tab>
+        m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
+
+        if not m:
+            return []
+        expr, attr = m.group(1, 3)
+        object = eval(expr, self.namespace)
+        words = dir(object)
+        if hasattr(object,'__class__'):
+            words.append('__class__')
+            words.extend(get_class_members(object.__class__))
+        n = len(attr)
+        matches = []
+        for word in words:
+            try:
+                if word[:n] == attr and word != "__builtins__":
+                    matches.append("%s.%s" % (expr, word))
+            except:
+                # some badly behaved objects pollute dir() with non-strings,
+                # which cause the completion to fail.  This way we skip the
+                # bad entries and can still continue processing the others.
+                pass
+        return matches
+
+def get_class_members(klass):
+    ret = dir(klass)
+    if hasattr(klass,'__bases__'):
+        for base in klass.__bases__:
+            ret.extend(get_class_members(base))
+    return ret
+
+readline.set_completer(Completer().complete)

IPython/Gnuplot2.py

@@ -0,0 +1,655 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 392 2004-10-09 22:01:51Z fperez $"""
+
+import string,os,time,types
+import cStringIO
+import sys
+import tempfile
+import Numeric
+import Gnuplot as Gnuplot_ori
+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
+
+else:  # Gnuplot.py version 1.7 and greater
+    _FileClass = _BaseFileItem = PlotItems._FileItem
+    _BaseTempFileItem = PlotItems._TempFileItem
+    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,253 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 542 2005-03-18 09:16:04Z fperez $
+"""                   # ' -> 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 sys, string
+from types import StringType
+from tokenize import tokenprog
+
+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):
+        """The single 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."""
+
+        if type(format) != StringType:
+            raise TypeError, "needs string initializer"
+        self.format = format
+
+        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):
+        """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
+
+        result = []
+        for live, chunk in self.chunks:
+            if live: result.append(str(eval(chunk,glob,loc)))
+            else: result.append(chunk)
+
+        return ''.join(result)
+
+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):
+        """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)
+        
+    def __str__(self):
+        """Evaluate and substitute the appropriate parts of the string."""
+        glob = self.globals
+        loc = self.locals
+        result = []
+        for live, chunk in self.chunks:
+            if live: result.append(str(eval(chunk,glob,loc)))
+            else: result.append(chunk)
+        return ''.join(result)
+
+# 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,185 b''
+# -*- coding: utf-8 -*-
+"""
+Logger class for IPython's logging facilities.
+
+$Id: Logger.py 430 2004-11-30 08:52:05Z fperez $
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2001 Janko Hauser <[e-mail]> and
+#       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.
+#*****************************************************************************
+
+#****************************************************************************
+# 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 os,sys,glob
+
+# Homebrewed
+from IPython.genutils import *
+
+#****************************************************************************
+# FIXME: The logger class shouldn't be a mixin, it throws too many things into
+# the InteractiveShell namespace. Rather make it a standalone tool, and create
+# a Logger instance in InteractiveShell that uses it. Doing this will require
+# tracking down a *lot* of nasty uses of the Logger attributes in
+# InteractiveShell, but will clean up things quite a bit.
+
+class Logger:
+    """A Logfile Mixin class with different policies for file creation"""
+
+    # FIXME: once this isn't a mixin, log_ns should just be 'namespace', since the
+    # names won't collide anymore.
+    def __init__(self,log_ns):
+        self._i00,self._i,self._ii,self._iii = '','','',''
+        self.do_full_cache = 0 # FIXME. There's also a do_full.. in OutputCache
+        self.log_ns = log_ns
+        # defaults
+        self.LOGMODE = 'backup'
+        self.defname = 'logfile'
+        
+    def create_log(self,header='',fname='',defname='.Logger.log'):
+        """Generate a new log-file with a default header"""
+        if fname:
+            self.LOG = fname
+
+        if self.LOG:
+            self.logfname = self.LOG
+        else:
+            self.logfname = defname
+        
+        if self.LOGMODE == 'over':
+            if os.path.isfile(self.logfname):
+                os.remove(self.logfname) 
+            self.logfile = open(self.logfname,'w')
+        if self.LOGMODE == 'backup':
+            if os.path.isfile(self.logfname):
+                backup_logname = self.logfname+'~'
+                # Manually remove any old backup, since os.rename may fail
+                # under Windows.
+                if os.path.isfile(backup_logname):
+                    os.remove(backup_logname)
+                os.rename(self.logfname,backup_logname)
+            self.logfile = open(self.logfname,'w')
+        elif self.LOGMODE == 'global':
+            self.logfname = os.path.join(self.home_dir, self.defname)
+            self.logfile = open(self.logfname, 'a')
+            self.LOG = self.logfname
+        elif self.LOGMODE == 'rotate':
+            if os.path.isfile(self.logfname):
+                if os.path.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')
+        elif self.LOGMODE == 'append':
+            self.logfile = open(self.logfname,'a')
+            
+        if self.LOGMODE != 'append':
+            self.logfile.write(header)
+        self.logfile.flush()
+
+    def logstart(self, header='',parameter_s = ''):
+        if not hasattr(self, 'LOG'):
+            logfname = self.LOG or parameter_s or './'+self.defname
+            self.create_log(header,logfname)
+        elif parameter_s and hasattr(self,'logfname') and \
+             parameter_s != self.logfname:
+            self.close_log()
+            self.create_log(header,parameter_s)
+            
+        self._dolog = 1
+
+    def switch_log(self,val):
+        """Switch logging on/off. val should be ONLY 0 or 1."""
+
+        if not val in [0,1]:
+            raise ValueError, \
+                  'Call switch_log ONLY with 0 or 1 as argument, not with:',val
+        
+        label = {0:'OFF',1:'ON'}
+
+        try:
+            _ = self.logfile
+        except AttributeError:
+            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._dolog == val:
+                print 'Logging is already',label[val]
+            else:
+                print 'Switching logging',label[val]
+                self._dolog = 1 - self._dolog
+
+    def logstate(self):
+        """Print a status message about the logger."""
+        try:
+            logfile = self.logfname
+        except:
+            print 'Logging has not been activated.'
+        else:
+            state = self._dolog and 'active' or 'temporarily suspended'
+            print """
+File:\t%s
+Mode:\t%s
+State:\t%s """ % (logfile,self.LOGMODE,state)
+
+        
+    def log(self, line,continuation=None):
+        """Write the line to a log and create input cache variables _i*."""
+
+        # update the auto _i tables
+        #print '***logging line',line # dbg
+        #print '***cache_count', self.outputcache.prompt_count # dbg
+        input_hist = self.log_ns['_ih']
+        if not continuation and line:
+            self._iii = self._ii
+            self._ii = self._i
+            self._i = self._i00
+            # put back the final \n of every input line
+            self._i00 = line+'\n'
+            #print 'Logging input:<%s>' % line  # dbg
+            input_hist.append(self._i00)
+
+        # hackish access to top-level namespace to create _i1,_i2... dynamically
+        to_main = {'_i':self._i,'_ii':self._ii,'_iii':self._iii}
+        if self.do_full_cache:
+            in_num = self.outputcache.prompt_count
+            # add blank lines if the input cache fell out of sync. This can happen
+            # for embedded instances which get killed via C-D and then get resumed.
+            while in_num >= len(input_hist):
+                input_hist.append('\n')
+            new_i = '_i%s' % in_num
+            if continuation:
+                self._i00 = '%s%s\n' % (self.log_ns[new_i],line)
+                input_hist[in_num] = self._i00
+            to_main[new_i] = self._i00
+        self.log_ns.update(to_main)
+        
+        if self._dolog and line:
+            self.logfile.write(line+'\n')
+            self.logfile.flush()
+
+    def close_log(self):
+        if hasattr(self, 'logfile'):
+            self.logfile.close()
+            self.logfname = ''

IPython/Magic.py

@@ -0,0 +1,2490 b''
+# -*- coding: utf-8 -*-
+"""Magic functions for InteractiveShell.
+
+$Id: Magic.py 583 2005-05-13 21:20:33Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001 Janko Hauser <[e-mail]> and
+#       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.
+#*****************************************************************************
+
+#****************************************************************************
+# Modules and globals
+
+from IPython import Release
+__author__  = '%s <%s>\n%s <%s>' % \
+              ( Release.authors['Janko'] + Release.authors['Fernando'] )
+__license__ = Release.license
+
+# Python standard modules
+import __builtin__
+import os,sys,inspect,pydoc,re,tempfile,shlex,pdb,bdb,time
+try:
+    import profile,pstats
+except ImportError:
+    profile = pstats = None
+from getopt import getopt
+from pprint import pprint, pformat
+from cStringIO import StringIO
+
+# Homebrewed
+from IPython.Struct import Struct
+from IPython.Itpl import Itpl, itpl, printpl,itplns
+from IPython.FakeModule import FakeModule
+from IPython import OInspect
+from IPython.genutils import *
+
+# Globals to be set later by Magic constructor
+MAGIC_PREFIX = ''
+MAGIC_ESCAPE = ''
+
+#***************************************************************************
+# Utility functions
+def magic2python(cmd):
+    """Convert a command string of magic syntax to valid Python code."""
+
+    if cmd.startswith('#'+MAGIC_ESCAPE) or \
+           cmd.startswith(MAGIC_ESCAPE):
+        if cmd[0]=='#':
+            cmd = cmd[1:]
+        # we need to return the proper line end later
+        if cmd[-1] == '\n':
+            endl = '\n'
+        else:
+            endl = ''
+        try:
+            func,args = cmd[1:].split(' ',1)
+        except:
+            func,args = cmd[1:].rstrip(),''
+        args = args.replace('"','\\"').replace("'","\\'").rstrip()
+        return '%s%s ("%s")%s' % (MAGIC_PREFIX,func,args,endl)
+    else:
+        return cmd
+
+def on_off(tag):
+    """Return an ON/OFF string for a 1/0 input. Simple utility function."""
+    return ['OFF','ON'][tag]
+
+def get_py_filename(name):
+    """Return a valid python filename in the current directory.
+
+    If the given name is not a file, it adds '.py' and searches again.
+    Raises IOError with an informative message if the file isn't found."""
+
+    name = os.path.expanduser(name)
+    if not os.path.isfile(name) and not name.endswith('.py'):
+        name += '.py'
+    if os.path.isfile(name):
+        return name
+    else:
+        raise IOError,'File `%s` not found.' % name
+
+# Try to use shlex.split for converting an input string into a sys.argv-type
+# list.  This appeared in Python 2.3, so here's a quick backport for 2.2.
+try:
+    shlex_split = shlex.split
+except AttributeError:
+    _quotesre = re.compile(r'[\'"](.*)[\'"]')
+    _wordchars = ('abcdfeghijklmnopqrstuvwxyz'
+                  'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-.~*?'
+                  'ßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ'
+                  'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ%s'
+                  % os.sep)
+    
+    def shlex_split(s):
+        """Simplified backport to Python 2.2 of shlex.split().
+
+        This is a quick and dirty hack, since the shlex module under 2.2 lacks
+        several of the features needed to really match the functionality of
+        shlex.split() in 2.3."""
+
+        lex = shlex.shlex(StringIO(s))
+        # Try to get options, extensions and path separators as characters
+        lex.wordchars = _wordchars
+        lex.commenters = ''
+        # Make a list out of the lexer by hand, since in 2.2 it's not an
+        # iterator.
+        lout = []
+        while 1:
+            token = lex.get_token()
+            if token == '':
+                break
+            # Try to handle quoted tokens correctly
+            quotes = _quotesre.match(token)
+            if quotes:
+                token = quotes.group(1)
+            lout.append(token)
+        return lout
+
+#****************************************************************************
+# Utility classes
+class Macro:
+    """Simple class to store the value of macros as strings.
+
+    This allows us to later exec them by checking when something is an
+    instance of this class."""
+    
+    def __init__(self,cmds):
+        """Build a macro from a list of commands."""
+
+        # Since the list may include multi-line entries, first make sure that
+        # they've been all broken up before passing it to magic2python
+        cmdlist = map(magic2python,''.join(cmds).split('\n'))
+        self.value = '\n'.join(cmdlist)
+
+    def __str__(self):
+        return self.value
+
+#***************************************************************************
+# Main class implementing Magic functionality
+class Magic:
+    """Magic functions for InteractiveShell.
+
+    Shell functions which can be reached as %function_name. All magic
+    functions should accept a string, which they can parse for their own
+    needs. This can make some functions easier to type, eg `%cd ../`
+    vs. `%cd("../")`
+
+    ALL definitions MUST begin with the prefix magic_. The user won't need it
+    at the command line, but it is is needed in the definition. """
+
+    # class globals
+    auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
+                   'Automagic is ON, % prefix NOT needed for magic functions.']
+
+    #......................................................................
+    # some utility functions
+
+    def __init__(self,shell):
+        # XXX This is hackish, clean up later to avoid these messy globals
+        global MAGIC_PREFIX, MAGIC_ESCAPE
+        
+        self.options_table = {}
+        MAGIC_PREFIX = shell.name+'.magic_'
+        MAGIC_ESCAPE = shell.ESC_MAGIC
+        if profile is None:
+            self.magic_prun = self.profile_missing_notice
+
+    def profile_missing_notice(self, *args, **kwargs):
+        error("""\
+The profile module could not be found.  If you are a Debian user,
+it has been removed from the standard Debian package because of its non-free
+license. To use profiling, please install"python2.3-profiler" from non-free.""")
+    
+    def default_option(self,fn,optstr):
+        """Make an entry in the options_table for fn, with value optstr"""
+        
+        if fn not in self.lsmagic():
+            error("%s is not a magic function" % fn)
+        self.options_table[fn] = optstr
+
+    def lsmagic(self):
+        """Return a list of currently available magic functions.
+
+        Gives a list of the bare names after mangling (['ls','cd', ...], not
+        ['magic_ls','magic_cd',...]"""
+
+        # FIXME. This needs a cleanup, in the way the magics list is built.
+        
+        # magics in class definition
+        class_magic = lambda fn: fn.startswith('magic_') and \
+                      callable(Magic.__dict__[fn])
+        # in instance namespace (run-time user additions)
+        inst_magic =  lambda fn: fn.startswith('magic_') and \
+                     callable(self.__dict__[fn])
+        # and bound magics by user (so they can access self):
+        inst_bound_magic =  lambda fn: fn.startswith('magic_') and \
+                           callable(self.__class__.__dict__[fn])
+        magics = filter(class_magic,Magic.__dict__.keys()) + \
+                 filter(inst_magic,self.__dict__.keys()) + \
+                 filter(inst_bound_magic,self.__class__.__dict__.keys())
+        out = []
+        for fn in magics:
+            out.append(fn.replace('magic_','',1))
+        out.sort()
+        return out
+    
+    def set_shell(self,shell):
+        self.shell = shell
+        self.alias_table = shell.alias_table
+
+    def extract_input_slices(self,slices):
+        """Return as a string a set of input history slices.
+
+        The set of slices is given as a list of strings (like ['1','4:8','9'],
+        since this function is for use by magic functions which get their
+        arguments as strings."""
+
+        cmds = []
+        for chunk in slices:
+            if ':' in chunk:
+                ini,fin = map(int,chunk.split(':'))
+            else:
+                ini = int(chunk)
+                fin = ini+1
+            cmds.append(self.shell.input_hist[ini:fin])
+        return cmds
+        
+    def _ofind(self,oname):
+        """Find an object in the available namespaces.
+
+        self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
+
+        Has special code to detect magic functions.
+        """
+        
+        oname = oname.strip()
+
+        # Namespaces to search in:
+        user_ns        = self.shell.user_ns
+        internal_ns    = self.shell.internal_ns
+        builtin_ns     = __builtin__.__dict__
+        alias_ns       = self.shell.alias_table
+
+        # Put them in a list. The order is important so that we find things in
+        # the same order that Python finds them.
+        namespaces = [ ('Interactive',user_ns),
+                       ('IPython internal',internal_ns),
+                       ('Python builtin',builtin_ns),
+                       ('Alias',alias_ns),
+                       ]
+
+        # initialize results to 'null'
+        found = 0; obj = None;  ospace = None;  ds = None;
+        ismagic = 0; isalias = 0
+
+        # Look for the given name by splitting it in parts.  If the head is
+        # found, then we look for all the remaining parts as members, and only
+        # declare success if we can find them all.
+        oname_parts = oname.split('.')
+        oname_head, oname_rest = oname_parts[0],oname_parts[1:]
+        for nsname,ns in namespaces:
+            try:
+                obj = ns[oname_head]
+            except KeyError:
+                continue
+            else:
+                for part in oname_rest:
+                    try:
+                        obj = getattr(obj,part)
+                    except:
+                        # Blanket except b/c some badly implemented objects
+                        # allow __getattr__ to raise exceptions other than
+                        # AttributeError, which then crashes IPython.
+                        break
+                else:
+                    # If we finish the for loop (no break), we got all members
+                    found = 1
+                    ospace = nsname
+                    if ns == alias_ns:
+                        isalias = 1
+                    break  # namespace loop
+
+        # Try to see if it's magic
+        if not found:
+            if oname.startswith(self.shell.ESC_MAGIC):
+                oname = oname[1:]
+            obj = getattr(self,'magic_'+oname,None)
+            if obj is not None:
+                found = 1
+                ospace = 'IPython internal'
+                ismagic = 1
+
+        # Last try: special-case some literals like '', [], {}, etc:
+        if not found and oname_head in ["''",'""','[]','{}','()']:
+            obj = eval(oname_head)
+            found = 1
+            ospace = 'Interactive'
+            
+        return {'found':found, 'obj':obj, 'namespace':ospace,
+                'ismagic':ismagic, 'isalias':isalias}
+        
+    def arg_err(self,func):
+        """Print docstring if incorrect arguments were passed"""
+        print 'Error in arguments:'
+        print OInspect.getdoc(func)
+
+
+    def format_latex(self,str):
+        """Format a string for latex inclusion."""
+
+        # Characters that need to be escaped for latex:
+        escape_re = re.compile(r'(%|_|\$)',re.MULTILINE)
+        # Magic command names as headers:
+        cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
+                                 re.MULTILINE)
+        # Magic commands 
+        cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
+                            re.MULTILINE)
+        # Paragraph continue
+        par_re = re.compile(r'\\$',re.MULTILINE)
+
+        str = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',str)
+        str = cmd_re.sub(r'\\texttt{\g<cmd>}',str)
+        str = par_re.sub(r'\\\\',str)
+        str = escape_re.sub(r'\\\1',str)
+        return str
+
+    def format_screen(self,str):
+        """Format a string for screen printing.
+
+        This removes some latex-type format codes."""
+        # Paragraph continue
+        par_re = re.compile(r'\\$',re.MULTILINE)
+        str = par_re.sub('',str)
+        return str
+
+    def parse_options(self,arg_str,opt_str,*long_opts,**kw):
+        """Parse options passed to an argument string.
+
+        The interface is similar to that of getopt(), but it returns back a
+        Struct with the options as keys and the stripped argument string still
+        as a string.
+
+        arg_str is quoted as a true sys.argv vector by calling on the fly a
+        python process in a subshell.  This allows us to easily expand
+        variables, glob files, quote arguments, etc, with all the power and
+        correctness of the underlying system shell.
+
+        Options:
+          -mode: default 'string'. If given as 'list', the argument string is
+          returned as a list (split on whitespace) instead of a string.
+
+          -list_all: put all option values in lists. Normally only options
+          appearing more than once are put in a list."""
+
+        # inject default options at the beginning of the input line
+        caller = sys._getframe(1).f_code.co_name.replace('magic_','')
+        arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
+        
+        mode = kw.get('mode','string')
+        if mode not in ['string','list']:
+            raise ValueError,'incorrect mode given: %s' % mode
+        # Get options
+        list_all = kw.get('list_all',0)
+
+        # Check if we have more than one argument to warrant extra processing:
+        odict = {}  # Dictionary with options
+        args = arg_str.split()
+        if len(args) >= 1:
+            # If the list of inputs only has 0 or 1 thing in it, there's no
+            # need to look for options
+            argv = shlex_split(arg_str)
+            # Do regular option processing
+            opts,args = getopt(argv,opt_str,*long_opts)
+            for o,a in opts:
+                if o.startswith('--'):
+                    o = o[2:]
+                else:
+                    o = o[1:]
+                try:
+                    odict[o].append(a)
+                except AttributeError:
+                    odict[o] = [odict[o],a]
+                except KeyError:
+                    if list_all:
+                        odict[o] = [a]
+                    else:
+                        odict[o] = a
+
+        # Prepare opts,args for return
+        opts = Struct(odict)
+        if mode == 'string':
+            args = ' '.join(args)
+
+        return opts,args
+    
+    #......................................................................
+    # And now the actual magic functions
+
+    # Functions for IPython shell work (vars,funcs, config, etc)
+    def magic_lsmagic(self, parameter_s = ''):
+        """List currently available magic functions."""
+        mesc = self.shell.ESC_MAGIC
+        print 'Available magic functions:\n'+mesc+\
+              ('  '+mesc).join(self.lsmagic())
+        print '\n' + Magic.auto_status[self.shell.rc.automagic]
+        return None
+        
+    def magic_magic(self, parameter_s = ''):
+        """Print information about the magic function system."""
+
+        mode = ''
+        try:
+            if parameter_s.split()[0] == '-latex':
+                mode = 'latex'
+        except:
+            pass
+
+        magic_docs = []
+        for fname in self.lsmagic():
+            mname = 'magic_' + fname
+            for space in (Magic,self,self.__class__):
+                try:
+                    fn = space.__dict__[mname]
+                except KeyError:
+                    pass
+                else:
+                    break
+            magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
+                                                fname,fn.__doc__))
+        magic_docs = ''.join(magic_docs)
+
+        if mode == 'latex':
+            print self.format_latex(magic_docs)
+            return
+        else:
+            magic_docs = self.format_screen(magic_docs)
+        
+        outmsg = """
+IPython's 'magic' functions
+===========================
+
+The magic function system provides a series of functions which allow you to
+control the behavior of IPython itself, plus a lot of system-type
+features. All these functions are prefixed with a % character, but parameters
+are given without parentheses or quotes.
+
+NOTE: If you have 'automagic' enabled (via the command line option or with the
+%automagic function), you don't need to type in the % explicitly.  By default,
+IPython ships with automagic on, so you should only rarely need the % escape.
+
+Example: typing '%cd mydir' (without the quotes) changes you working directory
+to 'mydir', if it exists.
+
+You can define your own magic functions to extend the system. See the supplied
+ipythonrc and example-magic.py files for details (in your ipython
+configuration directory, typically $HOME/.ipython/).
+
+You can also define your own aliased names for magic functions. In your
+ipythonrc file, placing a line like:
+
+  execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
+
+will define %pf as a new name for %profile.
+
+You can also call magics in code using the ipmagic() function, which IPython
+automatically adds to the builtin namespace.  Type 'ipmagic?' for details.
+
+For a list of the available magic functions, use %lsmagic. For a description
+of any of them, type %magic_name?, e.g. '%cd?'.
+
+Currently the magic system has the following functions:\n"""
+
+        mesc = self.shell.ESC_MAGIC
+        outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
+                  "\n\n%s%s\n\n%s" % (outmsg,
+                                     magic_docs,mesc,mesc,
+                                     ('  '+mesc).join(self.lsmagic()),
+                                     Magic.auto_status[self.shell.rc.automagic] ) )
+
+        page(outmsg,screen_lines=self.shell.rc.screen_length)
+  
+    def magic_automagic(self, parameter_s = ''):
+        """Make magic functions callable without having to type the initial %.
+        
+        Toggles on/off (when off, you must call it as %automagic, of
+        course). Note that magic functions have lowest priority, so if there's
+        a variable whose name collides with that of a magic fn, automagic
+        won't work for that function (you get the variable instead). However,
+        if you delete the variable (del var), the previously shadowed magic
+        function becomes visible to automagic again."""
+
+        rc = self.shell.rc
+        rc.automagic = not rc.automagic
+        print '\n' + Magic.auto_status[rc.automagic]
+
+    def magic_autocall(self, parameter_s = ''):
+        """Make functions callable without having to type parentheses.
+
+        This toggles the autocall command line option on and off."""
+        
+        rc = self.shell.rc
+        rc.autocall = not rc.autocall
+        print "Automatic calling is:",['OFF','ON'][rc.autocall]
+
+    def magic_autoindent(self, parameter_s = ''):
+        """Toggle autoindent on/off (if available)."""
+
+        self.shell.set_autoindent()
+        print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
+
+    def magic_system_verbose(self, parameter_s = ''):
+        """Toggle verbose printing of system calls on/off."""
+
+        self.shell.rc_set_toggle('system_verbose')
+        print "System verbose printing is:",\
+              ['OFF','ON'][self.shell.rc.system_verbose]
+
+    def magic_history(self, parameter_s = ''):
+        """Print input history (_i<n> variables), with most recent last.
+        
+        %history [-n]       -> print at most 40 inputs (some may be multi-line)\\
+        %history [-n] n     -> print at most n inputs\\
+        %history [-n] n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
+
+        Each input's number <n> is shown, and is accessible as the
+        automatically generated variable _i<n>.  Multi-line statements are
+        printed starting at a new line for easy copy/paste.
+
+        If option -n is used, input numbers are not printed. This is useful if
+        you want to get a printout of many lines which can be directly pasted
+        into a text editor.
+
+        This feature is only available if numbered prompts are in use."""
+
+        if not self.do_full_cache:
+            print 'This feature is only available if numbered prompts are in use.'
+            return
+        opts,args = self.parse_options(parameter_s,'n',mode='list')
+        
+        default_length = 40
+        if len(args) == 0:
+            final = self.outputcache.prompt_count
+            init = max(1,final-default_length)
+        elif len(args) == 1:
+            final = self.outputcache.prompt_count
+            init = max(1,final-int(args[0]))
+        elif len(args) == 2:
+            init,final = map(int,args)
+        else:
+            warn('%hist takes 0, 1 or 2 arguments separated by spaces.')
+            print self.magic_hist.__doc__
+            return
+        width = len(str(final))
+        line_sep = ['','\n']
+        input_hist = self.shell.input_hist
+        print_nums = not opts.has_key('n')
+        for in_num in range(init,final):
+            inline = input_hist[in_num]
+            multiline = inline.count('\n') > 1
+            if print_nums:
+                print str(in_num).ljust(width)+':'+ line_sep[multiline],
+            if inline.startswith('#'+self.shell.ESC_MAGIC) or \
+                   inline.startswith('#!'):
+                print inline[1:],
+            else:
+                print inline,
+
+    def magic_hist(self, parameter_s=''):
+        """Alternate name for %history."""
+        return self.magic_history(parameter_s)
+
+    def magic_p(self, parameter_s=''):
+        """Just a short alias for Python's 'print'."""
+        exec 'print ' + parameter_s in self.shell.user_ns
+
+    def magic_r(self, parameter_s=''):
+        """Repeat previous input.
+
+        If given an argument, repeats the previous command which starts with
+        the same string, otherwise it just repeats the previous input.
+
+        Shell escaped commands (with ! as first character) are not recognized
+        by this system, only pure python code and magic commands.
+        """
+
+        start = parameter_s.strip()
+        esc_magic = self.shell.ESC_MAGIC
+        # Identify magic commands even if automagic is on (which means
+        # the in-memory version is different from that typed by the user).
+        if self.shell.rc.automagic:
+            start_magic = esc_magic+start
+        else:
+            start_magic = start
+        # Look through the input history in reverse
+        for n in range(len(self.shell.input_hist)-2,0,-1):
+            input = self.shell.input_hist[n]
+            # skip plain 'r' lines so we don't recurse to infinity
+            if input != 'ipmagic("r")\n' and \
+                   (input.startswith(start) or input.startswith(start_magic)):
+                #print 'match',`input`  # dbg
+                if input.startswith(esc_magic):
+                    input = magic2python(input)
+                    #print 'modified',`input`  # dbg
+                print 'Executing:',input,
+                exec input in self.shell.user_ns
+                return
+        print 'No previous input matching `%s` found.' % start
+
+    def magic_page(self, parameter_s=''):
+        """Pretty print the object and display it through a pager.
+        
+        If no parameter is given, use _ (last output)."""
+        # After a function contributed by Olivier Aubert, slightly modified.
+
+        oname = parameter_s and parameter_s or '_' 
+        info = self._ofind(oname)
+        if info['found']:
+            page(pformat(info['obj']))
+        else:
+            print 'Object `%s` not found' % oname
+
+    def magic_profile(self, parameter_s=''):
+        """Print your currently active IPyhton profile."""
+        if self.shell.rc.profile:
+            printpl('Current IPython profile: $self.shell.rc.profile.')
+        else:
+            print 'No profile active.'
+        
+    def _inspect(self,meth,oname,**kw):
+        """Generic interface to the inspector system.
+
+        This function is meant to be called by pdef, pdoc & friends."""
+        
+        oname = oname.strip()
+        info = Struct(self._ofind(oname))
+        if info.found:
+            pmethod = getattr(self.shell.inspector,meth)
+            formatter = info.ismagic and self.format_screen or None
+            if meth == 'pdoc':
+                pmethod(info.obj,oname,formatter)
+            elif meth == 'pinfo':
+                pmethod(info.obj,oname,formatter,info,**kw)
+            else:
+                pmethod(info.obj,oname)
+        else:
+            print 'Object `%s` not found.' % oname
+            return 'not found'  # so callers can take other action
+        
+    def magic_pdef(self, parameter_s=''):
+        """Print the definition header for any callable object.
+
+        If the object is a class, print the constructor information."""
+        self._inspect('pdef',parameter_s)
+        
+    def magic_pdoc(self, parameter_s=''):
+        """Print the docstring for an object.
+
+        If the given object is a class, it will print both the class and the
+        constructor docstrings."""
+        self._inspect('pdoc',parameter_s)
+
+    def magic_psource(self, parameter_s=''):
+        """Print (or run through pager) the source code for an object."""
+        self._inspect('psource',parameter_s)
+
+    def magic_pfile(self, parameter_s=''):
+        """Print (or run through pager) the file where an object is defined.
+
+        The file opens at the line where the object definition begins. IPython
+        will honor the environment variable PAGER if set, and otherwise will
+        do its best to print the file in a convenient form.
+
+        If the given argument is not an object currently defined, IPython will
+        try to interpret it as a filename (automatically adding a .py extension
+        if needed). You can thus use %pfile as a syntax highlighting code
+        viewer."""
+
+        # first interpret argument as an object name
+        out = self._inspect('pfile',parameter_s)
+        # if not, try the input as a filename
+        if out == 'not found':
+            try:
+                filename = get_py_filename(parameter_s)
+            except IOError,msg:
+                print msg
+                return
+            page(self.shell.inspector.format(file(filename).read()))
+            
+    def magic_pinfo(self, parameter_s=''):
+        """Provide detailed information about an object.
+
+        '%pinfo object' is just a synonym for object? or ?object."""
+
+        #print 'pinfo par: <%s>' % parameter_s  # dbg
+
+        # detail_level: 0 -> obj? , 1 -> obj??
+        detail_level = 0
+        # We need to detect if we got called as 'pinfo pinfo foo', which can
+        # happen if the user types 'pinfo foo?' at the cmd line.
+        pinfo,qmark1,oname,qmark2 = \
+               re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
+        if pinfo or qmark1 or qmark2:
+            detail_level = 1
+        self._inspect('pinfo',oname,detail_level=detail_level)
+
+    def magic_who_ls(self, parameter_s=''):
+        """Return a sorted list of all interactive variables.
+
+        If arguments are given, only variables of types matching these
+        arguments are returned."""
+
+        user_ns = self.shell.user_ns
+        out = []
+        typelist = parameter_s.split()
+        for i in self.shell.user_ns.keys():
+            if not (i.startswith('_') or i.startswith('_i')) \
+                   and not (self.internal_ns.has_key(i) or
+                            self.user_config_ns.has_key(i)):
+                if typelist:
+                    if type(user_ns[i]).__name__ in typelist:
+                        out.append(i)
+                else:
+                    out.append(i)
+        out.sort()
+        return out
+        
+    def magic_who(self, parameter_s=''):
+        """Print all interactive variables, with some minimal formatting.
+
+        If any arguments are given, only variables whose type matches one of
+        these are printed.  For example:
+
+          %who function str
+
+        will only list functions and strings, excluding all other types of
+        variables.  To find the proper type names, simply use type(var) at a
+        command line to see how python prints type names.  For example:
+
+          In [1]: type('hello')\\
+          Out[1]: <type 'str'>
+
+        indicates that the type name for strings is 'str'.
+
+        %who always excludes executed names loaded through your configuration
+        file and things which are internal to IPython.
+
+        This is deliberate, as typically you may load many modules and the
+        purpose of %who is to show you only what you've manually defined."""
+
+        varlist = self.magic_who_ls(parameter_s)
+        if not varlist:
+            print 'Interactive namespace is empty.'
+            return
+
+        # if we have variables, move on...
+
+        # stupid flushing problem: when prompts have no separators, stdout is
+        # getting lost. I'm starting to think this is a python bug. I'm having
+        # to force a flush with a print because even a sys.stdout.flush
+        # doesn't seem to do anything!
+
+        count = 0
+        for i in varlist:
+            print i+'\t',
+            count += 1
+            if count > 8:
+                count = 0
+                print
+            sys.stdout.flush()  # FIXME. Why the hell isn't this flushing???
+            
+        print # well, this does force a flush at the expense of an extra \n
+
+    def magic_whos(self, parameter_s=''):
+        """Like %who, but gives some extra information about each variable.
+
+        The same type filtering of %who can be applied here.
+
+        For all variables, the type is printed. Additionally it prints:
+        
+          - For {},[],(): their length.
+
+          - For Numeric arrays, a summary with shape, number of elements,
+          typecode and size in memory.
+
+          - Everything else: a string representation, snipping their middle if
+          too long."""
+        
+        varnames = self.magic_who_ls(parameter_s)
+        if not varnames:
+            print 'Interactive namespace is empty.'
+            return
+
+        # if we have variables, move on...
+
+        # for these types, show len() instead of data:
+        seq_types = [types.DictType,types.ListType,types.TupleType]
+
+        # for Numeric arrays, display summary info
+        try:
+            import Numeric
+        except ImportError:
+            array_type = None
+        else:
+            array_type = Numeric.ArrayType.__name__
+        
+        # Find all variable names and types so we can figure out column sizes
+        get_vars = lambda i: self.locals[i]
+        type_name = lambda v: type(v).__name__
+        varlist = map(get_vars,varnames)
+        typelist = map(type_name,varlist)
+        # column labels and # of spaces as separator
+        varlabel = 'Variable'
+        typelabel = 'Type'
+        datalabel = 'Data/Info'
+        colsep = 3
+        # variable format strings
+        vformat    = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
+        vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
+        aformat    = "%s: %s elems, type `%s`, %s bytes"
+        # find the size of the columns to format the output nicely
+        varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
+        typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
+        # table header
+        print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
+              ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
+        # and the table itself
+        kb = 1024
+        Mb = 1048576  # kb**2
+        for vname,var,vtype in zip(varnames,varlist,typelist):
+            print itpl(vformat),
+            if vtype in seq_types:
+                print len(var)
+            elif vtype==array_type:
+                vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
+                vsize  = Numeric.size(var)
+                vbytes = vsize*var.itemsize()
+                if vbytes < 100000:
+                    print aformat % (vshape,vsize,var.typecode(),vbytes)
+                else:
+                    print aformat % (vshape,vsize,var.typecode(),vbytes),
+                    if vbytes < Mb:
+                        print '(%s kb)' % (vbytes/kb,)
+                    else:
+                        print '(%s Mb)' % (vbytes/Mb,)
+            else:
+                vstr = str(var)
+                if len(vstr) < 50:
+                    print vstr
+                else:
+                    printpl(vfmt_short)
+                
+    def magic_reset(self, parameter_s=''):
+        """Resets the namespace by removing all names defined by the user.
+
+        Input/Output history are left around in case you need them."""
+
+        ans = raw_input(
+          "Once deleted, variables cannot be recovered. Proceed (y/n)? ")
+        if not ans.lower() == 'y':
+            print 'Nothing done.'
+            return
+        for i in self.magic_who_ls():
+            del(self.locals[i])
+
+    def magic_config(self,parameter_s=''):
+        """Show IPython's internal configuration."""
+        
+        page('Current configuration structure:\n'+
+             pformat(self.shell.rc.dict()))
+
+    def magic_logstart(self,parameter_s=''):
+        """Start logging anywhere in a session.
+
+        %logstart [log_name [log_mode]]
+
+        If no name is given, it defaults to a file named 'ipython.log' in your
+        current directory, in 'rotate' mode (see below).
+
+        '%logstart name' saves to file 'name' in 'backup' mode.  It saves your
+        history up to that point and then continues logging.
+
+        %logstart takes a second optional parameter: logging mode. This can be one
+        of (note that the modes are given unquoted):\\
+          over: overwrite existing log.\\
+          backup: rename (if exists) to name~ and start name.\\
+          append: well, that says it.\\
+          rotate: create rotating logs name.1~, name.2~, etc.
+        """
+
+        #FIXME. This function should all be moved to the Logger class.
+        
+        valid_modes = qw('over backup append rotate')
+        if self.LOG:
+            print 'Logging is already in place. Logfile:',self.LOG
+            return
+
+        par = parameter_s.strip()
+        if not par:
+            logname = self.LOGDEF
+            logmode = 'rotate'  # use rotate for the auto-generated logs
+        else:
+            try:
+                logname,logmode = par.split()
+            except:
+                try:
+                    logname = par
+                    logmode = 'backup'
+                except:
+                    warn('Usage: %log [log_name [log_mode]]')
+                    return
+        if not logmode in valid_modes:
+            warn('Logging NOT activated.\n'
+                 'Usage: %log [log_name [log_mode]]\n'
+                 'Valid modes: '+str(valid_modes))
+            return
+
+        # If we made it this far, I think we're ok:
+        print 'Activating auto-logging.'
+        print 'Current session state plus future input saved to:',logname
+        print 'Logging mode: ',logmode
+        # put logname into rc struct as if it had been called on the command line,
+        # so it ends up saved in the log header
+        # Save it in case we need to restore it...
+        old_logfile = self.shell.rc.opts.get('logfile','')  
+        logname = os.path.expanduser(logname)
+        self.shell.rc.opts.logfile = logname
+        self.LOGMODE = logmode  # FIXME: this should be set through a function.
+        try:
+            header = str(self.LOGHEAD)
+            self.create_log(header,logname)
+            self.logstart(header,logname)
+        except:
+            self.LOG = ''  # we are NOT logging, something went wrong
+            self.shell.rc.opts.logfile = old_logfile
+            warn("Couldn't start log: "+str(sys.exc_info()[1]))
+        else:  # log input history up to this point
+            self.logfile.write(self.shell.user_ns['_ih'][1:])
+            self.logfile.flush()
+        
+    def magic_logoff(self,parameter_s=''):
+        """Temporarily stop logging.
+
+        You must have previously started logging."""
+        self.switch_log(0)
+        
+    def magic_logon(self,parameter_s=''):
+        """Restart logging.
+
+        This function is for restarting logging which you've temporarily
+        stopped with %logoff. For starting logging for the first time, you
+        must use the %logstart function, which allows you to specify an
+        optional log filename."""
+        
+        self.switch_log(1)
+    
+    def magic_logstate(self,parameter_s=''):
+        """Print the status of the logging system."""
+
+        self.logstate()
+        
+    def magic_pdb(self, parameter_s=''):
+        """Control the calling of the pdb interactive debugger.
+
+        Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
+        argument it works as a toggle.
+
+        When an exception is triggered, IPython can optionally call the
+        interactive pdb debugger after the traceback printout. %pdb toggles
+        this feature on and off."""
+
+        par = parameter_s.strip().lower()
+
+        if par:
+            try:
+                pdb = {'off':0,'0':0,'on':1,'1':1}[par]
+            except KeyError:
+                print 'Incorrect argument. Use on/1, off/0 or nothing for a toggle.'
+                return
+            else:
+               self.shell.InteractiveTB.call_pdb = pdb 
+        else:
+            self.shell.InteractiveTB.call_pdb = 1 - self.shell.InteractiveTB.call_pdb
+        print 'Automatic pdb calling has been turned',\
+              on_off(self.shell.InteractiveTB.call_pdb)
+
+
+    def magic_prun(self, parameter_s ='',user_mode=1,
+                   opts=None,arg_lst=None,prog_ns=None):
+
+        """Run a statement through the python code profiler.
+
+        Usage:\\
+          %prun [options] statement
+
+        The given statement (which doesn't require quote marks) is run via the
+        python profiler in a manner similar to the profile.run() function.
+        Namespaces are internally managed to work correctly; profile.run
+        cannot be used in IPython because it makes certain assumptions about
+        namespaces which do not hold under IPython.
+
+        Options:
+
+        -l <limit>: you can place restrictions on what or how much of the
+        profile gets printed. The limit value can be:
+
+          * A string: only information for function names containing this string
+          is printed.
+
+          * An integer: only these many lines are printed.
+
+          * A float (between 0 and 1): this fraction of the report is printed
+          (for example, use a limit of 0.4 to see the topmost 40% only).
+
+        You can combine several limits with repeated use of the option. For
+        example, '-l __init__ -l 5' will print only the topmost 5 lines of
+        information about class constructors.
+
+        -r: return the pstats.Stats object generated by the profiling. This
+        object has all the information about the profile in it, and you can
+        later use it for further analysis or in other functions.
+
+        Since magic functions have a particular form of calling which prevents
+        you from writing something like:\\
+          In [1]: p = %prun -r print 4  # invalid!\\
+        you must instead use IPython's automatic variables to assign this:\\
+          In [1]: %prun -r print 4  \\
+          Out[1]: <pstats.Stats instance at 0x8222cec>\\
+          In [2]: stats = _
+
+        If you really need to assign this value via an explicit function call,
+        you can always tap directly into the true name of the magic function
+        by using the ipmagic function (which IPython automatically adds to the
+        builtins):\\
+          In [3]: stats = ipmagic('prun','-r print 4')
+
+        You can type ipmagic? for more details on ipmagic.
+
+       -s <key>: sort profile by given key. You can provide more than one key
+        by using the option several times: '-s key1 -s key2 -s key3...'. The
+        default sorting key is 'time'.
+
+        The following is copied verbatim from the profile documentation
+        referenced below:
+
+        When more than one key is provided, additional keys are used as
+        secondary criteria when the there is equality in all keys selected
+        before them.
+        
+        Abbreviations can be used for any key names, as long as the
+        abbreviation is unambiguous.  The following are the keys currently
+        defined:
+
+                Valid Arg       Meaning\\
+                  "calls"      call count\\
+                  "cumulative" cumulative time\\
+                  "file"       file name\\
+                  "module"     file name\\
+                  "pcalls"     primitive call count\\
+                  "line"       line number\\
+                  "name"       function name\\
+                  "nfl"        name/file/line\\
+                  "stdname"    standard name\\
+                  "time"       internal time
+
+        Note that all sorts on statistics are in descending order (placing
+        most time consuming items first), where as name, file, and line number
+        searches are in ascending order (i.e., alphabetical). The subtle
+        distinction between "nfl" and "stdname" is that the standard name is a
+        sort of the name as printed, which means that the embedded line
+        numbers get compared in an odd way.  For example, lines 3, 20, and 40
+        would (if the file names were the same) appear in the string order
+        "20" "3" and "40".  In contrast, "nfl" does a numeric compare of the
+        line numbers.  In fact, sort_stats("nfl") is the same as
+        sort_stats("name", "file", "line").
+
+        -T <filename>: save profile results as shown on screen to a text
+        file. The profile is still shown on screen.
+
+        -D <filename>: save (via dump_stats) profile statistics to given
+        filename. This data is in a format understod by the pstats module, and
+        is generated by a call to the dump_stats() method of profile
+        objects. The profile is still shown on screen.
+
+        If you want to run complete programs under the profiler's control, use
+        '%run -p [prof_opts] filename.py [args to program]' where prof_opts
+        contains profiler specific options as described here.
+        
+        You can read the complete documentation for the profile module with:\\
+          In [1]: import profile; profile.help() """
+
+        opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
+        # protect user quote marks
+        parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
+        
+        if user_mode:  # regular user call
+            opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
+                                              list_all=1)
+            namespace = self.shell.user_ns
+        else:  # called to run a program by %run -p
+            try:
+                filename = get_py_filename(arg_lst[0])
+            except IOError,msg:
+                error(msg)
+                return
+
+            arg_str = 'execfile(filename,prog_ns)'
+            namespace = locals()
+
+        opts.merge(opts_def)
+        
+        prof = profile.Profile()
+        try:
+            prof = prof.runctx(arg_str,namespace,namespace)
+            sys_exit = ''
+        except SystemExit:
+            sys_exit = """*** SystemExit exception caught in code being profiled."""
+
+        stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
+
+        lims = opts.l
+        if lims:
+            lims = []  # rebuild lims with ints/floats/strings
+            for lim in opts.l:
+                try:
+                    lims.append(int(lim))
+                except ValueError:
+                    try:
+                        lims.append(float(lim))
+                    except ValueError:
+                        lims.append(lim)
+                    
+        # trap output
+        sys_stdout = sys.stdout
+        stdout_trap = StringIO()
+        try:
+            sys.stdout = stdout_trap
+            stats.print_stats(*lims)
+        finally:
+            sys.stdout = sys_stdout
+        output = stdout_trap.getvalue()
+        output = output.rstrip()
+
+        page(output,screen_lines=self.shell.rc.screen_length)
+        print sys_exit,
+
+        dump_file = opts.D[0]
+        text_file = opts.T[0]
+        if dump_file:
+            prof.dump_stats(dump_file)
+            print '\n*** Profile stats marshalled to file',\
+                  `dump_file`+'.',sys_exit
+        if text_file:
+            file(text_file,'w').write(output)
+            print '\n*** Profile printout saved to text file',\
+                  `text_file`+'.',sys_exit
+
+        if opts.has_key('r'):
+            return stats
+        else:
+            return None
+
+    def magic_run(self, parameter_s ='',runner=None):
+        """Run the named file inside IPython as a program.
+
+        Usage:\\
+          %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
+
+        Parameters after the filename are passed as command-line arguments to
+        the program (put in sys.argv). Then, control returns to IPython's
+        prompt.
+
+        This is similar to running at a system prompt:\\
+          $ python file args\\
+        but with the advantage of giving you IPython's tracebacks, and of
+        loading all variables into your interactive namespace for further use
+        (unless -p is used, see below).
+
+        The file is executed in a namespace initially consisting only of
+        __name__=='__main__' and sys.argv constructed as indicated. It thus
+        sees its environment as if it were being run as a stand-alone
+        program. But after execution, the IPython interactive namespace gets
+        updated with all variables defined in the program (except for __name__
+        and sys.argv). This allows for very convenient loading of code for
+        interactive work, while giving each program a 'clean sheet' to run in.
+
+        Options:
+        
+        -n: __name__ is NOT set to '__main__', but to the running file's name
+        without extension (as python does under import).  This allows running
+        scripts and reloading the definitions in them without calling code
+        protected by an ' if __name__ == "__main__" ' clause.
+
+        -i: run the file in IPython's namespace instead of an empty one. This
+        is useful if you are experimenting with code written in a text editor
+        which depends on variables defined interactively.
+
+        -e: ignore sys.exit() calls or SystemExit exceptions in the script
+        being run.  This is particularly useful if IPython is being used to
+        run unittests, which always exit with a sys.exit() call.  In such
+        cases you are interested in the output of the test results, not in
+        seeing a traceback of the unittest module.
+
+        -t: print timing information at the end of the run.  IPython will give
+        you an estimated CPU time consumption for your script, which under
+        Unix uses the resource module to avoid the wraparound problems of
+        time.clock().  Under Unix, an estimate of time spent on system tasks
+        is also given (for Windows platforms this is reported as 0.0).
+
+        If -t is given, an additional -N<N> option can be given, where <N>
+        must be an integer indicating how many times you want the script to
+        run.  The final timing report will include total and per run results.
+
+        For example (testing the script uniq_stable.py):
+
+            In [1]: run -t uniq_stable
+
+            IPython CPU timings (estimated):\\
+              User  :    0.19597 s.\\
+              System:        0.0 s.\\
+
+            In [2]: run -t -N5 uniq_stable
+
+            IPython CPU timings (estimated):\\
+            Total runs performed: 5\\
+              Times :      Total       Per run\\
+              User  :   0.910862 s,  0.1821724 s.\\
+              System:        0.0 s,        0.0 s.
+
+        -d: run your program under the control of pdb, the Python debugger.
+        This allows you to execute your program step by step, watch variables,
+        etc.  Internally, what IPython does is similar to calling:
+        
+          pdb.run('execfile("YOURFILENAME")')
+
+        with a breakpoint set on line 1 of your file.  You can change the line
+        number for this automatic breakpoint to be <N> by using the -bN option
+        (where N must be an integer).  For example:
+
+          %run -d -b40 myscript
+
+        will set the first breakpoint at line 40 in myscript.py.  Note that
+        the first breakpoint must be set on a line which actually does
+        something (not a comment or docstring) for it to stop execution.
+
+        When the pdb debugger starts, you will see a (Pdb) prompt.  You must
+        first enter 'c' (without qoutes) to start execution up to the first
+        breakpoint.
+
+        Entering 'help' gives information about the use of the debugger.  You
+        can easily see pdb's full documentation with "import pdb;pdb.help()"
+        at a prompt.
+
+        -p: run program under the control of the Python profiler module (which
+        prints a detailed report of execution times, function calls, etc).
+
+        You can pass other options after -p which affect the behavior of the
+        profiler itself. See the docs for %prun for details.
+
+        In this mode, the program's variables do NOT propagate back to the
+        IPython interactive namespace (because they remain in the namespace
+        where the profiler executes them).
+
+        Internally this triggers a call to %prun, see its documentation for
+        details on the options available specifically for profiling."""
+
+        # get arguments and set sys.argv for program to be run.
+        opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
+                                          mode='list',list_all=1)
+
+        try:
+            filename = get_py_filename(arg_lst[0])
+        except IndexError:
+            warn('you must provide at least a filename.')
+            print '\n%run:\n',OInspect.getdoc(self.magic_run)
+            return
+        except IOError,msg:
+            error(msg)
+            return
+
+        # Control the response to exit() calls made by the script being run
+        exit_ignore = opts.has_key('e')
+        
+        # Make sure that the running script gets a proper sys.argv as if it
+        # were run from a system shell.
+        save_argv = sys.argv # save it for later restoring
+        sys.argv = [filename]+ arg_lst[1:]  # put in the proper filename
+
+        if opts.has_key('i'):
+            prog_ns = self.shell.user_ns
+            __name__save = self.shell.user_ns['__name__']
+            prog_ns['__name__'] = '__main__'
+        else:
+            if opts.has_key('n'):
+                name = os.path.splitext(os.path.basename(filename))[0]
+            else:
+                name = '__main__'
+            prog_ns = {'__name__':name}
+
+        # pickle fix.  See iplib for an explanation
+        sys.modules[prog_ns['__name__']] = FakeModule(prog_ns)
+        
+        stats = None
+        try:
+            if opts.has_key('p'):
+                stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
+            else:
+                if opts.has_key('d'):
+                    deb = pdb.Pdb()
+                    # reset Breakpoint state, which is moronically kept
+                    # in a class
+                    bdb.Breakpoint.next = 1
+                    bdb.Breakpoint.bplist = {}
+                    bdb.Breakpoint.bpbynumber = [None]
+                    # Set an initial breakpoint to stop execution
+                    maxtries = 10
+                    bp = int(opts.get('b',[1])[0])
+                    checkline = deb.checkline(filename,bp)
+                    if not checkline:
+                        for bp in range(bp+1,bp+maxtries+1):
+                            if deb.checkline(filename,bp):
+                                break
+                        else:
+                            msg = ("\nI failed to find a valid line to set "
+                                   "a breakpoint\n"
+                                   "after trying up to line: %s.\n"
+                                   "Please set a valid breakpoint manually "
+                                   "with the -b option." % bp)
+                            error(msg)
+                            return
+                    # if we find a good linenumber, set the breakpoint
+                    deb.do_break('%s:%s' % (filename,bp))
+                    # Start file run
+                    print "NOTE: Enter 'c' at the",
+                    print "(Pdb) prompt to start your script."
+                    deb.run('execfile("%s")' % filename,prog_ns)
+                else:
+                    if runner is None:
+                        runner = self.shell.safe_execfile
+                    if opts.has_key('t'):
+                        try:
+                            nruns = int(opts['N'][0])
+                            if nruns < 1:
+                                error('Number of runs must be >=1')
+                                return
+                        except (KeyError):
+                            nruns = 1
+                        if nruns == 1:
+                            t0 = clock2()
+                            runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
+                            t1 = clock2()
+                            t_usr = t1[0]-t0[0]
+                            t_sys = t1[1]-t1[1]
+                            print "\nIPython CPU timings (estimated):"
+                            print "  User  : %10s s." % t_usr
+                            print "  System: %10s s." % t_sys
+                        else:
+                            runs = range(nruns)
+                            t0 = clock2()
+                            for nr in runs:
+                                runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
+                            t1 = clock2()
+                            t_usr = t1[0]-t0[0]
+                            t_sys = t1[1]-t1[1]
+                            print "\nIPython CPU timings (estimated):"
+                            print "Total runs performed:",nruns
+                            print "  Times : %10s    %10s" % ('Total','Per run')
+                            print "  User  : %10s s, %10s s." % (t_usr,t_usr/nruns)
+                            print "  System: %10s s, %10s s." % (t_sys,t_sys/nruns)
+                            
+                    else:
+                        runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
+                if opts.has_key('i'):
+                    self.shell.user_ns['__name__'] = __name__save
+                else:
+                    # update IPython interactive namespace
+                    del prog_ns['__name__']
+                    self.shell.user_ns.update(prog_ns)
+        finally:
+            sys.argv = save_argv
+        return stats
+
+    def magic_runlog(self, parameter_s =''):
+        """Run files as logs.
+
+        Usage:\\
+          %runlog file1 file2 ...
+
+        Run the named files (treating them as log files) in sequence inside
+        the interpreter, and return to the prompt.  This is much slower than
+        %run because each line is executed in a try/except block, but it
+        allows running files with syntax errors in them.
+
+        Normally IPython will guess when a file is one of its own logfiles, so
+        you can typically use %run even for logs. This shorthand allows you to
+        force any file to be treated as a log file."""
+
+        for f in parameter_s.split():
+            self.shell.safe_execfile(f,self.shell.user_ns,
+                                     self.shell.user_ns,islog=1)
+
+    def magic_time(self,parameter_s = ''):
+        """Time execution of a Python statement or expression.
+
+        The CPU and wall clock times are printed, and the value of the
+        expression (if any) is returned.  Note that under Win32, system time
+        is always reported as 0, since it can not be measured.
+
+        This function provides very basic timing functionality.  In Python
+        2.3, the timeit module offers more control and sophistication, but for
+        now IPython supports Python 2.2, so we can not rely on timeit being
+        present.
+        
+        Some examples:
+
+          In [1]: time 2**128
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00
+          Out[1]: 340282366920938463463374607431768211456L
+
+          In [2]: n = 1000000
+
+          In [3]: time sum(range(n))
+          CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
+          Wall time: 1.37
+          Out[3]: 499999500000L
+
+          In [4]: time print 'hello world'
+          hello world
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00
+          """
+        
+        # fail immediately if the given expression can't be compiled
+        try:
+            mode = 'eval'
+            code = compile(parameter_s,'<timed eval>',mode)
+        except SyntaxError:
+            mode = 'exec'
+            code = compile(parameter_s,'<timed exec>',mode)
+        # skew measurement as little as possible
+        glob = self.shell.user_ns
+        clk = clock2
+        wtime = time.time
+        # time execution
+        wall_st = wtime()
+        if mode=='eval':
+            st = clk()
+            out = eval(code,glob)
+            end = clk()
+        else:
+            st = clk()
+            exec code in glob
+            end = clk()
+            out = None
+        wall_end = wtime()
+        # Compute actual times and report
+        wall_time = wall_end-wall_st
+        cpu_user = end[0]-st[0]
+        cpu_sys = end[1]-st[1]
+        cpu_tot = cpu_user+cpu_sys
+        print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
+              (cpu_user,cpu_sys,cpu_tot)
+        print "Wall time: %.2f" % wall_time
+        return out
+
+    def magic_macro(self,parameter_s = ''):
+        """Define a set of input lines as a macro for future re-execution.
+
+        Usage:\\
+          %macro name n1:n2 n3:n4 ... n5 .. n6 ...
+
+        This will define a global variable called `name` which is a string
+        made of joining the slices and lines you specify (n1,n2,... numbers
+        above) from your input history into a single string. This variable
+        acts like an automatic function which re-executes those lines as if
+        you had typed them. You just type 'name' at the prompt and the code
+        executes.
+
+        Note that the slices use the standard Python slicing notation (5:8
+        means include lines numbered 5,6,7).
+
+        For example, if your history contains (%hist prints it):
+        
+          44: x=1\\
+          45: y=3\\
+          46: z=x+y\\
+          47: print x\\
+          48: a=5\\
+          49: print 'x',x,'y',y\\
+
+        you can create a macro with lines 44 through 47 (included) and line 49
+        called my_macro with:
+
+          In [51]: %macro my_macro 44:48 49
+
+        Now, typing `my_macro` (without quotes) will re-execute all this code
+        in one pass.
+
+        You don't need to give the line-numbers in order, and any given line
+        number can appear multiple times. You can assemble macros with any
+        lines from your input history in any order.
+
+        The macro is a simple object which holds its value in an attribute,
+        but IPython's display system checks for macros and executes them as
+        code instead of printing them when you type their name.
+
+        You can view a macro's contents by explicitly printing it with:
+        
+          'print macro_name'.
+
+        For one-off cases which DON'T contain magic function calls in them you
+        can obtain similar results by explicitly executing slices from your
+        input history with:
+
+          In [60]: exec In[44:48]+In[49]"""
+
+        args = parameter_s.split()
+        name,ranges = args[0], args[1:]
+        #print 'rng',ranges  # dbg
+        cmds = self.extract_input_slices(ranges)
+        macro = Macro(cmds)
+        self.shell.user_ns.update({name:macro})
+        print 'Macro `%s` created. To execute, type its name (without quotes).' % name
+        print 'Macro contents:'
+        print str(macro).rstrip(),
+
+    def magic_save(self,parameter_s = ''):
+        """Save a set of lines to a given filename.
+
+        Usage:\\
+          %save filename 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
+        filename you specify.
+
+        It adds a '.py' extension to the file if you don't do so yourself, and
+        it asks for confirmation before overwriting existing files."""
+
+        args = parameter_s.split()
+        fname,ranges = args[0], args[1:]
+        if not fname.endswith('.py'):
+            fname += '.py'
+        if os.path.isfile(fname):
+            ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
+            if ans.lower() not in ['y','yes']:
+                print 'Operation cancelled.'
+                return
+        cmds = ''.join(self.extract_input_slices(ranges))
+        f = file(fname,'w')
+        f.write(cmds)
+        f.close()
+        print 'The following commands were written to file `%s`:' % fname
+        print cmds
+
+    def magic_ed(self,parameter_s = ''):
+        """Alias to %edit."""
+        return self.magic_edit(parameter_s)
+
+    def magic_edit(self,parameter_s = '',last_call=['','']):
+        """Bring up an editor and execute the resulting code.
+
+        Usage:
+          %edit [options] [args]
+
+        %edit runs IPython's editor hook.  The default version of this hook is
+        set to call the __IPYTHON__.rc.editor command.  This is read from your
+        environment variable $EDITOR.  If this isn't found, it will default to
+        vi under Linux/Unix and to notepad under Windows.  See the end of this
+        docstring for how to change the editor hook.
+
+        You can also set the value of this editor via the command line option
+        '-editor' or in your ipythonrc file. This is useful if you wish to use
+        specifically for IPython an editor different from your typical default
+        (and for Windows users who typically don't set environment variables).
+
+        This command allows you to conveniently edit multi-line code right in
+        your IPython session.
+        
+        If called without arguments, %edit opens up an empty editor with a
+        temporary file and will execute the contents of this file when you
+        close it (don't forget to save it!).
+
+        Options:
+
+        -p: this will call the editor with the same data as the previous time
+        it was used, regardless of how long ago (in your current session) it
+        was.
+
+        -x: do not execute the edited code immediately upon exit. This is
+        mainly useful if you are editing programs which need to be called with
+        command line arguments, which you can then do using %run.
+
+        Arguments:
+
+        If arguments are given, the following possibilites exist:
+
+        - The arguments are numbers or pairs of colon-separated numbers (like
+        1 4:8 9). These are interpreted as lines of previous input to be
+        loaded into the editor. The syntax is the same of the %macro command.
+
+        - If the argument doesn't start with a number, it is evaluated as a
+        variable and its contents loaded into the editor. You can thus edit
+        any string which contains python code (including the result of
+        previous edits).
+
+        - If the argument is the name of an object (other than a string),
+        IPython will try to locate the file where it was defined and open the
+        editor at the point where it is defined. You can use `%edit function`
+        to load an editor exactly at the point where 'function' is defined,
+        edit it and have the file be executed automatically.
+
+        Note: opening at an exact line is only supported under Unix, and some
+        editors (like kedit and gedit up to Gnome 2.8) do not understand the
+        '+NUMBER' parameter necessary for this feature. Good editors like
+        (X)Emacs, vi, jed, pico and joe all do.
+
+        - If the argument is not found as a variable, IPython will look for a
+        file with that name (adding .py if necessary) and load it into the
+        editor. It will execute its contents with execfile() when you exit,
+        loading any code in the file into your interactive namespace.
+
+        After executing your code, %edit will return as output the code you
+        typed in the editor (except when it was an existing file). This way
+        you can reload the code in further invocations of %edit as a variable,
+        via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
+        the output.
+
+        Note that %edit is also available through the alias %ed.
+
+        This is an example of creating a simple function inside the editor and
+        then modifying it. First, start up the editor:
+
+        In [1]: ed\\
+        Editing... done. Executing edited code...\\
+        Out[1]: 'def foo():\\n    print "foo() was defined in an editing session"\\n'
+
+        We can then call the function foo():
+        
+        In [2]: foo()\\
+        foo() was defined in an editing session
+
+        Now we edit foo.  IPython automatically loads the editor with the
+        (temporary) file where foo() was previously defined:
+        
+        In [3]: ed foo\\
+        Editing... done. Executing edited code...
+
+        And if we call foo() again we get the modified version:
+        
+        In [4]: foo()\\
+        foo() has now been changed!
+
+        Here is an example of how to edit a code snippet successive
+        times. First we call the editor:
+
+        In [8]: ed\\
+        Editing... done. Executing edited code...\\
+        hello\\
+        Out[8]: "print 'hello'\\n"
+
+        Now we call it again with the previous output (stored in _):
+
+        In [9]: ed _\\
+        Editing... done. Executing edited code...\\
+        hello world\\
+        Out[9]: "print 'hello world'\\n"
+
+        Now we call it with the output #8 (stored in _8, also as Out[8]):
+
+        In [10]: ed _8\\
+        Editing... done. Executing edited code...\\
+        hello again\\
+        Out[10]: "print 'hello again'\\n"
+
+
+        Changing the default editor hook:
+
+        If you wish to write your own editor hook, you can put it in a
+        configuration file which you load at startup time.  The default hook
+        is defined in the IPython.hooks module, and you can use that as a
+        starting example for further modifications.  That file also has
+        general instructions on how to set a new hook for use once you've
+        defined it."""
+        
+        # FIXME: This function has become a convoluted mess.  It needs a
+        # ground-up rewrite with clean, simple logic.
+
+        def make_filename(arg):
+            "Make a filename from the given args"
+            try:
+                filename = get_py_filename(arg)
+            except IOError:
+                if args.endswith('.py'):
+                    filename = arg
+                else:
+                    filename = None
+            return filename
+
+        # custom exceptions
+        class DataIsObject(Exception): pass
+
+        opts,args = self.parse_options(parameter_s,'px')
+
+        # Default line number value
+        lineno = None
+        if opts.has_key('p'):
+            args = '_%s' % last_call[0]
+            if not self.shell.user_ns.has_key(args):
+                args = last_call[1]
+            
+        # use last_call to remember the state of the previous call, but don't
+        # let it be clobbered by successive '-p' calls.
+        try:
+            last_call[0] = self.shell.outputcache.prompt_count
+            if not opts.has_key('p'):
+                last_call[1] = parameter_s
+        except:
+            pass
+
+        # by default this is done with temp files, except when the given
+        # arg is a filename
+        use_temp = 1
+
+        if re.match(r'\d',args):
+            # Mode where user specifies ranges of lines, like in %macro.
+            # This means that you can't edit files whose names begin with
+            # numbers this way. Tough.
+            ranges = args.split()
+            data = ''.join(self.extract_input_slices(ranges))
+        elif args.endswith('.py'):
+            filename = make_filename(args)
+            data = ''
+            use_temp = 0
+        elif args:
+            try:
+                # Load the parameter given as a variable. If not a string,
+                # process it as an object instead (below)
+
+                #print '*** args',args,'type',type(args)  # dbg
+                data = eval(args,self.shell.user_ns)
+                if not type(data) in StringTypes:
+                    raise DataIsObject
+            except (NameError,SyntaxError):
+                # given argument is not a variable, try as a filename
+                filename = make_filename(args)
+                if filename is None:
+                    warn("Argument given (%s) can't be found as a variable "
+                         "or as a filename." % args)
+                    return
+                data = ''
+                use_temp = 0
+            except DataIsObject:
+                # For objects, try to edit the file where they are defined
+                try:
+                    filename = inspect.getabsfile(data)
+                    datafile = 1
+                except TypeError:
+                    filename = make_filename(args)
+                    datafile = 1
+                    warn('Could not find file where `%s` is defined.\n'
+                         'Opening a file named `%s`' % (args,filename))
+                # Now, make sure we can actually read the source (if it was in
+                # a temp file it's gone by now).
+                if datafile:
+                    try:
+                        lineno = inspect.getsourcelines(data)[1]
+                    except IOError:
+                        filename = make_filename(args)
+                        if filename is None:
+                            warn('The file `%s` where `%s` was defined cannot '
+                                 'be read.' % (filename,data))
+                            return
+                use_temp = 0
+        else:
+            data = ''
+
+        if use_temp:
+            filename = tempfile.mktemp('.py')
+            self.shell.tempfiles.append(filename)
+        
+        if data and use_temp:
+            tmp_file = open(filename,'w')
+            tmp_file.write(data)
+            tmp_file.close()
+
+        # do actual editing here
+        print 'Editing...',
+        sys.stdout.flush()
+        self.shell.hooks.editor(filename,lineno)
+        if opts.has_key('x'):  # -x prevents actual execution
+            print
+        else:
+            print 'done. Executing edited code...'
+            try:
+                execfile(filename,self.shell.user_ns)
+            except IOError,msg:
+                if msg.filename == filename:
+                    warn('File not found. Did you forget to save?')
+                    return
+                else:
+                    self.shell.showtraceback()
+            except:
+                self.shell.showtraceback()
+        if use_temp:
+            contents = open(filename).read()
+            return contents
+
+    def magic_xmode(self,parameter_s = ''):
+        """Switch modes for the exception handlers.
+
+        Valid modes: Plain, Context and Verbose.
+
+        If called without arguments, acts as a toggle."""
+
+        new_mode = parameter_s.strip().capitalize()
+        try:
+            self.InteractiveTB.set_mode(mode = new_mode)
+            print 'Exception reporting mode:',self.InteractiveTB.mode
+        except:
+            warn('Error changing exception modes.\n' + str(sys.exc_info()[1]))
+            
+    def magic_colors(self,parameter_s = ''):
+        """Switch color scheme for prompts, info system and exception handlers.
+
+        Currently implemented schemes: NoColor, Linux, LightBG.
+
+        Color scheme names are not case-sensitive."""
+        
+        new_scheme = parameter_s.strip()
+        if not new_scheme:
+            print 'You must specify a color scheme.'
+            return
+        # Under Windows, check for Gary Bishop's readline, which is necessary
+        # for ANSI coloring
+        if os.name in ['nt','dos']:
+            try:
+                import readline
+            except ImportError:
+                has_readline = 0
+            else:
+                try:
+                    readline.GetOutputFile()
+                except AttributeError:
+                    has_readline = 0
+                else:
+                    has_readline = 1
+            if not has_readline:
+                msg = """\
+Proper color support under MS Windows requires Gary Bishop's readline library.
+You can find it at:
+http://sourceforge.net/projects/uncpythontools
+Gary's readline needs the ctypes module, from:
+http://starship.python.net/crew/theller/ctypes
+
+Defaulting color scheme to 'NoColor'"""
+                new_scheme = 'NoColor'
+                warn(msg)
+        
+        # Set prompt colors
+        try:
+            self.shell.outputcache.set_colors(new_scheme)
+        except:
+            warn('Error changing prompt color schemes.\n'
+                 + str(sys.exc_info()[1]))
+        else:
+            self.shell.rc.colors = \
+                       self.shell.outputcache.color_table.active_scheme_name
+        # Set exception colors
+        try:
+            self.shell.InteractiveTB.set_colors(scheme = new_scheme)
+            self.shell.SyntaxTB.set_colors(scheme = new_scheme)
+        except:
+            warn('Error changing exception color schemes.\n'
+                 + str(sys.exc_info()[1]))
+        # Set info (for 'object?') colors
+        if self.shell.rc.color_info:
+            try:
+                self.shell.inspector.set_active_scheme(new_scheme)
+            except:
+                warn('Error changing object inspector color schemes.\n'
+                     + str(sys.exc_info()[1]))
+        else:
+            self.shell.inspector.set_active_scheme('NoColor')
+                
+    def magic_color_info(self,parameter_s = ''):
+        """Toggle color_info.
+
+        The color_info configuration parameter controls whether colors are
+        used for displaying object details (by things like %psource, %pfile or
+        the '?' system). This function toggles this value with each call.
+
+        Note that unless you have a fairly recent pager (less works better
+        than more) in your system, using colored object information displays
+        will not work properly. Test it and see."""
+        
+        self.shell.rc.color_info = 1 - self.shell.rc.color_info
+        self.magic_colors(self.shell.rc.colors)
+        print 'Object introspection functions have now coloring:',
+        print ['OFF','ON'][self.shell.rc.color_info]
+
+    def magic_Pprint(self, parameter_s=''):
+        """Toggle pretty printing on/off."""
+        
+        self.shell.outputcache.Pprint = 1 - self.shell.outputcache.Pprint
+        print 'Pretty printing has been turned', \
+              ['OFF','ON'][self.shell.outputcache.Pprint]
+        
+    def magic_Exit(self, parameter_s=''):
+        """Exit IPython without confirmation."""
+
+        self.shell.exit_now = True
+
+    def magic_Quit(self, parameter_s=''):
+        """Exit IPython without confirmation (like %Exit)."""
+
+        self.shell.exit_now = True
+        
+    #......................................................................
+    # Functions to implement unix shell-type things
+    
+    def magic_alias(self, parameter_s = ''):
+        """Define an alias for a system command.
+
+        '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
+
+        Then, typing 'alias_name params' will execute the system command 'cmd
+        params' (from your underlying operating system).
+
+        Aliases have lower precedence than magic functions and Python normal
+        variables, so if 'foo' is both a Python variable and an alias, the
+        alias can not be executed until 'del foo' removes the Python variable.
+
+        You can use the %l specifier in an alias definition to represent the
+        whole line when the alias is called.  For example:
+
+          In [2]: alias all echo "Input in brackets: <%l>"\\
+          In [3]: all hello world\\
+          Input in brackets: <hello world>
+
+        You can also define aliases with parameters using %s specifiers (one
+        per parameter):
+        
+          In [1]: alias parts echo first %s second %s\\
+          In [2]: %parts A B\\
+          first A second B\\
+          In [3]: %parts A\\
+          Incorrect number of arguments: 2 expected.\\
+          parts is an alias to: 'echo first %s second %s'
+
+        Note that %l and %s are mutually exclusive.  You can only use one or
+        the other in your aliases.
+
+        Aliases expand Python variables just like system calls using ! or !! 
+        do: all expressions prefixed with '$' get expanded.  For details of
+        the semantic rules, see PEP-215:
+        http://www.python.org/peps/pep-0215.html.  This is the library used by
+        IPython for variable expansion.  If you want to access a true shell
+        variable, an extra $ is necessary to prevent its expansion by IPython:
+
+        In [6]: alias show echo\\
+        In [7]: PATH='A Python string'\\
+        In [8]: show $PATH\\
+        A Python string\\
+        In [9]: show $$PATH\\
+        /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
+
+        You can use the alias facility to acess all of $PATH.  See the %rehash
+        and %rehashx functions, which automatically create aliases for the
+        contents of your $PATH.
+
+        If called with no parameters, %alias prints the current alias table."""
+
+        par = parameter_s.strip()
+        if not par:
+            if self.shell.rc.automagic:
+                prechar = ''
+            else:
+                prechar = self.shell.ESC_MAGIC
+            print 'Alias\t\tSystem Command\n'+'-'*30
+            atab = self.shell.alias_table
+            aliases = atab.keys()
+            aliases.sort()
+            for alias in aliases:
+                print prechar+alias+'\t\t'+atab[alias][1]
+            print '-'*30+'\nTotal number of aliases:',len(aliases)
+            return
+        try:
+            alias,cmd = par.split(None,1)
+        except:
+            print OInspect.getdoc(self.magic_alias)
+        else:
+            nargs = cmd.count('%s')
+            if nargs>0 and cmd.find('%l')>=0:
+                error('The %s and %l specifiers are mutually exclusive '
+                      'in alias definitions.')
+            else:  # all looks OK
+                self.shell.alias_table[alias] = (nargs,cmd)
+                self.shell.alias_table_validate(verbose=1)
+    # end magic_alias
+
+    def magic_unalias(self, parameter_s = ''):
+        """Remove an alias"""
+
+        aname = parameter_s.strip()
+        if aname in self.shell.alias_table:
+            del self.shell.alias_table[aname]
+            
+    def magic_rehash(self, parameter_s = ''):
+        """Update the alias table with all entries in $PATH.
+
+        This version does no checks on execute permissions or whether the
+        contents of $PATH are truly files (instead of directories or something
+        else).  For such a safer (but slower) version, use %rehashx."""
+
+        # This function (and rehashx) manipulate the alias_table directly
+        # rather than calling magic_alias, for speed reasons.  A rehash on a
+        # typical Linux box involves several thousand entries, so efficiency
+        # here is a top concern.
+        
+        path = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
+        alias_table = self.shell.alias_table
+        for pdir in path:
+            for ff in os.listdir(pdir):
+                # each entry in the alias table must be (N,name), where
+                # N is the number of positional arguments of the alias.
+                alias_table[ff] = (0,ff)
+        # Make sure the alias table doesn't contain keywords or builtins
+        self.shell.alias_table_validate()
+        # Call again init_auto_alias() so we get 'rm -i' and other modified
+        # aliases since %rehash will probably clobber them
+        self.shell.init_auto_alias()
+
+    def magic_rehashx(self, parameter_s = ''):
+        """Update the alias table with all executable files in $PATH.
+
+        This version explicitly checks that every entry in $PATH is a file
+        with execute access (os.X_OK), so it is much slower than %rehash.
+
+        Under Windows, it checks executability as a match agains a
+        '|'-separated string of extensions, stored in the IPython config
+        variable win_exec_ext.  This defaults to 'exe|com|bat'. """
+        
+        path = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
+        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'
+    
+            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):
+                            # 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)
+            else:
+                for pdir in path:
+                    os.chdir(pdir)
+                    for ff in os.listdir(pdir):
+                        if isexec(ff):
+                            alias_table[execre.sub(r'\1',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 %rehashx will probably clobber them
+            self.shell.init_auto_alias()
+        finally:
+            os.chdir(savedir)
+        
+    def magic_pwd(self, parameter_s = ''):
+        """Return the current working directory path."""
+        return os.getcwd()
+
+    def magic_cd(self, parameter_s=''):
+        """Change the current working directory.
+
+        This command automatically maintains an internal list of directories
+        you visit during your IPython session, in the variable _dh. The
+        command %dhist shows this history nicely formatted.
+
+        Usage:
+
+          cd 'dir': changes to directory 'dir'.
+
+          cd -: changes to the last visited directory.
+
+          cd -<n>: changes to the n-th directory in the directory history.
+
+          cd -b <bookmark_name>: jump to a bookmark set by %bookmark
+             (note: cd <bookmark_name> is enough if there is no
+              directory <bookmark_name>, but a bookmark with the name exists.)
+
+        Options:
+
+        -q: quiet.  Do not print the working directory after the cd command is
+        executed.  By default IPython's cd command does print this directory,
+        since the default prompts do not display path information.
+        
+        Note that !cd doesn't work for this purpose because the shell where
+        !command runs is immediately discarded after executing 'command'."""
+
+        parameter_s = parameter_s.strip()
+        bkms = self.shell.persist.get("bookmarks",{})
+
+        numcd = re.match(r'(-)(\d+)$',parameter_s)
+        # jump in directory history by number
+        if numcd:
+            nn = int(numcd.group(2))
+            try:
+                ps = self.shell.user_ns['_dh'][nn]
+            except IndexError:
+                print 'The requested directory does not exist in history.'
+                return
+            else:
+                opts = {}
+        else:
+            opts,ps = self.parse_options(parameter_s,'qb',mode='string')
+        # jump to previous
+        if ps == '-':
+            try:
+                ps = self.shell.user_ns['_dh'][-2]
+            except IndexError:
+                print 'No previous directory to change to.'
+                return
+        # jump to bookmark
+        elif opts.has_key('b') or (bkms.has_key(ps) and not os.path.isdir(ps)):
+            if bkms.has_key(ps):
+                target = bkms[ps]
+                print '(bookmark:%s) -> %s' % (ps,target)
+                ps = target
+            else:
+                if bkms:
+                    error("Bookmark '%s' not found.  "
+                          "Use '%bookmark -l' to see your bookmarks." % ps)
+                else:
+                    print "Bookmarks not set - use %bookmark <bookmarkname>"
+                return
+            
+        # at this point ps should point to the target dir
+        if ps:
+            try:
+                os.chdir(os.path.expanduser(ps))
+            except OSError:
+                print sys.exc_info()[1]
+            else:
+                self.shell.user_ns['_dh'].append(os.getcwd())
+        else:
+            os.chdir(self.home_dir)
+            self.shell.user_ns['_dh'].append(os.getcwd())
+        if not 'q' in opts:
+            print self.shell.user_ns['_dh'][-1]
+
+    def magic_dhist(self, parameter_s=''):
+        """Print your history of visited directories.
+
+        %dhist       -> print full history\\
+        %dhist n     -> print last n entries only\\
+        %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
+
+        This history is automatically maintained by the %cd command, and
+        always available as the global list variable _dh. You can use %cd -<n>
+        to go to directory number <n>."""
+
+        dh = self.shell.user_ns['_dh']
+        if parameter_s:
+            try:
+                args = map(int,parameter_s.split())
+            except:
+                self.arg_err(Magic.magic_dhist)
+                return
+            if len(args) == 1:
+                ini,fin = max(len(dh)-(args[0]),0),len(dh)
+            elif len(args) == 2:
+                ini,fin = args
+            else:
+                self.arg_err(Magic.magic_dhist)
+                return
+        else:
+            ini,fin = 0,len(dh)
+        nlprint(dh,
+                header = 'Directory history (kept in _dh)',
+                start=ini,stop=fin)
+
+    def magic_env(self, parameter_s=''):
+        """List environment variables."""
+        
+        # environ is an instance of UserDict
+        return os.environ.data
+
+    def magic_pushd(self, parameter_s=''):
+        """Place the current dir on stack and change directory.
+        
+        Usage:\\
+          %pushd ['dirname']
+
+        %pushd with no arguments does a %pushd to your home directory.
+        """
+        if parameter_s == '': parameter_s = '~'
+        if len(self.dir_stack)>0 and os.path.expanduser(parameter_s) != \
+           os.path.expanduser(self.dir_stack[0]):
+            try:
+                self.magic_cd(parameter_s)
+                self.dir_stack.insert(0,os.getcwd().replace(self.home_dir,'~'))
+                self.magic_dirs()
+            except:
+                print 'Invalid directory'
+        else:
+            print 'You are already there!'
+
+    def magic_popd(self, parameter_s=''):
+        """Change to directory popped off the top of the stack.
+        """
+        if len (self.dir_stack) > 1:
+            self.dir_stack.pop(0)
+            self.magic_cd(self.dir_stack[0])
+            print self.dir_stack[0]
+        else:
+            print "You can't remove the starting directory from the stack:",\
+                  self.dir_stack
+
+    def magic_dirs(self, parameter_s=''):
+        """Return the current directory stack."""
+
+        return self.dir_stack[:]
+
+    def magic_sc(self, parameter_s=''):
+        """Shell capture - execute a shell command and capture its output.
+
+        %sc [options] varname=command
+
+        IPython will run the given command using commands.getoutput(), and
+        will then update the user's interactive namespace with a variable
+        called varname, containing the value of the call.  Your command can
+        contain shell wildcards, pipes, etc.
+
+        The '=' sign in the syntax is mandatory, and the variable name you
+        supply must follow Python's standard conventions for valid names.
+
+        Options:
+
+          -l: list output.  Split the output on newlines into a list before
+          assigning it to the given variable.  By default the output is stored
+          as a single string.
+
+          -v: verbose.  Print the contents of the variable.
+
+        In most cases you should not need to split as a list, because the
+        returned value is a special type of string which can automatically
+        provide its contents either as a list (split on newlines) or as a
+        space-separated string.  These are convenient, respectively, either
+        for sequential processing or to be passed to a shell command.
+
+        For example:
+
+            # Capture into variable a
+            In [9]: sc a=ls *py
+
+            # a is a string with embedded newlines
+            In [10]: a
+            Out[10]: 'setup.py\nwin32_manual_post_install.py'
+
+            # which can be seen as a list:
+            In [11]: a.l
+            Out[11]: ['setup.py', 'win32_manual_post_install.py']
+
+            # or as a whitespace-separated string:
+            In [12]: a.s
+            Out[12]: 'setup.py win32_manual_post_install.py'
+
+            # a.s is useful to pass as a single command line:
+            In [13]: !wc -l $a.s
+              146 setup.py
+              130 win32_manual_post_install.py
+              276 total
+
+            # while the list form is useful to loop over:
+            In [14]: for f in a.l:
+               ....:      !wc -l $f
+               ....:
+            146 setup.py
+            130 win32_manual_post_install.py
+
+        Similiarly, the lists returned by the -l option are also special, in
+        the sense that you can equally invoke the .s attribute on them to
+        automatically get a whitespace-separated string from their contents:
+
+            In [1]: sc -l b=ls *py
+
+            In [2]: b
+            Out[2]: ['setup.py', 'win32_manual_post_install.py']
+
+            In [3]: b.s
+            Out[3]: 'setup.py win32_manual_post_install.py'
+
+        In summary, both the lists and strings used for ouptut capture have
+        the following special attributes:
+
+            .l (or .list) : value as list.
+            .n (or .nlstr): value as newline-separated string.
+            .s (or .spstr): value as space-separated string.
+        """
+
+        opts,args = self.parse_options(parameter_s,'lv')
+        # Try to get a variable name and command to run
+        try:
+            # the variable name must be obtained from the parse_options
+            # output, which uses shlex.split to strip options out.
+            var,_ = args.split('=',1)
+            var = var.strip()
+            # But the the command has to be extracted from the original input
+            # parameter_s, not on what parse_options returns, to avoid the
+            # quote stripping which shlex.split performs on it.
+            _,cmd = parameter_s.split('=',1)
+        except ValueError:
+            var,cmd = '',''
+        if not var:
+            error('you must specify a variable to assign the command to.')
+            return
+        # If all looks ok, proceed
+        out,err = self.shell.getoutputerror(cmd)
+        if err:
+            print >> Term.cerr,err
+        if opts.has_key('l'):
+            out = SList(out.split('\n'))
+        else:
+            out = LSString(out)
+        if opts.has_key('v'):
+            print '%s ==\n%s' % (var,pformat(out))
+        self.shell.user_ns.update({var:out})
+
+    def magic_sx(self, parameter_s=''):
+        """Shell execute - run a shell command and capture its output.
+
+        %sx command
+
+        IPython will run the given command using commands.getoutput(), and
+        return the result formatted as a list (split on '\\n').  Since the
+        output is _returned_, it will be stored in ipython's regular output
+        cache Out[N] and in the '_N' automatic variables.
+
+        Notes:
+
+        1) If an input line begins with '!!', then %sx is automatically
+        invoked.  That is, while:
+          !ls
+        causes ipython to simply issue system('ls'), typing
+          !!ls
+        is a shorthand equivalent to:
+          %sx ls
+        
+        2) %sx differs from %sc in that %sx automatically splits into a list,
+        like '%sc -l'.  The reason for this is to make it as easy as possible
+        to process line-oriented shell output via further python commands.
+        %sc is meant to provide much finer control, but requires more
+        typing.
+
+        3) Just like %sc -l, this is a list with special attributes:
+
+          .l (or .list) : value as list.
+          .n (or .nlstr): value as newline-separated string.
+          .s (or .spstr): value as whitespace-separated string.
+
+        This is very useful when trying to use such lists as arguments to
+        system commands."""
+
+        if parameter_s:
+            out,err = self.shell.getoutputerror(parameter_s)
+            if err:
+                print >> Term.cerr,err
+            return SList(out.split('\n'))
+
+    def magic_bg(self, parameter_s=''):
+        """Run a job in the background, in a separate thread.
+
+        For example,
+
+          %bg myfunc(x,y,z=1)
+
+        will execute 'myfunc(x,y,z=1)' in a background thread.  As soon as the
+        execution starts, a message will be printed indicating the job
+        number.  If your job number is 5, you can use
+
+          myvar = jobs.result(5)  or  myvar = jobs[5].result
+
+        to assign this result to variable 'myvar'.
+
+        IPython has a job manager, accessible via the 'jobs' object.  You can
+        type jobs? to get more information about it, and use jobs.<TAB> to see
+        its attributes.  All attributes not starting with an underscore are
+        meant for public use.
+
+        In particular, look at the jobs.new() method, which is used to create
+        new jobs.  This magic %bg function is just a convenience wrapper
+        around jobs.new(), for expression-based jobs.  If you want to create a
+        new job with an explicit function object and arguments, you must call
+        jobs.new() directly.
+
+        The jobs.new docstring also describes in detail several important
+        caveats associated with a thread-based model for background job
+        execution.  Type jobs.new? for details.
+
+        You can check the status of all jobs with jobs.status().
+
+        The jobs variable is set by IPython into the Python builtin namespace.
+        If you ever declare a variable named 'jobs', you will shadow this
+        name.  You can either delete your global jobs variable to regain
+        access to the job manager, or make a new name and assign it manually
+        to the manager (stored in IPython's namespace).  For example, to
+        assign the job manager to the Jobs name, use:
+
+          Jobs = __builtins__.jobs"""
+        
+        self.shell.jobs.new(parameter_s,self.shell.user_ns)
+        
+    def magic_bookmark(self, parameter_s=''):
+        """Manage IPython's bookmark system.
+
+        %bookmark <name>       - set bookmark to current dir
+        %bookmark <name> <dir> - set bookmark to <dir>
+        %bookmark -l           - list all bookmarks
+        %bookmark -d <name>    - remove bookmark
+        %bookmark -r           - remove all bookmarks
+
+        You can later on access a bookmarked folder with:
+          %cd -b <name>
+        or simply '%cd <name>' if there is no directory called <name> AND
+        there is such a bookmark defined.
+
+        Your bookmarks persist through IPython sessions, but they are
+        associated with each profile."""
+
+        opts,args = self.parse_options(parameter_s,'drl',mode='list')
+        if len(args) > 2:
+            error('You can only give at most two arguments')
+            return
+
+        bkms = self.shell.persist.get('bookmarks',{})
+            
+        if opts.has_key('d'):
+            try:
+                todel = args[0]
+            except IndexError:
+                error('You must provide a bookmark to delete')
+            else:
+                try:
+                    del bkms[todel]
+                except:
+                    error("Can't delete bookmark '%s'" % todel)
+        elif opts.has_key('r'):
+            bkms = {}
+        elif opts.has_key('l'):
+            bks = bkms.keys()
+            bks.sort()
+            if bks:
+                size = max(map(len,bks))
+            else:
+                size = 0
+            fmt = '%-'+str(size)+'s -> %s'
+            print 'Current bookmarks:'
+            for bk in bks:
+                print fmt % (bk,bkms[bk])
+        else:
+            if not args:
+                error("You must specify the bookmark name")
+            elif len(args)==1:
+                bkms[args[0]] = os.getcwd()
+            elif len(args)==2:
+                bkms[args[0]] = args[1]
+        self.persist['bookmarks'] = bkms
+# end Magic

IPython/OInspect.py

@@ -0,0 +1,398 b''
+# -*- coding: utf-8 -*-
+"""Tools for inspecting Python objects.
+
+Uses syntax highlighting for presenting the various information elements.
+
+Similar in spirit to the inspect module, but all calls take a name argument to
+reference the name under which an object is being read.
+
+$Id: OInspect.py 575 2005-04-08 14:16:44Z fperez $
+"""
+
+#*****************************************************************************
+#       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
+
+__all__ = ['Inspector','InspectColors']
+
+# stdlib modules
+import inspect,linecache,types,StringIO,string
+
+# IPython's own
+from IPython.Itpl import itpl
+from IPython.genutils import page,indent,Term
+from IPython import PyColorize
+from IPython.ColorANSI import *
+
+#****************************************************************************
+# Builtin color schemes
+
+Colors = TermColors  # just a shorthand
+
+# Build a few color schemes
+NoColor = ColorScheme(
+    'NoColor',{
+    'header' : Colors.NoColor,
+    'normal' : Colors.NoColor  # color off (usu. Colors.Normal)
+    }  )
+
+LinuxColors = ColorScheme(
+    'Linux',{
+    'header' : Colors.LightRed,
+    'normal' : Colors.Normal  # color off (usu. Colors.Normal)
+    } )
+
+LightBGColors = ColorScheme(
+    'LightBG',{
+    'header' : Colors.Red,
+    'normal' : Colors.Normal  # color off (usu. Colors.Normal)
+    }  )
+
+# Build table of color schemes (needed by the parser)
+InspectColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
+                                 'Linux')
+
+#****************************************************************************
+# Auxiliary functions
+def getdoc(obj):
+    """Stable wrapper around inspect.getdoc.
+
+    This can't crash because of attribute problems.
+
+    It also attempts to call a getdoc() method on the given object.  This
+    allows objects which provide their docstrings via non-standard mechanisms
+    (like Pyro proxies) to still be inspected by ipython's ? system."""
+
+    ds = None  # default return value
+    try:
+        ds = inspect.getdoc(obj)
+    except:
+        # Harden against an inspect failure, which can occur with
+        # SWIG-wrapped extensions.
+        pass
+    # Allow objects to offer customized documentation via a getdoc method:
+    try:
+        ds2 = obj.getdoc()
+    except:
+        pass
+    else:
+        # if we get extra info, we add it to the normal docstring.
+        if ds is None:
+            ds = ds2
+        else:
+            ds = '%s\n%s' % (ds,ds2)
+    return ds
+
+#****************************************************************************
+# Class definitions
+
+class myStringIO(StringIO.StringIO):
+    """Adds a writeln method to normal StringIO."""
+    def writeln(self,*arg,**kw):
+        """Does a write() and then a write('\n')"""
+        self.write(*arg,**kw)
+        self.write('\n')
+
+class Inspector:
+    def __init__(self,color_table,code_color_table,scheme):
+        self.color_table = color_table
+        self.parser = PyColorize.Parser(code_color_table,out='str')
+        self.format = self.parser.format
+        self.set_active_scheme(scheme)
+
+    def __getargspec(self,obj):
+        """Get the names and default values of a function's arguments.
+
+        A tuple of four things is returned: (args, varargs, varkw, defaults).
+        'args' is a list of the argument names (it may contain nested lists).
+        'varargs' and 'varkw' are the names of the * and ** arguments or None.
+        'defaults' is an n-tuple of the default values of the last n arguments.
+
+        Modified version of inspect.getargspec from the Python Standard
+        Library."""
+
+        if inspect.isfunction(obj):
+            func_obj = obj
+        elif inspect.ismethod(obj):
+            func_obj = obj.im_func
+        else:
+            raise TypeError, 'arg is not a Python function'
+        args, varargs, varkw = inspect.getargs(func_obj.func_code)
+        return args, varargs, varkw, func_obj.func_defaults
+
+    def __getdef(self,obj,oname=''):
+        """Return the definition header for any callable object.
+
+        If any exception is generated, None is returned instead and the
+        exception is suppressed."""
+        
+        try:
+            return oname + inspect.formatargspec(*self.__getargspec(obj))
+        except:
+            return None
+ 
+    def __head(self,h):
+        """Return a header string with proper colors."""
+        return '%s%s%s' % (self.color_table.active_colors.header,h,
+                           self.color_table.active_colors.normal)
+
+    def set_active_scheme(self,scheme):
+        self.color_table.set_active_scheme(scheme)
+        self.parser.color_table.set_active_scheme(scheme)
+    
+    def noinfo(self,msg,oname):
+        """Generic message when no information is found."""
+        print 'No %s found' % msg,
+        if oname:
+            print 'for %s' % oname
+        else:
+            print
+            
+    def pdef(self,obj,oname=''):
+        """Print the definition header for any callable object.
+
+        If the object is a class, print the constructor information."""
+
+        if not callable(obj):
+            print 'Object is not callable.'
+            return
+
+        header = ''
+        if type(obj) is types.ClassType:
+            header = self.__head('Class constructor information:\n')
+            obj = obj.__init__
+        elif type(obj) is types.InstanceType:
+            obj = obj.__call__
+
+        output = self.__getdef(obj,oname)
+        if output is None:
+            self.noinfo('definition header',oname)
+        else:
+            print >>Term.cout, header,self.format(output),
+
+    def pdoc(self,obj,oname='',formatter = None):
+        """Print the docstring for any object.
+
+        Optional:
+        -formatter: a function to run the docstring through for specially
+        formatted docstrings."""
+        
+        head = self.__head  # so that itpl can find it even if private
+        ds = getdoc(obj)
+        if formatter:
+            ds = formatter(ds)
+        if type(obj) is types.ClassType:
+            init_ds = getdoc(obj.__init__)
+            output = itpl('$head("Class Docstring:")\n'
+                          '$indent(ds)\n'
+                          '$head("Constructor Docstring"):\n'
+                          '$indent(init_ds)')
+        elif type(obj) is types.InstanceType and hasattr(obj,'__call__'):
+            call_ds = getdoc(obj.__call__)
+            if call_ds:
+                output = itpl('$head("Class Docstring:")\n$indent(ds)\n'
+                              '$head("Calling Docstring:")\n$indent(call_ds)')
+            else:
+                output = ds
+        else:
+            output = ds
+        if output is None:
+            self.noinfo('documentation',oname)
+            return
+        page(output)
+
+    def psource(self,obj,oname=''):
+        """Print the source code for an object."""
+
+        # Flush the source cache because inspect can return out-of-date source
+        linecache.checkcache()
+        try:
+            src = inspect.getsource(obj) 
+        except:
+            self.noinfo('source',oname)
+        else:
+            page(self.format(src))
+
+    def pfile(self,obj,oname=''):
+        """Show the whole file where an object was defined."""
+        try:
+            sourcelines,lineno = inspect.getsourcelines(obj)
+        except:
+            self.noinfo('file',oname)
+        else:
+            # run contents of file through pager starting at line
+            # where the object is defined            
+            page(self.format(open(inspect.getabsfile(obj)).read()),lineno)
+
+    def pinfo(self,obj,oname='',formatter=None,info=None,detail_level=0):
+        """Show detailed information about an object.
+
+        Optional arguments:
+        
+        - oname: name of the variable pointing to the object.
+
+        - formatter: special formatter for docstrings (see pdoc)
+
+        - info: a structure with some information fields which may have been
+        precomputed already.
+
+        - detail_level: if set to 1, more information is given.
+        """
+
+        obj_type = type(obj)
+
+        header = self.__head
+        if info is None:
+            ismagic = 0
+            isalias = 0
+            ospace = ''
+        else:
+            ismagic = info.ismagic
+            isalias = info.isalias
+            ospace = info.namespace
+        # Get docstring, special-casing aliases:
+        if isalias:
+            ds = "Alias to the system command:\n  %s" % obj[1]
+        else:
+            ds = getdoc(obj)
+        if formatter is not None:
+            ds = formatter(ds)
+
+        # store output in a list which gets joined with \n at the end.
+        out = myStringIO()
+        
+        string_max = 200 # max size of strings to show (snipped if longer)
+        shalf = int((string_max -5)/2)
+
+        if ismagic:
+            obj_type_name = 'Magic function'
+        elif isalias:
+            obj_type_name = 'System alias'
+        else:
+            obj_type_name = obj_type.__name__
+        out.writeln(header('Type:\t\t')+obj_type_name)
+
+        try:
+            bclass = obj.__class__
+            out.writeln(header('Base Class:\t')+str(bclass))
+        except: pass
+
+        # String form, but snip if too long in ? form (full in ??)
+        try:
+            ostr = str(obj)
+            str_head = 'String Form:'
+            if not detail_level and len(ostr)>string_max:
+                ostr = ostr[:shalf] + ' <...> ' + ostr[-shalf:]
+                ostr = ("\n" + " " * len(str_head.expandtabs())).\
+                       join(map(string.strip,ostr.split("\n")))
+            if ostr.find('\n') > -1:
+                # Print multi-line strings starting at the next line.
+                str_sep = '\n'
+            else:
+                str_sep = '\t'
+            out.writeln("%s%s%s" % (header(str_head),str_sep,ostr))
+        except:
+            pass
+
+        if ospace:
+            out.writeln(header('Namespace:\t')+ospace)
+
+        # Length (for strings and lists)
+        try:
+            length = str(len(obj))
+            out.writeln(header('Length:\t\t')+length)
+        except: pass
+
+        # Filename where object was defined
+        try:
+            file = inspect.getabsfile(obj)
+            if file.endswith('<string>'):
+                file = 'Dynamically generated function. No source code available.'
+            out.writeln(header('File:\t\t')+file)
+        except: pass
+
+        # reconstruct the function definition and print it:
+        defln = self.__getdef(obj,oname)
+        if defln:
+            out.write(header('Definition:\t')+self.format(defln))
+ 
+        # Docstrings only in detail 0 mode, since source contains them (we
+        # avoid repetitions).  If source fails, we add them back, see below.
+        if ds and detail_level == 0:
+                out.writeln(header('Docstring:\n') + indent(ds))
+
+        # Original source code for any callable
+        if detail_level:
+            # Flush the source cache because inspect can return out-of-date source
+            linecache.checkcache()
+            try:
+                source = self.format(inspect.getsource(obj))
+                out.write(header('Source:\n')+source.rstrip())
+            except:
+                if ds:
+                    out.writeln(header('Docstring:\n') + indent(ds))
+
+        # Constructor docstring for classes
+        if obj_type is types.ClassType:
+            # reconstruct the function definition and print it:
+            try:
+                obj_init =  obj.__init__
+            except AttributeError:
+                init_def = init_ds = None
+            else:
+                init_def = self.__getdef(obj_init,oname)
+                init_ds  = getdoc(obj_init)
+
+            if init_def or init_ds:
+                out.writeln(header('\nConstructor information:'))
+                if init_def:
+                    out.write(header('Definition:\t')+ self.format(init_def))
+                if init_ds:
+                    out.writeln(header('Docstring:\n') + indent(init_ds))
+        # and class docstring for instances:
+        elif obj_type is types.InstanceType:
+
+            # First, check whether the instance docstring is identical to the
+            # class one, and print it separately if they don't coincide.  In
+            # most cases they will, but it's nice to print all the info for
+            # objects which use instance-customized docstrings.
+            if ds:
+                class_ds = getdoc(obj.__class__)
+                if class_ds and ds != class_ds:
+                    out.writeln(header('Class Docstring:\n') +
+                                indent(class_ds))
+
+            # Next, try to show constructor docstrings
+            try:
+                init_ds = getdoc(obj.__init__)
+            except AttributeError:
+                init_ds = None
+            if init_ds:
+                out.writeln(header('Constructor Docstring:\n') +
+                            indent(init_ds))
+
+            # Call form docstring for callable instances
+            if hasattr(obj,'__call__'):
+                out.writeln(header('Callable:\t')+'Yes')
+                call_def = self.__getdef(obj.__call__,oname)
+                if call_def is None:
+                    out.write(header('Call def:\t')+
+                              'Calling definition not available.')
+                else:
+                    out.write(header('Call def:\t')+self.format(call_def))
+                call_ds = getdoc(obj.__call__)
+                if call_ds:
+                    out.writeln(header('Call docstring:\n') + indent(call_ds))
+
+        # Finally send to printer/pager
+        output = out.getvalue()
+        if output:
+            page(output)
+        # end pinfo

IPython/OutputTrap.py

@@ -0,0 +1,262 b''
+# -*- coding: utf-8 -*-
+"""Class to trap stdout and stderr and log them separately.
+
+$Id: OutputTrap.py 542 2005-03-18 09:16:04Z fperez $"""
+
+#*****************************************************************************
+#       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
+
+import exceptions,sys
+from cStringIO import StringIO
+
+class OutputTrapError(exceptions.Exception):
+    """Exception for OutputTrap class."""
+
+    def __init__(self,args=None):
+        exceptions.Exception.__init__(self)
+        self.args = args
+
+class OutputTrap:
+
+    """Class to trap standard output and standard error. They get logged in
+    StringIO objects which are available as <instance>.out and
+    <instance>.err. The class also offers summary methods which format this
+    data a bit.
+
+    A word of caution: because it blocks messages, using this class can make
+    debugging very tricky. If you are having bizarre problems silently, try
+    turning your output traps off for a while. You can call the constructor
+    with the parameter debug=1 for these cases. This turns actual trapping
+    off, but you can keep the rest of your code unchanged (this has already
+    been a life saver).
+
+    Example:
+
+    # config: trapper with a line of dots as log separator (final '\\n' needed)
+    config = OutputTrap('Config','Out ','Err ','.'*80+'\\n')
+
+    # start trapping output
+    config.trap_all()
+
+    # now all output is logged ...
+    # do stuff...
+
+    # output back to normal:
+    config.release_all()
+
+    # print all that got logged:
+    print config.summary()
+
+    # print individual raw data:
+    print config.out.getvalue()
+    print config.err.getvalue()
+    """
+
+    def __init__(self,name='Generic Output Trap',
+                 out_head='Standard Output. ',err_head='Standard Error. ',
+                 sum_sep='\n',debug=0,trap_out=0,trap_err=0,
+                 quiet_out=0,quiet_err=0):
+        self.name = name
+        self.out_head = out_head
+        self.err_head = err_head
+        self.sum_sep = sum_sep
+        self.out = StringIO()
+        self.err = StringIO()
+        self.out_save = None
+        self.err_save = None
+        self.debug = debug
+        self.quiet_out = quiet_out
+        self.quiet_err = quiet_err
+        if trap_out:
+            self.trap_out()
+        if trap_err:
+            self.trap_err()
+
+    def trap_out(self):
+        """Trap and log stdout."""
+        if sys.stdout is self.out:
+            raise OutputTrapError,'You are already trapping stdout.'
+        if not self.debug:
+            self._out_save = sys.stdout
+            sys.stdout = self.out
+
+    def release_out(self):
+        """Release stdout."""
+        if not self.debug:
+            if not sys.stdout is self.out:
+                raise OutputTrapError,'You are not trapping stdout.'
+            sys.stdout = self._out_save
+            self.out_save = None
+
+    def summary_out(self):
+        """Return as a string the log from stdout."""
+        out = self.out.getvalue()
+        if out:
+            if self.quiet_out:
+                return out
+            else:
+                return self.out_head + 'Log by '+ self.name + ':\n' + out
+        else:
+            return ''
+
+    def flush_out(self):
+        """Flush the stdout log. All data held in the log is lost."""
+
+        self.out.close()
+        self.out = StringIO()
+
+    def trap_err(self):
+        """Trap and log stderr."""
+        if sys.stderr is self.err:
+            raise OutputTrapError,'You are already trapping stderr.'
+        if not self.debug:
+            self._err_save = sys.stderr
+            sys.stderr = self.err
+
+    def release_err(self):
+        """Release stderr."""
+        if not self.debug:
+            if not sys.stderr is self.err:
+                raise OutputTrapError,'You are not trapping stderr.'
+            sys.stderr = self._err_save
+            self.err_save = None
+
+    def summary_err(self):
+        """Return as a string the log from stderr."""
+        err = self.err.getvalue()
+        if err:
+            if self.quiet_err:
+                return err
+            else:
+                return self.err_head + 'Log by '+ self.name + ':\n' + err
+        else:
+            return ''
+
+    def flush_err(self):
+        """Flush the stdout log. All data held in the log is lost."""
+
+        self.err.close()
+        self.err = StringIO()
+
+    def trap_all(self):
+        """Trap and log both stdout and stderr.
+
+        Cacthes and discards OutputTrapError exceptions raised."""
+        try:
+            self.trap_out()
+        except OutputTrapError:
+            pass
+        try:
+            self.trap_err()
+        except OutputTrapError:
+            pass
+
+    def release_all(self):
+        """Release both stdout and stderr.
+
+        Cacthes and discards OutputTrapError exceptions raised."""
+        try:
+            self.release_out()
+        except OutputTrapError:
+            pass
+        try:
+            self.release_err()
+        except OutputTrapError:
+            pass
+        
+    def summary_all(self):
+        """Return as a string the log from stdout and stderr, prepending a separator
+        to each (defined in __init__ as sum_sep)."""
+        sum = ''
+        sout = self.summary_out()
+        if sout:
+            sum += self.sum_sep + sout
+        serr = self.summary_err()
+        if serr:
+            sum += '\n'+self.sum_sep + serr
+        return sum
+
+    def flush_all(self):
+        """Flush stdout and stderr"""
+        self.flush_out()
+        self.flush_err()
+
+    # a few shorthands
+    trap = trap_all
+    release = release_all
+    summary = summary_all
+    flush = flush_all
+# end OutputTrap
+
+
+#****************************************************************************
+# Module testing. Incomplete, I'm lazy...
+
+def _test_all():
+
+    """Module testing functions, activated when the module is called as a
+    script (not imported)."""
+
+    # Put tests for this module in here.
+    # Define them as nested functions so they don't clobber the
+    # pydoc-generated docs
+
+    def _test_():
+        name = ''
+        print '#'*50+'\nRunning test for ' + name
+        # ...
+        print 'Finished test for '+ name +'\n'+'#'*50
+
+    def _test_OutputTrap():
+        trap = OutputTrap(name = 'Test Trap', sum_sep = '.'*50+'\n',
+                          out_head = 'SOut. ', err_head = 'SErr. ')
+
+        name = 'OutputTrap class'
+        print '#'*50+'\nRunning test for ' + name
+        print 'Trapping out'
+        trap.trap_out()
+        print >>sys.stdout, '>>stdout. stdout is trapped.'
+        print >>sys.stderr, '>>stderr. stdout is trapped.'
+        trap.release_out()
+        print trap.summary_out()
+
+        print 'Trapping err'
+        trap.trap_err()
+        print >>sys.stdout, '>>stdout. stderr is trapped.'
+        print >>sys.stderr, '>>stderr. stderr is trapped.'
+        trap.release_err()
+        print trap.summary_err()
+
+        print 'Trapping all (no flushing)'
+        trap.trap_all()
+        print >>sys.stdout, '>>stdout. stdout/err is trapped.'
+        print >>sys.stderr, '>>stderr. stdout/err is trapped.'
+        trap.release_all()
+        print trap.summary_all()
+
+        print 'Trapping all (flushing first)'
+        trap.flush()
+        trap.trap_all()
+        print >>sys.stdout, '>>stdout. stdout/err is trapped.'
+        print >>sys.stderr, '>>stderr. stdout/err is trapped.'
+        trap.release_all()
+        print trap.summary_all()
+        print 'Finished test for '+ name +'\n'+'#'*50
+
+    # call the actual tests here:
+    _test_OutputTrap()
+
+
+if __name__=="__main__":
+    # _test_all() # XXX BROKEN.
+    pass
+
+#************************ end of file <OutputTrap.py> ************************

IPython/Prompts.py

@@ -0,0 +1,574 b''
+# -*- coding: utf-8 -*-
+"""
+Classes for handling input/output prompts.
+
+$Id: Prompts.py 564 2005-03-26 22:43:58Z fperez $"""
+
+#*****************************************************************************
+#       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
+__version__ = Release.version
+
+#****************************************************************************
+# Required modules
+import __builtin__
+import os,sys,socket
+import time
+from pprint import pprint,pformat
+
+# IPython's own
+from IPython.genutils import *
+from IPython.Struct import Struct
+from IPython.Magic import Macro
+from IPython.Itpl import ItplNS
+from IPython import ColorANSI
+
+#****************************************************************************
+#Color schemes for Prompts.
+
+PromptColors = ColorANSI.ColorSchemeTable()
+InputColors = ColorANSI.InputTermColors  # just a shorthand
+Colors = ColorANSI.TermColors  # just a shorthand
+
+PromptColors.add_scheme(ColorANSI.ColorScheme(
+    'NoColor',
+    in_prompt  = InputColors.NoColor,  # Input prompt
+    in_number  = InputColors.NoColor,  # Input prompt number
+    in_prompt2 = InputColors.NoColor, # Continuation prompt
+    in_normal  = InputColors.NoColor,  # color off (usu. Colors.Normal)
+    
+    out_prompt = Colors.NoColor, # Output prompt
+    out_number = Colors.NoColor, # Output prompt number
+
+    normal = Colors.NoColor  # color off (usu. Colors.Normal)
+    ))
+# make some schemes as instances so we can copy them for modification easily:
+__PColLinux =  ColorANSI.ColorScheme(
+    'Linux',
+    in_prompt  = InputColors.Green,
+    in_number  = InputColors.LightGreen,
+    in_prompt2 = InputColors.Green,
+    in_normal  = InputColors.Normal,  # color off (usu. Colors.Normal)
+
+    out_prompt = Colors.Red,
+    out_number = Colors.LightRed,
+
+    normal = Colors.Normal
+    )
+# Don't forget to enter it into the table!
+PromptColors.add_scheme(__PColLinux)
+# Slightly modified Linux for light backgrounds
+__PColLightBG  = ColorANSI.ColorScheme('LightBG',**__PColLinux.colors.dict().copy())
+
+__PColLightBG.colors.update(
+    in_prompt  = InputColors.Blue,
+    in_number  = InputColors.LightBlue,
+    in_prompt2 = InputColors.Blue
+)
+PromptColors.add_scheme(__PColLightBG)
+
+del Colors,InputColors
+
+#-----------------------------------------------------------------------------
+def multiple_replace(dict, text):
+    """ Replace in 'text' all occurences of any key in the given
+    dictionary by its corresponding value.  Returns the new string."""
+
+    # Function by Xavier Defrang, originally found at:
+    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330
+
+    # Create a regular expression  from the dictionary keys
+    regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
+    # For each match, look-up corresponding value in dictionary
+    return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
+
+#-----------------------------------------------------------------------------
+# Special characters that can be used in prompt templates, mainly bash-like
+
+# If $HOME isn't defined (Windows), make it an absurd string so that it can
+# never be expanded out into '~'.  Basically anything which can never be a
+# reasonable directory name will do, we just want the $HOME -> '~' operation
+# to become a no-op.  We pre-compute $HOME here so it's not done on every
+# prompt call.
+
+# FIXME:
+
+# - This should be turned into a class which does proper namespace management,
+# since the prompt specials need to be evaluated in a certain namespace.
+# Currently it's just globals, which need to be managed manually by code
+# below.
+
+# - I also need to split up the color schemes from the prompt specials
+# somehow.  I don't have a clean design for that quite yet.
+
+HOME = os.environ.get("HOME","//////:::::ZZZZZ,,,~~~")
+
+# We precompute a few more strings here for the prompt_specials, which are
+# fixed once ipython starts.  This reduces the runtime overhead of computing
+# prompt strings.
+USER           = os.environ.get("USER")
+HOSTNAME       = socket.gethostname()
+HOSTNAME_SHORT = HOSTNAME.split(".")[0]
+ROOT_SYMBOL    = "$#"[os.name=='nt' or os.getuid()==0]
+
+prompt_specials_color = {
+    # Prompt/history count
+    '%n' : '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
+    '\\#': '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
+    # Prompt/history count, with the actual digits replaced by dots.  Used
+    # mainly in continuation prompts (prompt_in2)
+    '\\D': '${"."*len(str(self.cache.prompt_count))}',
+    # Current working directory
+    '\\w': '${os.getcwd()}',
+    # Current time
+    '\\t' : '${time.strftime("%H:%M:%S")}',
+    # Basename of current working directory.
+    # (use os.sep to make this portable across OSes)
+    '\\W' : '${os.getcwd().split("%s")[-1]}' % os.sep,
+    # These X<N> are an extension to the normal bash prompts.  They return
+    # N terms of the path, after replacing $HOME with '~'
+    '\\X0': '${os.getcwd().replace("%s","~")}' % HOME,
+    '\\X1': '${self.cwd_filt(1)}',
+    '\\X2': '${self.cwd_filt(2)}',
+    '\\X3': '${self.cwd_filt(3)}',
+    '\\X4': '${self.cwd_filt(4)}',
+    '\\X5': '${self.cwd_filt(5)}',
+    # Y<N> are similar to X<N>, but they show '~' if it's the directory
+    # N+1 in the list.  Somewhat like %cN in tcsh.
+    '\\Y0': '${self.cwd_filt2(0)}',
+    '\\Y1': '${self.cwd_filt2(1)}',
+    '\\Y2': '${self.cwd_filt2(2)}',
+    '\\Y3': '${self.cwd_filt2(3)}',
+    '\\Y4': '${self.cwd_filt2(4)}',
+    '\\Y5': '${self.cwd_filt2(5)}',
+    # Hostname up to first .
+    '\\h': HOSTNAME_SHORT,
+    # Full hostname
+    '\\H': HOSTNAME,
+    # Username of current user
+    '\\u': USER,
+    # Escaped '\'
+    '\\\\': '\\',
+    # Newline
+    '\\n': '\n',
+    # Carriage return
+    '\\r': '\r',
+    # Release version
+    '\\v': __version__,
+    # Root symbol ($ or #)
+    '\\$': ROOT_SYMBOL,
+    }
+
+# A copy of the prompt_specials dictionary but with all color escapes removed,
+# so we can correctly compute the prompt length for the auto_rewrite method.
+prompt_specials_nocolor = prompt_specials_color.copy()
+prompt_specials_nocolor['%n'] = '${self.cache.prompt_count}'
+prompt_specials_nocolor['\\#'] = '${self.cache.prompt_count}'
+
+# Add in all the InputTermColors color escapes as valid prompt characters.
+# They all get added as \\C_COLORNAME, so that we don't have any conflicts
+# with a color name which may begin with a letter used by any other of the
+# allowed specials.  This of course means that \\C will never be allowed for
+# anything else.
+input_colors = ColorANSI.InputTermColors
+for _color in dir(input_colors):
+    if _color[0] != '_':
+        c_name = '\\C_'+_color
+        prompt_specials_color[c_name] = getattr(input_colors,_color)
+        prompt_specials_nocolor[c_name] = ''
+
+# we default to no color for safety.  Note that prompt_specials is a global
+# variable used by all prompt objects.
+prompt_specials = prompt_specials_nocolor
+
+#-----------------------------------------------------------------------------
+def str_safe(arg):
+    """Convert to a string, without ever raising an exception.
+
+    If str(arg) fails, <ERROR: ... > is returned, where ... is the exception
+    error message."""
+    
+    try:
+        return str(arg)
+    except Exception,msg:
+        return '<ERROR: %s>' % msg
+
+class BasePrompt:
+    """Interactive prompt similar to Mathematica's."""
+    def __init__(self,cache,sep,prompt,pad_left=False):
+
+        # Hack: we access information about the primary prompt through the
+        # cache argument.  We need this, because we want the secondary prompt
+        # to be aligned with the primary one.  Color table info is also shared
+        # by all prompt classes through the cache.  Nice OO spaghetti code!
+        self.cache = cache
+        self.sep = sep
+        
+        # regexp to count the number of spaces at the end of a prompt
+        # expression, useful for prompt auto-rewriting
+        self.rspace = re.compile(r'(\s*)$')
+        # Flag to left-pad prompt strings to match the length of the primary
+        # prompt
+        self.pad_left = pad_left
+        # Set template to create each actual prompt (where numbers change)
+        self.p_template = prompt
+        self.set_p_str()
+
+    def set_p_str(self):
+        """ Set the interpolating prompt strings.
+
+        This must be called every time the color settings change, because the
+        prompt_specials global may have changed."""
+
+        import os,time  # needed in locals for prompt string handling
+        loc = locals()
+        self.p_str = ItplNS('%s%s%s' %
+                            ('${self.sep}${self.col_p}',
+                             multiple_replace(prompt_specials, self.p_template),
+                             '${self.col_norm}'),self.cache.user_ns,loc)
+        
+        self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
+                                                     self.p_template),
+                                    self.cache.user_ns,loc)
+
+    def write(self,msg):  # dbg
+        sys.stdout.write(msg)
+        return ''
+
+    def __str__(self):
+        """Return a string form of the prompt.
+
+        This for is useful for continuation and output prompts, since it is
+        left-padded to match lengths with the primary one (if the
+        self.pad_left attribute is set)."""
+
+        out_str = str_safe(self.p_str)
+        if self.pad_left:
+            # We must find the amount of padding required to match lengths,
+            # taking the color escapes (which are invisible on-screen) into
+            # account.
+            esc_pad = len(out_str) - len(str_safe(self.p_str_nocolor))
+            format = '%%%ss' % (len(str(self.cache.last_prompt))+esc_pad)
+            return format % out_str
+        else:
+            return out_str
+
+    # these path filters are put in as methods so that we can control the
+    # namespace where the prompt strings get evaluated
+    def cwd_filt(self,depth):
+        """Return the last depth elements of the current working directory.
+
+        $HOME is always replaced with '~'.
+        If depth==0, the full path is returned."""
+
+        cwd = os.getcwd().replace(HOME,"~")
+        out = os.sep.join(cwd.split(os.sep)[-depth:])
+        if out:
+            return out
+        else:
+            return os.sep
+
+    def cwd_filt2(self,depth):
+        """Return the last depth elements of the current working directory.
+
+        $HOME is always replaced with '~'.
+        If depth==0, the full path is returned."""
+
+        cwd = os.getcwd().replace(HOME,"~").split(os.sep)
+        if '~' in cwd and len(cwd) == depth+1:
+            depth += 1
+        out = os.sep.join(cwd[-depth:])
+        if out:
+            return out
+        else:
+            return os.sep
+
+class Prompt1(BasePrompt):
+    """Input interactive prompt similar to Mathematica's."""
+
+    def __init__(self,cache,sep='\n',prompt='In [\\#]: ',pad_left=True):
+        BasePrompt.__init__(self,cache,sep,prompt,pad_left)
+
+    def set_colors(self):
+        self.set_p_str()
+        Colors = self.cache.color_table.active_colors # shorthand
+        self.col_p = Colors.in_prompt
+        self.col_num = Colors.in_number
+        self.col_norm = Colors.in_normal
+        # We need a non-input version of these escapes for the '--->'
+        # auto-call prompts used in the auto_rewrite() method.
+        self.col_p_ni = self.col_p.replace('\001','').replace('\002','') 
+        self.col_norm_ni = Colors.normal        
+        
+    def __str__(self):
+        self.cache.prompt_count += 1
+        self.cache.last_prompt = str_safe(self.p_str_nocolor).split('\n')[-1]
+        return str_safe(self.p_str)
+
+    def auto_rewrite(self):
+        """Print a string of the form '--->' which lines up with the previous
+        input string. Useful for systems which re-write the user input when
+        handling automatically special syntaxes."""
+
+        curr = str(self.cache.last_prompt)
+        nrspaces = len(self.rspace.search(curr).group())
+        return '%s%s>%s%s' % (self.col_p_ni,'-'*(len(curr)-nrspaces-1),
+                              ' '*nrspaces,self.col_norm_ni)
+
+class PromptOut(BasePrompt):
+    """Output interactive prompt similar to Mathematica's."""
+
+    def __init__(self,cache,sep='',prompt='Out[\\#]: ',pad_left=True):
+        BasePrompt.__init__(self,cache,sep,prompt,pad_left)
+        if not self.p_template:
+            self.__str__ = lambda: ''
+
+    def set_colors(self):
+        self.set_p_str()
+        Colors = self.cache.color_table.active_colors # shorthand
+        self.col_p = Colors.out_prompt
+        self.col_num = Colors.out_number
+        self.col_norm = Colors.normal
+
+class Prompt2(BasePrompt):
+    """Interactive continuation prompt."""
+    
+    def __init__(self,cache,prompt='   .\\D.: ',pad_left=True):
+        self.cache = cache
+        self.p_template = prompt
+        self.pad_left = pad_left
+        self.set_p_str()
+
+    def set_p_str(self):
+        import os,time  # needed in locals for prompt string handling
+        loc = locals()
+        self.p_str = ItplNS('%s%s%s' %
+                            ('${self.col_p2}',
+                             multiple_replace(prompt_specials, self.p_template),
+                             '$self.col_norm'),
+                            self.cache.user_ns,loc)
+        self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
+                                                     self.p_template),
+                                    self.cache.user_ns,loc)
+
+    def set_colors(self):
+        self.set_p_str()
+        Colors = self.cache.color_table.active_colors
+        self.col_p2 = Colors.in_prompt2
+        self.col_norm = Colors.in_normal
+        # FIXME (2004-06-16) HACK: prevent crashes for users who haven't
+        # updated their prompt_in2 definitions.  Remove eventually.
+        self.col_p = Colors.out_prompt
+        self.col_num = Colors.out_number
+
+#-----------------------------------------------------------------------------
+class CachedOutput:
+    """Class for printing output from calculations while keeping a cache of
+    reults. It dynamically creates global variables prefixed with _ which
+    contain these results.
+
+    Meant to be used as a sys.displayhook replacement, providing numbered
+    prompts and cache services.
+
+    Initialize with initial and final values for cache counter (this defines
+    the maximum size of the cache."""
+
+    def __init__(self,cache_size,Pprint,colors='NoColor',input_sep='\n',
+                 output_sep='\n',output_sep2='',user_ns={},
+                 ps1 = None, ps2 = None,ps_out = None,
+                 input_hist = None,pad_left=True):
+
+        cache_size_min = 20
+        if cache_size <= 0:
+            self.do_full_cache = 0
+            cache_size = 0
+        elif cache_size < cache_size_min:
+            self.do_full_cache = 0
+            cache_size = 0
+            warn('caching was disabled (min value for cache size is %s).' %
+                 cache_size_min,level=3)
+        else:
+            self.do_full_cache = 1
+
+        self.cache_size = cache_size
+        self.input_sep = input_sep
+
+        # we need a reference to the user-level namespace
+        self.user_ns = user_ns
+        # and to the user's input
+        self.input_hist = input_hist
+
+        # Set input prompt strings and colors
+        if cache_size == 0:
+            if ps1.find('%n') > -1 or ps1.find('\\#') > -1: ps1 = '>>> '
+            if ps2.find('%n') > -1 or ps2.find('\\#') > -1: ps2 = '... '
+        self.ps1_str = self._set_prompt_str(ps1,'In [\\#]: ','>>> ')
+        self.ps2_str = self._set_prompt_str(ps2,'   .\\D.: ','... ')
+        self.ps_out_str = self._set_prompt_str(ps_out,'Out[\\#]: ','')
+
+        self.prompt1 = Prompt1(self,sep=input_sep,prompt=self.ps1_str,
+                               pad_left=pad_left)
+        self.prompt2 = Prompt2(self,prompt=self.ps2_str,pad_left=pad_left)
+        self.prompt_out = PromptOut(self,sep='',prompt=self.ps_out_str,
+                                    pad_left=pad_left)
+        self.color_table = PromptColors
+        self.set_colors(colors)
+
+        # other more normal stuff
+        # b/c each call to the In[] prompt raises it by 1, even the first.
+        self.prompt_count = 0
+        self.cache_count = 1
+        # Store the last prompt string each time, we need it for aligning
+        # continuation and auto-rewrite prompts
+        self.last_prompt = ''
+        self.entries = [None]  # output counter starts at 1 for the user
+        self.Pprint = Pprint
+        self.output_sep = output_sep
+        self.output_sep2 = output_sep2
+        self._,self.__,self.___ = '','',''
+        self.pprint_types = map(type,[(),[],{}])
+        
+        # these are deliberately global:
+        to_user_ns = {'_':self._,'__':self.__,'___':self.___}
+        self.user_ns.update(to_user_ns)
+
+    def _set_prompt_str(self,p_str,cache_def,no_cache_def):
+        if p_str is None:
+            if self.do_full_cache:
+                return cache_def
+            else:
+                return no_cache_def
+        else:
+            return p_str
+                
+    def set_colors(self,colors):
+        """Set the active color scheme and configure colors for the three
+        prompt subsystems."""
+
+        # FIXME: the prompt_specials global should be gobbled inside this
+        # class instead.  Do it when cleaning up the whole 3-prompt system.
+        global prompt_specials
+        if colors.lower()=='nocolor':
+            prompt_specials = prompt_specials_nocolor
+        else:
+            prompt_specials = prompt_specials_color
+        
+        self.color_table.set_active_scheme(colors)
+        self.prompt1.set_colors()
+        self.prompt2.set_colors()
+        self.prompt_out.set_colors()
+
+    def __call__(self,arg=None):
+        """Printing with history cache management.
+        
+        This is invoked everytime the interpreter needs to print, and is
+        activated by setting the variable sys.displayhook to it."""
+
+        # If something injected a '_' variable in __builtin__, delete
+        # ipython's automatic one so we don't clobber that.  gettext() in
+        # particular uses _, so we need to stay away from it.
+        if '_' in __builtin__.__dict__:
+            try:
+                del self.user_ns['_']
+            except KeyError:
+                pass
+        if arg is not None:
+            # first handle the cache and counters
+            self.update(arg)
+            # do not print output if input ends in ';'
+            if self.input_hist[self.prompt_count].endswith(';\n'):
+                return
+            # don't use print, puts an extra space
+            Term.cout.write(self.output_sep)
+            if self.do_full_cache:
+                Term.cout.write(str(self.prompt_out))
+
+            if isinstance(arg,Macro):
+                print 'Executing Macro...'
+                # in case the macro takes a long time to execute
+                Term.cout.flush()
+                exec arg.value in self.user_ns
+                return None
+
+            # and now call a possibly user-defined print mechanism
+            self.display(arg)
+            Term.cout.write(self.output_sep2)
+            Term.cout.flush()
+
+    def _display(self,arg):
+        """Default printer method, uses pprint.
+
+        This can be over-ridden by the users to implement special formatting
+        of certain types of output."""
+
+        if self.Pprint:
+            # The following is an UGLY kludge, b/c python fails to properly
+            # identify instances of classes imported in the user namespace
+            # (they have different memory locations, I guess). Structs are
+            # essentially dicts but pprint doesn't know what to do with them.
+            try:
+                if arg.__class__.__module__ == 'Struct' and \
+                   arg.__class__.__name__ == 'Struct':
+                    out = 'Struct:\n%s' % pformat(arg.dict())
+                else:
+                    out = pformat(arg)
+            except:
+                out = pformat(arg)
+            if '\n' in out:
+                # So that multi-line strings line up with the left column of
+                # the screen, instead of having the output prompt mess up
+                # their first line.                
+                Term.cout.write('\n')
+            print >>Term.cout, out
+        else:
+            print >>Term.cout, arg
+
+    # Assign the default display method:
+    display = _display
+
+    def update(self,arg):
+        #print '***cache_count', self.cache_count # dbg
+        if self.cache_count >= self.cache_size and self.do_full_cache:
+            self.flush()
+        # Don't overwrite '_' and friends if '_' is in __builtin__ (otherwise
+        # we cause buggy behavior for things like gettext).
+        if '_' not in __builtin__.__dict__:
+            self.___ = self.__
+            self.__ = self._
+            self._ = arg
+            self.user_ns.update({'_':self._,'__':self.__,'___':self.___})
+            
+        # hackish access to top-level  namespace to create _1,_2... dynamically
+        to_main = {}
+        if self.do_full_cache:
+            self.cache_count += 1
+            self.entries.append(arg)
+            new_result = '_'+`self.prompt_count`
+            to_main[new_result] = self.entries[-1]
+        self.user_ns.update(to_main)
+        self.user_ns['_oh'][self.prompt_count] = arg
+
+    def flush(self):
+        if not self.do_full_cache:
+            raise ValueError,"You shouldn't have reached the cache flush "\
+                  "if full caching is not enabled!"
+        warn('Output cache limit (currently '+\
+              `self.cache_count`+' entries) hit.\n'
+             'Flushing cache and resetting history counter...\n'
+             'The only history variables available will be _,__,___ and _1\n'
+             'with the current result.')
+        # delete auto-generated vars from global namespace
+        for n in range(1,self.prompt_count + 1):
+            key = '_'+`n`
+            try:
+                del self.user_ns[key]
+            except: pass
+        self.prompt_count = 1
+        self.cache_count = 1

IPython/PyColorize.py

@@ -0,0 +1,255 b''
+# -*- coding: utf-8 -*-
+"""
+    Class and program to colorize python source code for ANSI terminals.
+
+    Based on an HTML code highlighter by Jurgen Hermann found at:
+    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52298
+
+    Modifications by Fernando Perez ([e-mail]).
+
+    Information on the original HTML highlighter follows:
+    
+    MoinMoin - Python Source Parser
+
+    Title:olorize Python source using the built-in tokenizer
+           
+    Submitter: Jurgen Hermann
+    Last Updated:2001/04/06
+           
+    Version no:1.2
+
+    Description:
+
+    This code is part of MoinMoin (http://moin.sourceforge.net/) and converts
+    Python source code to HTML markup, rendering comments, keywords,
+    operators, numeric and string literals in different colors.
+
+    It shows how to use the built-in keyword, token and tokenize modules to
+    scan Python source code and re-emit it with no changes to its original
+    formatting (which is the hard part).
+
+    $Id: PyColorize.py 485 2005-01-27 19:15:39Z fperez $"""
+
+__all__ = ['ANSICodeColors','Parser']
+
+_scheme_default = 'Linux'
+
+# Imports
+import string, sys, os, cStringIO
+import keyword, token, tokenize
+
+from IPython.ColorANSI import *
+
+#############################################################################
+### Python Source Parser (does Hilighting)
+#############################################################################
+
+_KEYWORD = token.NT_OFFSET + 1
+_TEXT    = token.NT_OFFSET + 2
+
+#****************************************************************************
+# Builtin color schemes
+
+Colors = TermColors  # just a shorthand
+
+# Build a few color schemes
+NoColor = ColorScheme(
+    'NoColor',{
+    token.NUMBER     : Colors.NoColor,
+    token.OP         : Colors.NoColor,
+    token.STRING     : Colors.NoColor,
+    tokenize.COMMENT : Colors.NoColor,
+    token.NAME       : Colors.NoColor,
+    token.ERRORTOKEN : Colors.NoColor,
+
+    _KEYWORD         : Colors.NoColor,
+    _TEXT            : Colors.NoColor,
+
+    'normal'         : Colors.NoColor  # color off (usu. Colors.Normal)
+    }  )
+
+LinuxColors = ColorScheme(
+    'Linux',{
+    token.NUMBER     : Colors.LightCyan,
+    token.OP         : Colors.Yellow,
+    token.STRING     : Colors.LightBlue,
+    tokenize.COMMENT : Colors.LightRed,
+    token.NAME       : Colors.White,
+    token.ERRORTOKEN : Colors.Red,
+
+    _KEYWORD         : Colors.LightGreen,
+    _TEXT            : Colors.Yellow,
+
+    'normal'         : Colors.Normal  # color off (usu. Colors.Normal)
+    } )
+
+LightBGColors = ColorScheme(
+    'LightBG',{
+    token.NUMBER     : Colors.Cyan,
+    token.OP         : Colors.Blue,
+    token.STRING     : Colors.Blue,
+    tokenize.COMMENT : Colors.Red,
+    token.NAME       : Colors.Black,
+    token.ERRORTOKEN : Colors.Red,
+
+    _KEYWORD         : Colors.Green,
+    _TEXT            : Colors.Blue,
+
+    'normal'         : Colors.Normal  # color off (usu. Colors.Normal)
+    }  )
+
+# Build table of color schemes (needed by the parser)
+ANSICodeColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
+                                  _scheme_default)
+
+class Parser:
+    """ Format colored Python source.
+    """
+
+    def __init__(self, color_table=None,out = sys.stdout):
+        """ Create a parser with a specified color table and output channel.
+
+        Call format() to process code.
+        """
+        self.color_table = color_table and color_table or ANSICodeColors
+        self.out = out
+
+    def format(self, raw, out = None, scheme = ''):
+        """ Parse and send the colored source.
+
+        If out and scheme are not specified, the defaults (given to
+        constructor) are used.
+
+        out should be a file-type object. Optionally, out can be given as the
+        string 'str' and the parser will automatically return the output in a
+        string."""
+        
+        self.raw = string.strip(string.expandtabs(raw))
+        string_output = 0
+        if out == 'str' or self.out == 'str':
+            out_old = self.out
+            self.out = cStringIO.StringIO()
+            string_output = 1
+        elif out is not None:
+            self.out = out
+        # local shorthand
+        colors = self.color_table[scheme].colors
+        self.colors = colors # put in object so __call__ sees it
+        # store line offsets in self.lines
+        self.lines = [0, 0]
+        pos = 0
+        while 1:
+            pos = string.find(self.raw, '\n', pos) + 1
+            if not pos: break
+            self.lines.append(pos)
+        self.lines.append(len(self.raw))
+
+        # parse the source and write it
+        self.pos = 0
+        text = cStringIO.StringIO(self.raw)
+        #self.out.write('<pre><font face="Courier New">')
+        try:
+            tokenize.tokenize(text.readline, self)
+        except tokenize.TokenError, ex:
+            msg = ex[0]
+            line = ex[1][0]
+            self.out.write("%s\n\n*** ERROR: %s%s%s\n" %
+                           (colors[token.ERRORTOKEN],
+                            msg, self.raw[self.lines[line]:],
+                            colors.normal)
+                           )
+        self.out.write(colors.normal+'\n')
+        if string_output:
+            output = self.out.getvalue()
+            self.out = out_old
+            return output
+
+    def __call__(self, toktype, toktext, (srow,scol), (erow,ecol), line):
+        """ Token handler, with syntax highlighting."""
+
+        # local shorthand
+        colors = self.colors
+
+        # line separator, so this works across platforms
+        linesep = os.linesep
+
+        # calculate new positions
+        oldpos = self.pos
+        newpos = self.lines[srow] + scol
+        self.pos = newpos + len(toktext)
+
+        # handle newlines
+        if toktype in [token.NEWLINE, tokenize.NL]:
+            self.out.write(linesep)
+            return
+
+        # send the original whitespace, if needed
+        if newpos > oldpos:
+            self.out.write(self.raw[oldpos:newpos])
+
+        # skip indenting tokens
+        if toktype in [token.INDENT, token.DEDENT]:
+            self.pos = newpos
+            return
+
+        # map token type to a color group
+        if token.LPAR <= toktype and toktype <= token.OP:
+            toktype = token.OP
+        elif toktype == token.NAME and keyword.iskeyword(toktext):
+            toktype = _KEYWORD
+        color = colors.get(toktype, colors[_TEXT])
+
+        #print '<%s>' % toktext,    # dbg
+
+        # Triple quoted strings must be handled carefully so that backtracking
+        # in pagers works correctly. We need color terminators on _each_ line.
+        if linesep in toktext:
+            toktext = toktext.replace(linesep, '%s%s%s' %
+                                      (colors.normal,linesep,color))
+
+        # send text
+        self.out.write('%s%s%s' % (color,toktext,colors.normal))
+            
+def main():
+    """Colorize a python file using ANSI color escapes and print to stdout.
+
+    Usage:
+      %s [-s scheme] filename
+
+    Options:
+
+      -s scheme: give the color scheme to use. Currently only 'Linux'
+      (default) and 'LightBG' and 'NoColor' are implemented (give without
+      quotes).  """  
+
+    def usage():
+        print >> sys.stderr, main.__doc__ % sys.argv[0]
+        sys.exit(1)
+        
+    # FIXME: rewrite this to at least use getopt
+    try:
+        if sys.argv[1] == '-s':
+            scheme_name = sys.argv[2]
+            del sys.argv[1:3]
+        else:
+            scheme_name = _scheme_default
+        
+    except:
+        usage()
+
+    try:
+        fname = sys.argv[1]
+    except:
+        usage()
+        
+    # write colorized version to stdout
+    parser = Parser()
+    try:
+        parser.format(file(fname).read(),scheme = scheme_name)
+    except IOError,msg:
+        # if user reads through a pager and quits, don't print traceback
+        if msg.args != (32,'Broken pipe'):
+            raise
+
+if __name__ == "__main__":
+    main()

IPython/Release.py

@@ -0,0 +1,69 b''
+# -*- coding: utf-8 -*-
+"""Release data for the IPython project.
+
+$Id: Release.py 605 2005-06-09 14:09:03Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2005 Fernando Perez <[e-mail]>
+#
+#       Copyright (c) 2001 Janko Hauser <[e-mail]> and Nathaniel Gray
+#       <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+# Name of the package for release purposes.  This is the name which labels
+# the tarballs and RPMs made by distutils, so it's best to lowercase it.
+name = 'ipython'
+
+# For versions with substrings (like 0.6.7_rc1), use _ but NOT -, since
+# bdist_rpm chokes on dashes in the version string.
+version = '0.6.16_cvs'
+
+description = "An enhanced interactive Python shell."
+
+long_description = \
+"""
+IPython provides a replacement for the interactive Python interpreter with
+extra functionality.
+
+Main features:
+
+ * Comprehensive object introspection.
+
+ * Input history, persistent across sessions.
+
+ * Caching of output results during a session with automatically generated
+   references.
+
+ * Readline based name completion.
+
+ * Extensible system of 'magic' commands for controlling the environment and
+   performing many tasks related either to IPython or the operating system.
+
+ * Configuration system with easy switching between different setups (simpler
+   than changing $PYTHONSTARTUP environment variables every time).
+
+ * Session logging and reloading.
+
+ * Extensible syntax processing for special purpose situations.
+
+ * Access to the system shell with user-extensible alias system.
+
+ * Easily embeddable in other Python programs.
+
+ * Integrated access to the pdb debugger and the Python profiler. """
+
+license = 'BSD'
+
+authors = {'Fernando' : ('Fernando Perez','[e-mail]'),
+           'Janko'    : ('Janko Hauser','[e-mail]'),
+           'Nathan'   : ('Nathaniel Gray','[e-mail]')
+           }
+
+url = 'http://ipython.scipy.org'
+
+platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME']
+
+keywords = ['Interactive','Interpreter','Shell']

IPython/Shell.py

@@ -0,0 +1,894 b''
+# -*- coding: utf-8 -*-
+"""IPython Shell classes.
+
+All the matplotlib support code was co-developed with John Hunter,
+matplotlib's author.
+
+$Id: Shell.py 605 2005-06-09 14:09:03Z fperez $"""
+
+#*****************************************************************************
+#       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
+
+# Code begins
+import __main__
+import __builtin__
+import sys
+import os
+import code
+import threading
+import signal
+
+import IPython
+from IPython.iplib import InteractiveShell
+from IPython.ipmaker import make_IPython
+from IPython.genutils import Term,warn,error,flag_calls
+from IPython.Struct import Struct
+from IPython.Magic import Magic
+from IPython import ultraTB
+
+# global flag to pass around information about Ctrl-C without exceptions
+KBINT = False
+
+# global flag to turn on/off Tk support.
+USE_TK = False
+
+#-----------------------------------------------------------------------------
+# This class is trivial now, but I want to have it in to publish a clean
+# interface. Later when the internals are reorganized, code that uses this
+# shouldn't have to change.
+
+class IPShell:
+    """Create an IPython instance."""
+    
+    def __init__(self,argv=None,user_ns=None,debug=1,
+                 shell_class=InteractiveShell):
+        self.IP = make_IPython(argv,user_ns=user_ns,debug=debug,
+                               shell_class=shell_class)
+
+    def mainloop(self,sys_exit=0,banner=None):
+        self.IP.mainloop(banner)
+        if sys_exit:
+            sys.exit()
+
+#-----------------------------------------------------------------------------
+class IPShellEmbed:
+    """Allow embedding an IPython shell into a running program.
+
+    Instances of this class are callable, with the __call__ method being an
+    alias to the embed() method of an InteractiveShell instance.
+
+    Usage (see also the example-embed.py file for a running example):
+
+    ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
+
+    - argv: list containing valid command-line options for IPython, as they
+    would appear in sys.argv[1:].
+
+    For example, the following command-line options:
+
+      $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
+
+    would be passed in the argv list as:
+
+      ['-prompt_in1','Input <\\#>','-colors','LightBG']
+
+    - banner: string which gets printed every time the interpreter starts.
+
+    - exit_msg: string which gets printed every time the interpreter exits.
+
+    - rc_override: a dict or Struct of configuration options such as those
+    used by IPython. These options are read from your ~/.ipython/ipythonrc
+    file when the Shell object is created. Passing an explicit rc_override
+    dict with any options you want allows you to override those values at
+    creation time without having to modify the file. This way you can create
+    embeddable instances configured in any way you want without editing any
+    global files (thus keeping your interactive IPython configuration
+    unchanged).
+
+    Then the ipshell instance can be called anywhere inside your code:
+    
+    ipshell(header='') -> Opens up an IPython shell.
+
+    - header: string printed by the IPython shell upon startup. This can let
+    you know where in your code you are when dropping into the shell. Note
+    that 'banner' gets prepended to all calls, so header is used for
+    location-specific information.
+
+    For more details, see the __call__ method below.
+
+    When the IPython shell is exited with Ctrl-D, normal program execution
+    resumes.
+
+    This functionality was inspired by a posting on comp.lang.python by cmkl
+    <[e-mail]> on Dec. 06/01 concerning similar uses of pyrepl, and
+    by the IDL stop/continue commands."""
+
+    def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None):
+        """Note that argv here is a string, NOT a list."""
+        self.set_banner(banner)
+        self.set_exit_msg(exit_msg)
+        self.set_dummy_mode(0)
+
+        # sys.displayhook is a global, we need to save the user's original
+        # Don't rely on __displayhook__, as the user may have changed that.
+        self.sys_displayhook_ori = sys.displayhook
+
+        # save readline completer status
+        try:
+            #print 'Save completer',sys.ipcompleter  # dbg
+            self.sys_ipcompleter_ori = sys.ipcompleter
+        except:
+            pass # not nested with IPython
+        
+        # FIXME. Passing user_ns breaks namespace handling.
+        #self.IP = make_IPython(argv,user_ns=__main__.__dict__)
+        self.IP = make_IPython(argv,rc_override=rc_override,embedded=True)
+
+        self.IP.name_space_init()
+        # mark this as an embedded instance so we know if we get a crash
+        # post-mortem
+        self.IP.rc.embedded = 1
+        # copy our own displayhook also
+        self.sys_displayhook_embed = sys.displayhook
+        # and leave the system's display hook clean
+        sys.displayhook = self.sys_displayhook_ori
+        # don't use the ipython crash handler so that user exceptions aren't
+        # trapped
+        sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
+                                             mode = self.IP.rc.xmode,
+                                             call_pdb = self.IP.rc.pdb)
+        self.restore_system_completer()
+
+    def restore_system_completer(self):
+        """Restores the readline completer which was in place.
+
+        This allows embedded IPython within IPython not to disrupt the
+        parent's completion.
+        """
+        
+        try:
+            self.IP.readline.set_completer(self.sys_ipcompleter_ori)
+            sys.ipcompleter = self.sys_ipcompleter_ori
+        except:
+            pass
+
+    def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
+        """Activate the interactive interpreter.
+
+        __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
+        the interpreter shell with the given local and global namespaces, and
+        optionally print a header string at startup.
+
+        The shell can be globally activated/deactivated using the
+        set/get_dummy_mode methods. This allows you to turn off a shell used
+        for debugging globally.
+
+        However, *each* time you call the shell you can override the current
+        state of dummy_mode with the optional keyword parameter 'dummy'. For
+        example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
+        can still have a specific call work by making it as IPShell(dummy=0).
+
+        The optional keyword parameter dummy controls whether the call
+        actually does anything.  """
+
+        # Allow the dummy parameter to override the global __dummy_mode
+        if dummy or (dummy != 0 and self.__dummy_mode):
+            return
+
+        # Set global subsystems (display,completions) to our values
+        sys.displayhook = self.sys_displayhook_embed
+        if self.IP.has_readline:
+            self.IP.readline.set_completer(self.IP.Completer.complete)
+
+        if self.banner and header:
+            format = '%s\n%s\n'
+        else:
+            format = '%s%s\n'
+        banner =  format % (self.banner,header)
+
+        # Call the embedding code with a stack depth of 1 so it can skip over
+        # our call and get the original caller's namespaces.
+        self.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
+
+        if self.exit_msg:
+            print self.exit_msg
+            
+        # Restore global systems (display, completion)
+        sys.displayhook = self.sys_displayhook_ori
+        self.restore_system_completer()
+    
+    def set_dummy_mode(self,dummy):
+        """Sets the embeddable shell's dummy mode parameter.
+
+        set_dummy_mode(dummy): dummy = 0 or 1.
+
+        This parameter is persistent and makes calls to the embeddable shell
+        silently return without performing any action. This allows you to
+        globally activate or deactivate a shell you're using with a single call.
+
+        If you need to manually"""
+
+        if dummy not in [0,1]:
+            raise ValueError,'dummy parameter must be 0 or 1'
+        self.__dummy_mode = dummy
+
+    def get_dummy_mode(self):
+        """Return the current value of the dummy mode parameter.
+        """
+        return self.__dummy_mode
+    
+    def set_banner(self,banner):
+        """Sets the global banner.
+
+        This banner gets prepended to every header printed when the shell
+        instance is called."""
+
+        self.banner = banner
+
+    def set_exit_msg(self,exit_msg):
+        """Sets the global exit_msg.
+
+        This exit message gets printed upon exiting every time the embedded
+        shell is called. It is None by default. """
+
+        self.exit_msg = exit_msg
+
+#-----------------------------------------------------------------------------
+def sigint_handler (signum,stack_frame):
+    """Sigint handler for threaded apps.
+
+    This is a horrible hack to pass information about SIGINT _without_ using
+    exceptions, since I haven't been able to properly manage cross-thread
+    exceptions in GTK/WX.  In fact, I don't think it can be done (or at least
+    that's my understanding from a c.l.py thread where this was discussed)."""
+
+    global KBINT
+    
+    print '\nKeyboardInterrupt - Press <Enter> to continue.',
+    Term.cout.flush()
+    # Set global flag so that runsource can know that Ctrl-C was hit
+    KBINT = True
+
+class MTInteractiveShell(InteractiveShell):
+    """Simple multi-threaded shell."""
+
+    # Threading strategy taken from:
+    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
+    # McErlean and John Finlay.  Modified with corrections by Antoon Pardon,
+    # from the pygtk mailing list, to avoid lockups with system calls.
+
+    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
+                 user_ns = None, banner2='',**kw):
+        """Similar to the normal InteractiveShell, but with threading control"""
+        
+        IPython.iplib.InteractiveShell.__init__(self,name,usage,rc,user_ns,banner2)
+
+        # Locking control variable
+        self.thread_ready = threading.Condition()
+
+        # Stuff to do at closing time
+        self._kill = False
+        on_kill = kw.get('on_kill')
+        if on_kill is None:
+            on_kill = []
+        # Check that all things to kill are callable:
+        for t in on_kill:
+            if not callable(t):
+                raise TypeError,'on_kill must be a list of callables'
+        self.on_kill = on_kill
+
+    def runsource(self, source, filename="<input>", symbol="single"):
+        """Compile and run some source in the interpreter.
+
+        Modified version of code.py's runsource(), to handle threading issues.
+        See the original for full docstring details."""
+
+        global KBINT
+        
+        # If Ctrl-C was typed, we reset the flag and return right away
+        if KBINT:
+            KBINT = False
+            return False
+        
+        try:
+            code = self.compile(source, filename, symbol)
+        except (OverflowError, SyntaxError, ValueError):
+            # Case 1
+            self.showsyntaxerror(filename)
+            return False
+
+        if code is None:
+            # Case 2
+            return True
+
+        # Case 3
+        # Store code in self, so the execution thread can handle it
+        self.thread_ready.acquire()
+        self.code_to_run_src = source
+        self.code_to_run = code
+        self.thread_ready.wait()  # Wait until processed in timeout interval
+        self.thread_ready.release()
+
+        return False
+
+    def runcode(self):
+        """Execute a code object.
+
+        Multithreaded wrapper around IPython's runcode()."""
+
+        # lock thread-protected stuff
+        self.thread_ready.acquire()
+
+        # Install sigint handler
+        try:
+            signal.signal(signal.SIGINT, sigint_handler)
+        except SystemError:
+            # This happens under Windows, which seems to have all sorts
+            # of problems with signal handling.  Oh well...
+            pass
+
+        if self._kill:
+            print >>Term.cout, 'Closing threads...',
+            Term.cout.flush()
+            for tokill in self.on_kill:
+                tokill()
+            print >>Term.cout, 'Done.'
+
+        # Run pending code by calling parent class
+        if self.code_to_run is not None:
+            self.thread_ready.notify()
+            InteractiveShell.runcode(self,self.code_to_run)
+            
+        # We're done with thread-protected variables
+        self.thread_ready.release()
+        # This MUST return true for gtk threading to work
+        return True
+
+    def kill (self):
+        """Kill the thread, returning when it has been shut down."""
+        self.thread_ready.acquire()
+        self._kill = True
+        self.thread_ready.release()
+
+class MatplotlibShellBase:
+    """Mixin class to provide the necessary modifications to regular IPython
+    shell classes for matplotlib support.
+
+    Given Python's MRO, this should be used as the FIRST class in the
+    inheritance hierarchy, so that it overrides the relevant methods."""
+    
+    def _matplotlib_config(self,name):
+        """Return various items needed to setup the user's shell with matplotlib"""
+
+        # Initialize matplotlib to interactive mode always
+        import matplotlib
+        from matplotlib import backends
+        matplotlib.interactive(True)
+
+        def use(arg):
+            """IPython wrapper for matplotlib's backend switcher.
+
+            In interactive use, we can not allow switching to a different
+            interactive backend, since thread conflicts will most likely crash
+            the python interpreter.  This routine does a safety check first,
+            and refuses to perform a dangerous switch.  It still allows
+            switching to non-interactive backends."""
+
+            if arg in backends.interactive_bk and arg != self.mpl_backend:
+                m=('invalid matplotlib backend switch.\n'
+                   'This script attempted to switch to the interactive '
+                   'backend: `%s`\n'
+                   'Your current choice of interactive backend is: `%s`\n\n'
+                   'Switching interactive matplotlib backends at runtime\n'
+                   'would crash the python interpreter, '
+                   'and IPython has blocked it.\n\n'
+                   'You need to either change your choice of matplotlib backend\n'
+                   'by editing your .matplotlibrc file, or run this script as a \n'
+                   'standalone file from the command line, not using IPython.\n' %
+                   (arg,self.mpl_backend) )
+                raise RuntimeError, m
+            else:
+                self.mpl_use(arg)
+                self.mpl_use._called = True
+        
+        self.matplotlib = matplotlib
+
+        # Take control of matplotlib's error handling, which can normally
+        # lock up the python interpreter when raw_input() is called
+        import matplotlib.backends as backend
+        backend.error_msg = error
+        
+        # we'll handle the mainloop, tell show not to
+        import matplotlib.backends
+        matplotlib.backends.show._needmain = False
+        self.mpl_backend = matplotlib.rcParams['backend']
+
+        # we also need to block switching of interactive backends by use()
+        self.mpl_use = matplotlib.use
+        self.mpl_use._called = False
+        # overwrite the original matplotlib.use with our wrapper
+        matplotlib.use = use
+
+        # We need to detect at runtime whether show() is called by the user.
+        # For this, we wrap it into a decorator which adds a 'called' flag.
+        backend.draw_if_interactive = flag_calls(backend.draw_if_interactive)
+
+        # This must be imported last in the matplotlib series, after
+        # backend/interactivity choices have been made
+        try:
+            import matplotlib.pylab as pylab
+            self.pylab = pylab
+            self.pylab_name = 'pylab'
+        except ImportError:
+            import matplotlib.matlab as matlab            
+            self.pylab = matlab
+            self.pylab_name = 'matlab'
+
+        # Build a user namespace initialized with matplotlib/matlab features.
+        user_ns = {'__name__':'__main__',
+                   '__builtins__' : __builtin__ }
+
+        # Be careful not to remove the final \n in the code string below, or
+        # things will break badly with py22 (I think it's a python bug, 2.3 is
+        # OK).
+        pname = self.pylab_name # Python can't interpolate dotted var names
+        exec ("import matplotlib\n"
+              "import matplotlib.%(pname)s as %(pname)s\n"
+              "from matplotlib.%(pname)s import *\n" % locals()) in user_ns
+        
+        # Build matplotlib info banner
+        b="""
+  Welcome to pylab, a matplotlib-based Python environment.
+  For more information, type 'help(pylab)'.
+"""
+        return user_ns,b
+
+    def mplot_exec(self,fname,*where,**kw):
+        """Execute a matplotlib script.
+
+        This is a call to execfile(), but wrapped in safeties to properly
+        handle interactive rendering and backend switching."""
+
+        #print '*** Matplotlib runner ***' # dbg
+        # turn off rendering until end of script
+        isInteractive = self.matplotlib.rcParams['interactive']
+        self.matplotlib.interactive(False)
+        self.safe_execfile(fname,*where,**kw)
+        self.matplotlib.interactive(isInteractive)
+        # make rendering call now, if the user tried to do it
+        if self.pylab.draw_if_interactive.called:
+            self.pylab.draw()
+            self.pylab.draw_if_interactive.called = False
+                
+        # if a backend switch was performed, reverse it now
+        if self.mpl_use._called:
+            self.matplotlib.rcParams['backend'] = self.mpl_backend
+        
+    def magic_run(self,parameter_s=''):
+        Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
+
+    # Fix the docstring so users see the original as well
+    magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
+                                    "\n        *** Modified %run for Matplotlib,"
+                                    " with proper interactive handling ***")
+
+# Now we provide 2 versions of a matplotlib-aware IPython base shells, single
+# and multithreaded.  Note that these are meant for internal use, the IPShell*
+# classes below are the ones meant for public consumption.
+
+class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
+    """Single-threaded shell with matplotlib support."""
+
+    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
+                 user_ns = None, **kw):
+        user_ns,b2 = self._matplotlib_config(name)
+        InteractiveShell.__init__(self,name,usage,rc,user_ns,banner2=b2,**kw)
+
+class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
+    """Multi-threaded shell with matplotlib support."""
+
+    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
+                 user_ns = None, **kw):
+        user_ns,b2 = self._matplotlib_config(name)
+        MTInteractiveShell.__init__(self,name,usage,rc,user_ns,banner2=b2,**kw)
+
+#-----------------------------------------------------------------------------
+# Utility functions for the different GUI enabled IPShell* classes.
+
+def get_tk():
+    """Tries to import Tkinter and returns a withdrawn Tkinter root
+    window.  If Tkinter is already imported or not available, this
+    returns None.  This function calls `hijack_tk` underneath.
+    """
+    if not USE_TK or sys.modules.has_key('Tkinter'):
+        return None
+    else:
+        try:
+            import Tkinter
+        except ImportError:
+            return None
+        else:
+            hijack_tk()
+            r = Tkinter.Tk()
+            r.withdraw()
+            return r
+
+def hijack_tk():
+    """Modifies Tkinter's mainloop with a dummy so when a module calls
+    mainloop, it does not block.
+
+    """
+    def misc_mainloop(self, n=0):
+        pass
+    def tkinter_mainloop(n=0):
+        pass
+    
+    import Tkinter
+    Tkinter.Misc.mainloop = misc_mainloop
+    Tkinter.mainloop = tkinter_mainloop
+
+def update_tk(tk):
+    """Updates the Tkinter event loop.  This is typically called from
+    the respective WX or GTK mainloops.
+    """    
+    if tk:
+        tk.update()
+
+def hijack_wx():
+    """Modifies wxPython's MainLoop with a dummy so user code does not
+    block IPython.  The hijacked mainloop function is returned.
+    """    
+    def dummy_mainloop(*args, **kw):
+        pass
+    import wxPython
+    ver = wxPython.__version__
+    orig_mainloop = None
+    if ver[:3] >= '2.5':
+        import wx
+        if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
+        elif hasattr(wx, '_core'): core = getattr(wx, '_core')
+        else: raise AttributeError('Could not find wx core module')
+        orig_mainloop = core.PyApp_MainLoop
+        core.PyApp_MainLoop = dummy_mainloop
+    elif ver[:3] == '2.4':
+        orig_mainloop = wxPython.wxc.wxPyApp_MainLoop
+        wxPython.wxc.wxPyApp_MainLoop = dummy_mainloop
+    else:
+        warn("Unable to find either wxPython version 2.4 or >= 2.5.")
+    return orig_mainloop
+
+def hijack_gtk():
+    """Modifies pyGTK's mainloop with a dummy so user code does not
+    block IPython.  This function returns the original `gtk.mainloop`
+    function that has been hijacked.
+
+    NOTE: Make sure you import this *AFTER* you call
+    pygtk.require(...).
+    """    
+    def dummy_mainloop(*args, **kw):
+        pass
+    import gtk
+    if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
+    else:                            orig_mainloop = gtk.mainloop
+    gtk.mainloop = dummy_mainloop
+    gtk.main = dummy_mainloop
+    return orig_mainloop
+
+#-----------------------------------------------------------------------------
+# The IPShell* classes below are the ones meant to be run by external code as
+# IPython instances.  Note that unless a specific threading strategy is
+# desired, the factory function start() below should be used instead (it
+# selects the proper threaded class).
+
+class IPShellGTK(threading.Thread):
+    """Run a gtk mainloop() in a separate thread.
+    
+    Python commands can be passed to the thread where they will be executed.
+    This is implemented by periodically checking for passed code using a
+    GTK timeout callback."""
+    
+    TIMEOUT = 100 # Millisecond interval between timeouts.
+
+    def __init__(self,argv=None,user_ns=None,debug=1,
+                 shell_class=MTInteractiveShell):
+
+        import pygtk
+        pygtk.require("2.0")
+        import gtk
+        
+        self.gtk = gtk
+        self.gtk_mainloop = hijack_gtk()
+
+        # Allows us to use both Tk and GTK.
+        self.tk = get_tk()
+        
+        if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
+        else:                            mainquit = self.gtk.mainquit
+
+        self.IP = make_IPython(argv,user_ns=user_ns,debug=debug,
+                               shell_class=shell_class,
+                               on_kill=[mainquit])
+        threading.Thread.__init__(self)
+
+    def run(self):
+        self.IP.mainloop()
+        self.IP.kill()
+
+    def mainloop(self):
+
+        if self.gtk.pygtk_version >= (2,4,0):
+            import gobject
+            gobject.timeout_add(self.TIMEOUT, self.on_timer)
+        else:
+            self.gtk.timeout_add(self.TIMEOUT, self.on_timer)
+
+        if sys.platform != 'win32':
+            try:
+                if self.gtk.gtk_version[0] >= 2:
+                    self.gtk.threads_init()
+            except AttributeError:
+                pass
+            except RuntimeError:
+                error('Your pyGTK likely has not been compiled with '
+                      'threading support.\n'
+                      'The exception printout is below.\n'
+                      'You can either rebuild pyGTK with threads, or '
+                      'try using \n'
+                      'matplotlib with a different backend (like Tk or WX).\n'
+                      'Note that matplotlib will most likely not work in its '
+                      'current state!')
+                self.IP.InteractiveTB()
+        self.start()
+        self.gtk.threads_enter()
+        self.gtk_mainloop()
+        self.gtk.threads_leave()
+        self.join()
+
+    def on_timer(self):
+        update_tk(self.tk)
+        return self.IP.runcode()
+        
+
+class IPShellWX(threading.Thread):
+    """Run a wx mainloop() in a separate thread.
+    
+    Python commands can be passed to the thread where they will be executed.
+    This is implemented by periodically checking for passed code using a
+    GTK timeout callback."""
+    
+    TIMEOUT = 100 # Millisecond interval between timeouts.
+
+    def __init__(self,argv=None,user_ns=None,debug=1,
+                 shell_class=MTInteractiveShell):
+
+        import wxPython.wx as wx
+
+        threading.Thread.__init__(self)
+        self.wx = wx
+        self.wx_mainloop = hijack_wx()
+
+        # Allows us to use both Tk and GTK.
+        self.tk = get_tk()
+        
+        self.IP = make_IPython(argv,user_ns=user_ns,debug=debug,
+                               shell_class=shell_class,
+                               on_kill=[self.wxexit])
+        self.app = None
+
+    def wxexit(self, *args):
+        if self.app is not None:
+            self.app.agent.timer.Stop()
+            self.app.ExitMainLoop()
+
+    def run(self):
+        self.IP.mainloop()
+        self.IP.kill()
+
+    def mainloop(self):
+        
+        self.start()
+
+        class TimerAgent(self.wx.wxMiniFrame):
+            wx = self.wx
+            IP = self.IP
+            tk = self.tk
+            def __init__(self, parent, interval):
+                style = self.wx.wxDEFAULT_FRAME_STYLE | self.wx.wxTINY_CAPTION_HORIZ
+                self.wx.wxMiniFrame.__init__(self, parent, -1, ' ', pos=(200, 200),
+                                             size=(100, 100),style=style)
+                self.Show(False)
+                self.interval = interval
+                self.timerId = self.wx.wxNewId()                                
+
+            def StartWork(self):
+                self.timer = self.wx.wxTimer(self, self.timerId)
+                self.wx.EVT_TIMER(self,  self.timerId, self.OnTimer)
+                self.timer.Start(self.interval)
+
+            def OnTimer(self, event):
+                update_tk(self.tk)
+                self.IP.runcode()
+
+        class App(self.wx.wxApp):
+            wx = self.wx
+            TIMEOUT = self.TIMEOUT
+            def OnInit(self):
+                'Create the main window and insert the custom frame'
+                self.agent = TimerAgent(None, self.TIMEOUT)
+                self.agent.Show(self.wx.false)
+                self.agent.StartWork()
+                return self.wx.true
+        
+        self.app = App(redirect=False)
+        self.wx_mainloop(self.app)
+        self.join()
+
+
+class IPShellQt(threading.Thread):
+    """Run a Qt event loop in a separate thread.
+    
+    Python commands can be passed to the thread where they will be executed.
+    This is implemented by periodically checking for passed code using a
+    Qt timer / slot."""
+    
+    TIMEOUT = 100 # Millisecond interval between timeouts.
+
+    def __init__(self,argv=None,user_ns=None,debug=0,
+                 shell_class=MTInteractiveShell):
+        
+        import qt
+
+        class newQApplication:
+            def __init__( self ):
+                self.QApplication = qt.QApplication
+                
+            def __call__( *args, **kwargs ):
+                return qt.qApp
+
+            def exec_loop( *args, **kwargs ):
+                pass
+
+            def __getattr__( self, name ):
+                return getattr( self.QApplication, name )
+          
+        qt.QApplication = newQApplication()
+
+        # Allows us to use both Tk and QT.
+        self.tk = get_tk()
+
+        self.IP = make_IPython(argv,user_ns=user_ns,debug=debug,
+                               shell_class=shell_class,
+                               on_kill=[qt.qApp.exit])
+        
+        threading.Thread.__init__(self)
+
+    def run(self):
+        #sys.excepthook = self.IP.excepthook # dbg
+        self.IP.mainloop()
+        self.IP.kill()
+
+    def mainloop(self):
+        import qt, sys
+        if qt.QApplication.startingUp():
+          a = qt.QApplication.QApplication( sys.argv )
+        self.timer = qt.QTimer()
+        qt.QObject.connect( self.timer, qt.SIGNAL( 'timeout()' ), self.on_timer )
+
+        self.start()
+        self.timer.start( self.TIMEOUT, True )
+        while True:
+            if self.IP._kill: break
+            qt.qApp.exec_loop()
+        self.join()
+
+    def on_timer(self):
+        update_tk(self.tk)
+        result = self.IP.runcode()
+        self.timer.start( self.TIMEOUT, True )
+        return result
+
+# A set of matplotlib public IPython shell classes, for single-threaded
+# (Tk* and FLTK* backends) and multithreaded (GTK* and WX* backends) use.
+class IPShellMatplotlib(IPShell):
+    """Subclass IPShell with MatplotlibShell as the internal shell.
+
+    Single-threaded class, meant for the Tk* and FLTK* backends.
+
+    Having this on a separate class simplifies the external driver code."""
+    
+    def __init__(self,argv=None,user_ns=None,debug=1):
+        IPShell.__init__(self,argv,user_ns,debug,shell_class=MatplotlibShell)
+
+class IPShellMatplotlibGTK(IPShellGTK):
+    """Subclass IPShellGTK with MatplotlibMTShell as the internal shell.
+
+    Multi-threaded class, meant for the GTK* backends."""
+    
+    def __init__(self,argv=None,user_ns=None,debug=1):
+        IPShellGTK.__init__(self,argv,user_ns,debug,shell_class=MatplotlibMTShell)
+
+class IPShellMatplotlibWX(IPShellWX):
+    """Subclass IPShellWX with MatplotlibMTShell as the internal shell.
+
+    Multi-threaded class, meant for the WX* backends."""
+    
+    def __init__(self,argv=None,user_ns=None,debug=1):
+        IPShellWX.__init__(self,argv,user_ns,debug,shell_class=MatplotlibMTShell)
+
+class IPShellMatplotlibQt(IPShellQt):
+    """Subclass IPShellQt with MatplotlibMTShell as the internal shell.
+
+    Multi-threaded class, meant for the Qt* backends."""
+    
+    def __init__(self,argv=None,user_ns=None,debug=1):
+        IPShellQt.__init__(self,argv,user_ns,debug,shell_class=MatplotlibMTShell)
+
+#-----------------------------------------------------------------------------
+# Factory functions to actually start the proper thread-aware shell
+
+def _matplotlib_shell_class():
+    """Factory function to handle shell class selection for matplotlib.
+
+    The proper shell class to use depends on the matplotlib backend, since
+    each backend requires a different threading strategy."""
+
+    try:
+        import matplotlib
+    except ImportError:
+        error('matplotlib could NOT be imported!  Starting normal IPython.')
+        sh_class = IPShell
+    else:
+        backend = matplotlib.rcParams['backend']
+        if backend.startswith('GTK'):
+            sh_class = IPShellMatplotlibGTK
+        elif backend.startswith('WX'):
+            sh_class = IPShellMatplotlibWX
+        elif backend.startswith('Qt'):
+            sh_class = IPShellMatplotlibQt
+        else:
+            sh_class = IPShellMatplotlib
+    #print 'Using %s with the %s backend.' % (sh_class,backend) # dbg
+    return sh_class
+
+# This is the one which should be called by external code.
+def start():
+    """Return a running shell instance, dealing with threading options.
+
+    This is a factory function which will instantiate the proper IPython shell
+    based on the user's threading choice.  Such a selector is needed because
+    different GUI toolkits require different thread handling details."""
+
+    global USE_TK
+    # Crude sys.argv hack to extract the threading options.
+    if len(sys.argv) > 1:
+        if len(sys.argv) > 2:
+            arg2 = sys.argv[2]
+            if arg2.endswith('-tk'):
+                USE_TK = True
+        arg1 = sys.argv[1]
+        if arg1.endswith('-gthread'):
+            shell = IPShellGTK
+        elif arg1.endswith( '-qthread' ):
+            shell = IPShellQt
+        elif arg1.endswith('-wthread'):
+            shell = IPShellWX
+        elif arg1.endswith('-pylab'):
+            shell = _matplotlib_shell_class()
+        else:
+            shell = IPShell
+    else:
+        shell = IPShell
+    return shell()
+
+# Some aliases for backwards compatibility
+IPythonShell = IPShell
+IPythonShellEmbed = IPShellEmbed
+#************************ End of file <Shell.py> ***************************

IPython/Struct.py

@@ -0,0 +1,376 b''
+# -*- coding: utf-8 -*-
+"""Mimic C structs with lots of extra functionality.
+
+$Id: Struct.py 410 2004-11-04 07:58:17Z fperez $"""
+
+#*****************************************************************************
+#       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
+
+__all__ = ['Struct']
+
+import types
+from IPython.genutils import list2dict2
+
+class Struct:
+    """Class to mimic C structs but also provide convenient dictionary-like
+    functionality.
+
+    Instances can be initialized with a dictionary, a list of key=value pairs
+    or both. If both are present, the dictionary must come first.
+
+    Because Python classes provide direct assignment to their members, it's
+    easy to overwrite normal methods (S.copy = 1 would destroy access to
+    S.copy()). For this reason, all builtin method names are protected and
+    can't be assigned to. An attempt to do s.copy=1 or s['copy']=1 will raise
+    a KeyError exception. If you really want to, you can bypass this
+    protection by directly assigning to __dict__: s.__dict__['copy']=1 will
+    still work. Doing this will break functionality, though. As in most of
+    Python, namespace protection is weakly enforced, so feel free to shoot
+    yourself if you really want to.
+
+    Note that this class uses more memory and is *much* slower than a regular
+    dictionary, so be careful in situations where memory or performance are
+    critical. But for day to day use it should behave fine. It is particularly
+    convenient for storing configuration data in programs.
+
+    +,+=,- and -= are implemented. +/+= do merges (non-destructive updates),
+    -/-= remove keys from the original. See the method descripitions.
+
+    This class allows a quick access syntax: both s.key and s['key'] are
+    valid.  This syntax has a limitation: each 'key' has to be explicitly
+    accessed by its original name. The normal s.key syntax doesn't provide
+    access to the keys via variables whose values evaluate to the desired
+    keys. An example should clarify this:
+
+    Define a dictionary and initialize both with dict and k=v pairs:
+    >>> d={'a':1,'b':2}
+    >>> s=Struct(d,hi=10,ho=20)
+    The return of __repr__ can be used to create a new instance:
+    >>> s
+    Struct({'ho': 20, 'b': 2, 'hi': 10, 'a': 1})
+    __str__ (called by print) shows it's not quite a regular dictionary:
+    >>> print s
+    Struct {a: 1, b: 2, hi: 10, ho: 20}
+    Access by explicitly named key with dot notation:
+    >>> s.a
+    1
+    Or like a dictionary:
+    >>> s['a']
+    1
+    If you want a variable to hold the key value, only dictionary access works:
+    >>> key='hi'
+    >>> s.key
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in ?
+    AttributeError: Struct instance has no attribute 'key'
+    >>> s[key]
+    10
+
+    Another limitation of the s.key syntax (and Struct(key=val)
+    initialization): keys can't be numbers. But numeric keys can be used and
+    accessed using the dictionary syntax. Again, an example:
+
+    This doesn't work:
+    >>> s=Struct(4='hi')
+    SyntaxError: keyword can't be an expression
+    But this does:
+    >>> s=Struct()
+    >>> s[4]='hi'
+    >>> s
+    Struct({4: 'hi'})
+    >>> s[4]
+    'hi'
+    """
+
+    # Attributes to which __setitem__ and __setattr__ will block access.
+    # Note: much of this will be moot in Python 2.2 and will be done in a much
+    # cleaner way.
+    __protected = ('copy dict dictcopy get has_attr has_key items keys '
+                   'merge popitem setdefault update values '
+                   '__make_dict __dict_invert ').split()
+
+    def __init__(self,dict=None,**kw):
+        """Initialize with a dictionary, another Struct, or by giving
+        explicitly the list of attributes.
+
+        Both can be used, but the dictionary must come first:
+        Struct(dict), Struct(k1=v1,k2=v2) or Struct(dict,k1=v1,k2=v2).
+        """
+        if dict is None:
+            dict = {}
+        if isinstance(dict,Struct):
+            dict = dict.dict()
+        elif dict and  type(dict) is not types.DictType:
+            raise TypeError,\
+                  'Initialize with a dictionary or key=val pairs.'
+        dict.update(kw)
+        # do the updating by hand to guarantee that we go through the
+        # safety-checked __setitem__
+        for k,v in dict.items():
+            self[k] = v
+
+    def __setitem__(self,key,value):
+        """Used when struct[key] = val calls are made."""
+        if key in Struct.__protected:
+            raise KeyError,'Key '+`key`+' is a protected key of class Struct.'
+        self.__dict__[key] = value
+
+    def __setattr__(self, key, value):
+        """Used when struct.key = val calls are made."""
+        self.__setitem__(key,value)
+
+    def __str__(self):
+        """Gets called by print."""
+        
+        return 'Struct('+str(self.__dict__)+')'
+
+    def __repr__(self):
+        """Gets called by repr.
+        
+        A Struct can be recreated with S_new=eval(repr(S_old))."""
+        return 'Struct('+str(self.__dict__)+')'
+
+    def __getitem__(self,key):
+        """Allows struct[key] access."""
+        return self.__dict__[key]
+
+    def __contains__(self,key):
+        """Allows use of the 'in' operator."""
+        return self.__dict__.has_key(key)
+
+    def __iadd__(self,other):
+        """S += S2 is a shorthand for S.merge(S2)."""
+        self.merge(other)
+        return self
+
+    def __add__(self,other):
+        """S + S2 -> New Struct made form S and S.merge(S2)"""
+        Sout = self.copy()
+        Sout.merge(other)
+        return Sout
+
+    def __sub__(self,other):
+        """Return S1-S2, where all keys in S2 have been deleted (if present)
+        from S1."""
+        Sout = self.copy()
+        Sout -= other
+        return Sout
+
+    def __isub__(self,other):
+        """Do in place S = S - S2, meaning all keys in S2 have been deleted
+        (if present) from S1."""
+
+        for k in other.keys():
+            if self.has_key(k):
+                del self.__dict__[k]
+
+    def __make_dict(self,__loc_data__,**kw):
+        "Helper function for update and merge. Return a dict from data."
+
+        if __loc_data__ == None:
+            dict = {}
+        elif type(__loc_data__) is types.DictType:
+            dict = __loc_data__
+        elif isinstance(__loc_data__,Struct):
+            dict = __loc_data__.__dict__
+        else:
+            raise TypeError, 'Update with a dict, a Struct or key=val pairs.'
+        if kw:
+            dict.update(kw)
+        return dict
+
+    def __dict_invert(self,dict):
+        """Helper function for merge. Takes a dictionary whose values are
+        lists and returns a dict. with the elements of each list as keys and
+        the original keys as values."""
+
+        outdict = {}
+        for k,lst in dict.items():
+            if type(lst) is types.StringType:
+                lst = lst.split()
+            for entry in lst:
+                outdict[entry] = k
+        return outdict
+
+    def clear(self):
+        """Clear all attributes."""
+        self.__dict__.clear()
+
+    def copy(self):
+        """Return a (shallow) copy of a Struct."""
+        return Struct(self.__dict__.copy())
+
+    def dict(self):
+        """Return the Struct's dictionary."""
+        return self.__dict__
+
+    def dictcopy(self):
+        """Return a (shallow) copy of the Struct's dictionary."""
+        return self.__dict__.copy()
+
+    def popitem(self):
+        """S.popitem() -> (k, v), remove and return some (key, value) pair as
+        a 2-tuple; but raise KeyError if S is empty."""
+        return self.__dict__.popitem()
+
+    def update(self,__loc_data__=None,**kw):
+        """Update (merge) with data from another Struct or from a dictionary.
+        Optionally, one or more key=value pairs can be given at the end for
+        direct update."""
+
+        # The funny name __loc_data__ is to prevent a common variable name which
+        # could be a fieled of a Struct to collide with this parameter. The problem
+        # would arise if the function is called with a keyword with this same name
+        # that a user means to add as a Struct field.
+        newdict = Struct.__make_dict(self,__loc_data__,**kw)
+        for k,v in newdict.items():
+            self[k] = v
+
+    def merge(self,__loc_data__=None,__conflict_solve=None,**kw):
+        """S.merge(data,conflict,k=v1,k=v2,...) -> merge data and k=v into S.
+
+        This is similar to update(), but much more flexible.  First, a dict is
+        made from data+key=value pairs. When merging this dict with the Struct
+        S, the optional dictionary 'conflict' is used to decide what to do.
+
+        If conflict is not given, the default behavior is to preserve any keys
+        with their current value (the opposite of the update method's
+        behavior).
+
+        conflict is a dictionary of binary functions which will be used to
+        solve key conflicts. It must have the following structure:
+
+          conflict == { fn1 : [Skey1,Skey2,...], fn2 : [Skey3], etc }
+
+        Values must be lists or whitespace separated strings which are
+        automatically converted to lists of strings by calling string.split().
+
+        Each key of conflict is a function which defines a policy for
+        resolving conflicts when merging with the input data. Each fn must be
+        a binary function which returns the desired outcome for a key
+        conflict. These functions will be called as fn(old,new).
+
+        An example is probably in order. Suppose you are merging the struct S
+        with a dict D and the following conflict policy dict:
+
+            S.merge(D,{fn1:['a','b',4], fn2:'key_c key_d'})
+
+        If the key 'a' is found in both S and D, the merge method will call:
+
+            S['a'] = fn1(S['a'],D['a'])
+
+        As a convenience, merge() provides five (the most commonly needed)
+        pre-defined policies: preserve, update, add, add_flip and add_s. The
+        easiest explanation is their implementation:
+
+          preserve = lambda old,new: old
+          update   = lambda old,new: new
+          add      = lambda old,new: old + new
+          add_flip = lambda old,new: new + old  # note change of order!
+          add_s    = lambda old,new: old + ' ' + new  # only works for strings!
+
+        You can use those four words (as strings) as keys in conflict instead
+        of defining them as functions, and the merge method will substitute
+        the appropriate functions for you. That is, the call
+
+          S.merge(D,{'preserve':'a b c','add':[4,5,'d'],my_function:[6]})
+
+        will automatically substitute the functions preserve and add for the
+        names 'preserve' and 'add' before making any function calls.
+
+        For more complicated conflict resolution policies, you still need to
+        construct your own functions. """
+
+        data_dict = Struct.__make_dict(self,__loc_data__,**kw)
+
+        # policies for conflict resolution: two argument functions which return
+        # the value that will go in the new struct
+        preserve = lambda old,new: old
+        update   = lambda old,new: new
+        add      = lambda old,new: old + new
+        add_flip = lambda old,new: new + old  # note change of order!
+        add_s    = lambda old,new: old + ' ' + new
+
+        # default policy is to keep current keys when there's a conflict
+        conflict_solve = list2dict2(self.keys(),default = preserve)
+
+        # the conflict_solve dictionary is given by the user 'inverted': we
+        # need a name-function mapping, it comes as a function -> names
+        # dict. Make a local copy (b/c we'll make changes), replace user
+        # strings for the three builtin policies and invert it.
+        if __conflict_solve:
+            inv_conflict_solve_user = __conflict_solve.copy()
+            for name, func in [('preserve',preserve), ('update',update),
+                               ('add',add), ('add_flip',add_flip), ('add_s',add_s)]:
+                if name in inv_conflict_solve_user.keys():
+                    inv_conflict_solve_user[func] = inv_conflict_solve_user[name]
+                    del inv_conflict_solve_user[name]
+            conflict_solve.update(Struct.__dict_invert(self,inv_conflict_solve_user))
+        #print 'merge. conflict_solve: '; pprint(conflict_solve) # dbg
+        # after Python 2.2, use iterators: for key in data_dict will then work
+        #print '*'*50,'in merger. conflict_solver:';  pprint(conflict_solve)
+        for key in data_dict.keys():
+            if key not in self:
+                self[key] = data_dict[key]
+            else:
+                self[key] = conflict_solve[key](self[key],data_dict[key])
+
+    def has_key(self,key):
+        """Like has_key() dictionary method."""
+        return self.__dict__.has_key(key)
+
+    def hasattr(self,key):
+        """hasattr function available as a method.
+
+        Implemented like has_key, to make sure that all available keys in the
+        internal dictionary of the Struct appear also as attributes (even
+        numeric keys)."""
+        return self.__dict__.has_key(key)
+
+    def items(self):
+        """Return the items in the Struct's dictionary, in the same format
+        as a call to {}.items()."""
+        return self.__dict__.items()
+
+    def keys(self):
+        """Return the keys in the Struct's dictionary, in the same format
+        as a call to {}.keys()."""
+        return self.__dict__.keys()
+
+    def values(self,keys=None):
+        """Return the values in the Struct's dictionary, in the same format
+        as a call to {}.values().
+
+        Can be called with an optional argument keys, which must be a list or
+        tuple of keys. In this case it returns only the values corresponding
+        to those keys (allowing a form of 'slicing' for Structs)."""
+        if not keys:
+            return self.__dict__.values()
+        else:
+            ret=[]
+            for k in keys:
+                ret.append(self[k])
+            return ret
+
+    def get(self,attr,val=None):
+        """S.get(k[,d]) -> S[k] if S.has_key(k), else d.  d defaults to None."""
+        try:
+            return self[attr]
+        except KeyError:
+            return val
+
+    def setdefault(self,attr,val=None):
+        """S.setdefault(k[,d]) -> S.get(k,d), also set S[k]=d if not S.has_key(k)"""
+        if not self.has_key(attr):
+            self[attr] = val
+        return self.get(attr,val)
+# end class Struct
+

IPython/UserConfig/ipythonrc

@@ -0,0 +1,546 b''
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+# $Id: ipythonrc 596 2005-06-01 17:01:13Z fperez $
+
+#***************************************************************************
+#
+# Configuration file for IPython -- ipythonrc format
+#
+# The format of this file is simply one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+
+# The meaning and use of each key are explained below.
+
+#---------------------------------------------------------------------------
+# Section: included files
+
+# Put one or more *config* files (with the syntax of this file) you want to
+# include. For keys with a unique value the outermost file has precedence. For
+# keys with multiple values, they all get assembled into a list which then
+# gets loaded by IPython.
+
+# In this file, all lists of things should simply be space-separated.
+
+# This allows you to build hierarchies of files which recursively load
+# lower-level services. If this is your main ~/.ipython/ipythonrc file, you
+# should only keep here basic things you always want available. Then you can
+# include it in every other special-purpose config file you create.
+include 
+
+#---------------------------------------------------------------------------
+# Section: startup setup
+
+# These are mostly things which parallel a command line option of the same
+# name.
+
+# Keys in this section should only appear once. If any key from this section
+# is encountered more than once, the last value remains, all earlier ones get
+# discarded.
+
+# Automatic calling of callable objects.  If set to true, callable objects are
+# automatically called when invoked at the command line, even if you don't
+# type parentheses.  IPython adds the parentheses for you.  For example:
+
+#In [1]: str 45
+#------> str(45)
+#Out[1]: '45'
+
+# IPython reprints your line with '---->' indicating that it added
+# parentheses.  While this option is very convenient for interactive use, it
+# may occasionally cause problems with objects which have side-effects if
+# called unexpectedly.  Set it to 0 if you want to disable it.
+
+# Note that even with autocall off, you can still use '/' at the start of a
+# line to treat the first argument on the command line as a function and add
+# parentheses to it:
+
+#In [8]: /str 43
+#------> str(43)
+#Out[8]: '43'
+
+autocall 1
+
+# Auto-indent. IPython can recognize lines ending in ':' and indent the next
+# line, while also un-indenting automatically after 'raise' or 'return'.  
+
+# This feature uses the readline library, so it will honor your ~/.inputrc
+# configuration (or whatever file your INPUTRC variable points to).  Adding
+# the following lines to your .inputrc file can make indent/unindenting more
+# convenient (M-i indents, M-u unindents):
+
+#  $if Python
+#  "\M-i": "    "
+#  "\M-u": "\d\d\d\d"
+#  $endif
+
+# The feature is potentially a bit dangerous, because it can cause problems
+# with pasting of indented code (the pasted code gets re-indented on each
+# line).  But it's a huge time-saver when working interactively.  The magic
+# function @autoindent allows you to toggle it on/off at runtime.
+
+autoindent 1
+
+# Auto-magic. This gives you access to all the magic functions without having
+# to prepend them with an @ sign. If you define a variable with the same name
+# as a magic function (say who=1), you will need to access the magic function
+# with @ (@who in this example). However, if later you delete your variable
+# (del who), you'll recover the automagic calling form.
+
+# Considering that many magic functions provide a lot of shell-like
+# functionality, automagic gives you something close to a full Python+system
+# shell environment (and you can extend it further if you want).
+
+automagic 1
+
+# Size of the output cache. After this many entries are stored, the cache will
+# get flushed. Depending on the size of your intermediate calculations, you
+# may have memory problems if you make it too big, since keeping things in the
+# cache prevents Python from reclaiming the memory for old results. Experiment
+# with a value that works well for you.
+
+# If you choose cache_size 0 IPython will revert to python's regular >>>
+# unnumbered prompt. You will still have _, __ and ___ for your last three
+# results, but that will be it.  No dynamic _1, _2, etc. will be created. If
+# you are running on a slow machine or with very limited memory, this may
+# help.
+
+cache_size 1000
+
+# Classic mode: Setting 'classic 1' you lose many of IPython niceties,
+# but that's your choice! Classic 1 -> same as IPython -classic.
+# Note that this is _not_ the normal python interpreter, it's simply
+# IPython emulating most of the classic interpreter's behavior.
+classic 0
+
+# colors - Coloring option for prompts and traceback printouts.
+
+# Currently available schemes: NoColor, Linux, LightBG.
+
+# This option allows coloring the prompts and traceback printouts. This
+# requires a terminal which can properly handle color escape sequences. If you
+# are having problems with this, use the NoColor scheme (uses no color escapes
+# at all).
+
+# The Linux option works well in linux console type environments: dark
+# background with light fonts.
+
+# LightBG is similar to Linux but swaps dark/light colors to be more readable
+# in light background terminals.
+
+# keep uncommented only the one you want:
+colors Linux
+#colors LightBG
+#colors NoColor
+
+########################
+# Note to Windows users
+#
+# Color and readline support is avaialble to Windows users via Gary Bishop's
+# readline library.  You can find Gary's tools at
+# http://sourceforge.net/projects/uncpythontools.
+# Note that his readline module requires in turn the ctypes library, available
+# at http://starship.python.net/crew/theller/ctypes.
+########################
+
+# color_info: IPython can display information about objects via a set of
+# functions, and optionally can use colors for this, syntax highlighting
+# source code and various other elements. This information is passed through a
+# pager (it defaults to 'less' if $PAGER is not set). 
+
+# If your pager has problems, try to setting it to properly handle escapes
+# (see the less manpage for detail), or disable this option.  The magic
+# function @color_info allows you to toggle this interactively for testing.
+
+color_info 1
+
+# confirm_exit: set to 1 if you want IPython to confirm when you try to exit
+# with an EOF (Control-d in Unix, Control-Z/Enter in Windows). Note that using
+# the magic functions @Exit or @Quit you can force a direct exit, bypassing
+# any confirmation.
+
+confirm_exit 1
+
+# Use deep_reload() as a substitute for reload() by default. deep_reload() is
+# still available as dreload() and appears as a builtin.
+
+deep_reload 0
+
+# Which editor to use with the @edit command. If you leave this at 0, IPython
+# will honor your EDITOR environment variable. Since this editor is invoked on
+# the fly by ipython and is meant for editing small code snippets, you may
+# want to use a small, lightweight editor here.
+
+# For Emacs users, setting up your Emacs server properly as described in the
+# manual is a good idea. An alternative is to use jed, a very light editor
+# with much of the feel of Emacs (though not as powerful for heavy-duty work).
+
+editor 0
+
+# log 1 -> same as ipython -log. This automatically logs to ./ipython.log
+log 0
+
+# Same as ipython -Logfile YourLogfileName. 
+# Don't use with log 1 (use one or the other)
+logfile ''
+
+# banner 0 -> same as ipython -nobanner
+banner 1
+
+# messages 0 -> same as ipython -nomessages
+messages 1
+
+# Automatically call the pdb debugger after every uncaught exception. If you
+# are used to debugging using pdb, this puts you automatically inside of it
+# after any call (either in IPython or in code called by it) which triggers an
+# exception which goes uncaught.
+pdb 0
+
+# Enable the pprint module for printing. pprint tends to give a more readable
+# display (than print) for complex nested data structures.
+pprint 1
+
+# Prompt strings
+
+# Most bash-like escapes can be used to customize IPython's prompts, as well as
+# a few additional ones which are IPython-specific.  All valid prompt escapes
+# are described in detail in the Customization section of the IPython HTML/PDF
+# manual.
+
+# Use \# to represent the current prompt number, and quote them to protect
+# spaces.
+prompt_in1 'In [\#]: '
+
+# \D is replaced by as many dots as there are digits in the
+# current value of \#.
+prompt_in2 '   .\D.: '
+
+prompt_out 'Out[\#]: '
+
+# Select whether to left-pad the output prompts to match the length of the
+# input ones.  This allows you for example to use a simple '>' as an output
+# prompt, and yet have the output line up with the input.  If set to false,
+# the output prompts will be unpadded (flush left).
+prompts_pad_left 1
+
+# quick 1 -> same as ipython -quick
+quick 0
+
+# Use the readline library (1) or not (0). Most users will want this on, but
+# if you experience strange problems with line management (mainly when using
+# IPython inside Emacs buffers) you may try disabling it. Not having it on
+# prevents you from getting command history with the arrow keys, searching and
+# name completion using TAB.
+
+readline 1
+
+# Screen Length: number of lines of your screen. This is used to control
+# printing of very long strings. Strings longer than this number of lines will
+# be paged with the less command instead of directly printed.
+
+# The default value for this is 0, which means IPython will auto-detect your
+# screen size every time it needs to print. If for some reason this isn't
+# working well (it needs curses support), specify it yourself. Otherwise don't
+# change the default.
+
+screen_length 0
+
+# Prompt separators for input and output.
+# Use \n for newline explicitly, without quotes.
+# Use 0 (like at the cmd line) to turn off a given separator.
+
+# The structure of prompt printing is:
+# (SeparateIn)Input....
+# (SeparateOut)Output...
+# (SeparateOut2),   # that is, no newline is printed after Out2
+# By choosing these you can organize your output any way you want.
+
+separate_in \n
+separate_out 0
+separate_out2 0
+
+# 'nosep 1' is a shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 0'.
+# Simply removes all input/output separators, overriding the choices above.
+nosep 0
+
+# xmode - Exception reporting mode. 
+
+# Valid modes: Plain, Context and Verbose.
+
+# Plain: similar to python's normal traceback printing.
+
+# Context: prints 5 lines of context source code around each line in the
+# traceback.
+
+# Verbose: similar to Context, but additionally prints the variables currently
+# visible where the exception happened (shortening their strings if too
+# long). This can potentially be very slow, if you happen to have a huge data
+# structure whose string representation is complex to compute. Your computer
+# may appear to freeze for a while with cpu usage at 100%. If this occurs, you
+# can cancel the traceback with Ctrl-C (maybe hitting it more than once).
+
+#xmode Plain
+xmode Context
+#xmode Verbose
+
+# multi_line_specials: if true, allow magics, aliases and shell escapes (via
+# !cmd) to be used in multi-line input (like for loops).  For example, if you
+# have this active, the following is valid in IPython:
+#
+#In [17]: for i in range(3):
+#   ....:     mkdir $i
+#   ....:     !touch $i/hello
+#   ....:     ls -l $i
+
+multi_line_specials 1
+
+#---------------------------------------------------------------------------
+# Section: Readline configuration (readline is not available for MS-Windows)
+
+# This is done via the following options:
+
+# (i) readline_parse_and_bind: this option can appear as many times as you
+# want, each time defining a string to be executed via a
+# readline.parse_and_bind() command. The syntax for valid commands of this
+# kind can be found by reading the documentation for the GNU readline library,
+# as these commands are of the kind which readline accepts in its
+# configuration file.
+
+# The TAB key can be used to complete names at the command line in one of two
+# ways: 'complete' and 'menu-complete'. The difference is that 'complete' only
+# completes as much as possible while 'menu-complete' cycles through all
+# possible completions. Leave the one you prefer uncommented.
+
+readline_parse_and_bind tab: complete
+#readline_parse_and_bind tab: menu-complete
+
+# This binds Control-l to printing the list of all possible completions when
+# there is more than one (what 'complete' does when hitting TAB twice, or at
+# the first TAB if show-all-if-ambiguous is on)
+readline_parse_and_bind "\C-l": possible-completions
+
+# This forces readline to automatically print the above list when tab
+# completion is set to 'complete'. You can still get this list manually by
+# using the key bound to 'possible-completions' (Control-l by default) or by
+# hitting TAB twice. Turning this on makes the printing happen at the first
+# TAB.
+readline_parse_and_bind set show-all-if-ambiguous on
+
+# If you have TAB set to complete names, you can rebind any key (Control-o by
+# default) to insert a true TAB character.
+readline_parse_and_bind "\C-o": tab-insert
+
+# These commands allow you to indent/unindent easily, with the 4-space
+# convention of the Python coding standards.  Since IPython's internal
+# auto-indent system also uses 4 spaces, you should not change the number of
+# spaces in the code below.
+readline_parse_and_bind "\M-i": "    "
+readline_parse_and_bind "\M-o": "\d\d\d\d"
+readline_parse_and_bind "\M-I": "\d\d\d\d"
+
+# Bindings for incremental searches in the history. These searches use the
+# string typed so far on the command line and search anything in the previous
+# input history containing them.
+readline_parse_and_bind "\C-r": reverse-search-history
+readline_parse_and_bind "\C-s": forward-search-history
+
+# Bindings for completing the current line in the history of previous
+# commands. This allows you to recall any previous command by typing its first
+# few letters and hitting Control-p, bypassing all intermediate commands which
+# may be in the history (much faster than hitting up-arrow 50 times!)
+readline_parse_and_bind "\C-p": history-search-backward
+readline_parse_and_bind "\C-n": history-search-forward
+
+# I also like to have the same functionality on the plain arrow keys. If you'd
+# rather have the arrows use all the history (and not just match what you've
+# typed so far), comment out or delete the next two lines.
+readline_parse_and_bind "\e[A": history-search-backward
+readline_parse_and_bind "\e[B": history-search-forward
+
+# (ii) readline_remove_delims: a string of characters to be removed from the
+# default word-delimiters list used by readline, so that completions may be
+# performed on strings which contain them.
+
+readline_remove_delims -/~
+
+# (iii) readline_merge_completions: whether to merge the result of all
+# possible completions or not.  If true, IPython will complete filenames,
+# python names and aliases and return all possible completions.  If you set it
+# to false, each completer is used at a time, and only if it doesn't return
+# any completions is the next one used.
+
+# The default order is: [python_matches, file_matches, alias_matches]
+
+readline_merge_completions 1
+
+# (iv) readline_omit__names: normally hitting <tab> after a '.' in a name
+# will complete all attributes of an object, including all the special methods
+# whose names start with single or double underscores (like __getitem__ or
+# __class__).
+
+# This variable allows you to control this completion behavior:
+
+# readline_omit__names 1 -> completion will omit showing any names starting
+# with two __, but it will still show names starting with one _.
+
+# readline_omit__names 2 -> completion will omit all names beginning with one
+# _ (which obviously means filtering out the double __ ones).
+
+# Even when this option is set, you can still see those names by explicitly
+# typing a _ after the period and hitting <tab>: 'name._<tab>' will always
+# complete attribute names starting with '_'.
+
+# This option is off by default so that new users see all attributes of any
+# objects they are dealing with.
+
+readline_omit__names 0
+
+#---------------------------------------------------------------------------
+# Section: modules to be loaded with 'import ...'
+
+# List, separated by spaces, the names of the modules you want to import
+
+# Example:
+# import_mod sys os
+# will produce internally the statements
+# import sys
+# import os
+
+# Each import is executed in its own try/except block, so if one module
+# fails to load the others will still be ok.
+
+import_mod 
+
+#---------------------------------------------------------------------------
+# Section: modules to import some functions from: 'from ... import ...'
+
+# List, one per line, the modules for which you want only to import some
+# functions. Give the module name first and then the name of functions to be
+# imported from that module.
+
+# Example:
+
+# import_some IPython.genutils timing timings
+# will produce internally the statement
+# from IPython.genutils import timing, timings
+
+# timing() and timings() are two IPython utilities for timing the execution of
+# your own functions, which you may find useful.  Just commment out the above
+# line if you want to test them.
+
+# If you have more than one modules_some line, each gets its own try/except
+# block (like modules, see above).
+
+import_some 
+
+#---------------------------------------------------------------------------
+# Section: modules to import all from : 'from ... import *'
+
+# List (same syntax as import_mod above) those modules for which you want to
+# import all functions. Remember, this is a potentially dangerous thing to do,
+# since it is very easy to overwrite names of things you need. Use with
+# caution.
+
+# Example:
+# import_all sys os
+# will produce internally the statements
+# from sys import *
+# from os import *
+
+# As before, each will be called in a separate try/except block.
+
+import_all 
+
+#---------------------------------------------------------------------------
+# Section: Python code to execute.
+
+# Put here code to be explicitly executed (keep it simple!)
+# Put one line of python code per line. All whitespace is removed (this is a
+# feature, not a bug), so don't get fancy building loops here.
+# This is just for quick convenient creation of things you want available.
+
+# Example:
+# execute x = 1
+# execute print 'hello world'; y = z = 'a'
+# will produce internally
+# x = 1
+# print 'hello world'; y = z = 'a'
+# and each *line* (not each statement, we don't do python syntax parsing) is
+# executed in its own try/except block.
+
+execute 
+
+# Note for the adventurous: you can use this to define your own names for the
+# magic functions, by playing some namespace tricks:
+
+# execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
+
+# defines @pf as a new name for @profile.
+
+#---------------------------------------------------------------------------
+# Section: Pyhton files to load and execute.
+
+# Put here the full names of files you want executed with execfile(file).  If
+# you want complicated initialization, just write whatever you want in a
+# regular python file and load it from here.
+
+# Filenames defined here (which *must* include the extension) are searched for
+# through all of sys.path. Since IPython adds your .ipython directory to
+# sys.path, they can also be placed in your .ipython dir and will be
+# found. Otherwise (if you want to execute things not in .ipyton nor in
+# sys.path) give a full path (you can use ~, it gets expanded)
+
+# Example:
+# execfile file1.py ~/file2.py
+# will generate
+# execfile('file1.py')
+# execfile('_path_to_your_home/file2.py')
+
+# As before, each file gets its own try/except block.
+
+execfile
+
+# If you are feeling adventurous, you can even add functionality to IPython
+# through here. IPython works through a global variable called __ip which
+# exists at the time when these files are read. If you know what you are doing
+# (read the source) you can add functions to __ip in files loaded here. 
+
+# The file example-magic.py contains a simple but correct example. Try it:
+
+# execfile example-magic.py
+
+# Look at the examples in IPython/iplib.py for more details on how these magic
+# functions need to process their arguments.
+
+#---------------------------------------------------------------------------
+# Section: aliases for system shell commands
+
+# Here you can define your own names for system commands. The syntax is
+# similar to that of the builtin @alias function:
+
+# alias alias_name command_string
+
+# The resulting aliases are auto-generated magic functions (hence usable as
+# @alias_name)
+
+# For example:
+
+# alias myls ls -la
+
+# will define 'myls' as an alias for executing the system command 'ls -la'.
+# This allows you to customize IPython's environment to have the same aliases
+# you are accustomed to from your own shell.
+
+# You can also define aliases with parameters using %s specifiers (one per
+# parameter):
+
+# alias parts echo first %s second %s
+
+# will give you in IPython:
+# >>> @parts A B
+# first A second B
+
+# Use one 'alias' statement per alias you wish to define.
+
+# alias 
+
+#************************* end of file <ipythonrc> ************************

IPython/UserConfig/ipythonrc-math

@@ -0,0 +1,36 b''
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+#
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# This is an example of a 'profile' file which includes a base file and adds
+# some customizaton for a particular purpose.
+
+# If this file is found in the user's ~/.ipython directory as ipythonrc-math,
+# it can be loaded by calling passing the '-profile math' (or '-p math')
+# option to IPython.
+
+# This example is a light customization to have ipython have basic math functions
+# readily available, effectively making the python prompt a very capable scientific
+# calculator
+
+# include base config and only add some extras
+include ipythonrc
+
+# load the complex math functions but keep them in a separate namespace
+import_mod cmath
+
+# from ... import *
+# load the real math functions in the global namespace for convenience
+import_all math
+
+# from ... import ...
+import_some
+
+# code to execute
+execute print "*** math functions available globally, cmath as a module"

IPython/UserConfig/ipythonrc-numeric

@@ -0,0 +1,57 b''
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+#
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# This is an example of a 'profile' file which includes a base file and adds
+# some customizaton for a particular purpose.
+
+# If this file is found in the user's ~/.ipython directory as
+# ipythonrc-numeric, it can be loaded by calling passing the '-profile
+# numeric' (or '-p numeric') option to IPython.
+
+# A simple alias numpy -> 'ipython -p numeric' makes life very convenient.
+
+# This example is meant to load several modules to turn IPython into a very
+# capable environment for high-end numerical work, similar to IDL or MatLab
+# but with the beauty and flexibility of the Python language.
+
+# Load the user's basic configuration
+include ipythonrc
+
+# import ...
+
+# Load Numeric by itself so that 'help Numeric' works
+import_mod Numeric
+
+# from ... import *
+# GnuplotRuntime loads Gnuplot and adds enhancements for use in IPython
+import_all Numeric IPython.numutils IPython.GnuplotInteractive
+
+# a simple line at zero, often useful for an x-axis
+execute xaxis=gpfunc('0',title='',with='lines lt -1')
+
+# Below are optional things off by default. Uncomment them if desired.
+
+# MA (MaskedArray) modifies the Numeric printing mechanism so that huge arrays
+# are only summarized and not printed (which may freeze the machine for a
+# _long_ time).
+
+#import_mod MA
+
+
+# gracePlot is a Python interface to the plotting package Grace.
+# For more details go to: http://www.idyll.org/~n8gray/code/index.html
+# Uncomment lines below if you have grace and its python support code
+
+#import_mod gracePlot 
+#execute grace = gracePlot.gracePlot  # alias to make gracePlot instances
+#execute print '*** grace is an alias for gracePlot.gracePlot'
+
+# Files to execute
+execfile

IPython/UserConfig/ipythonrc-physics

@@ -0,0 +1,43 b''
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+#
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# If this file is found in the user's ~/.ipython directory as
+# ipythonrc-physics, it can be loaded by calling passing the '-profile
+# physics' (or '-p physics') option to IPython.
+
+# This profile loads modules useful for doing interactive calculations with
+# physical quantities (with units). It relies on modules from Konrad Hinsen's
+# ScientificPython (http://starship.python.net/crew/hinsen/)
+
+# First load basic user configuration
+include ipythonrc
+
+# import ...
+# Module with alternate input syntax for PhysicalQuantity objects.
+import_mod IPython.Extensions.PhysicalQInput
+
+# from ... import *
+# math CANNOT be imported after PhysicalQInteractive. It will override the
+# functions defined there.
+import_all math IPython.Extensions.PhysicalQInteractive
+
+# from ... import ...
+import_some  
+
+# code
+execute q = PhysicalQuantityInteractive
+execute g = PhysicalQuantityInteractive('9.8 m/s**2')
+ececute rad = pi/180.
+execute print '*** q is an alias for PhysicalQuantityInteractive'
+execute print '*** g = 9.8 m/s^2 has been defined'
+execute print '*** rad = pi/180  has been defined'
+
+# Files to execute
+execfile 

IPython/UserConfig/ipythonrc-pysh

@@ -0,0 +1,94 b''
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments.  But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# If this file is found in the user's ~/.ipython directory as ipythonrc-pysh,
+# it can be loaded by calling passing the '-profile pysh' (or '-p pysh')
+# option to IPython.
+
+# This profile turns IPython into a lightweight system shell with python
+# syntax.
+
+# We only set a few options here, the rest is done in the companion pysh.py
+# file.  In the future _all_ of IPython's configuration will be done via
+# proper python code.
+
+############################################################################
+# First load common user configuration
+include ipythonrc
+
+############################################################################
+# Load all the actual syntax extensions for shell-like operation, which live
+# in the InterpreterExec standard extension.
+import_all IPython.Extensions.InterpreterExec
+
+############################################################################
+# PROMPTS
+#
+# Configure prompt for more shell-like usage.
+
+# Most bash-like escapes can be used to customize IPython's prompts, as well as
+# a few additional ones which are IPython-specific.  All valid prompt escapes
+# are described in detail in the Customization section of the IPython HTML/PDF
+# manual.
+
+prompt_in1 '\C_LightGreen\u@\h\C_LightBlue[\C_LightCyan\Y1\C_LightBlue]\C_Green|\#> '
+prompt_in2 '\C_Green|\C_LightGreen\D\C_Green> '
+prompt_out '<\#> '
+
+# Here's a more complex prompt, showing the hostname and more path depth (\Y3)
+#prompt_in1 '\C_LightRed\u\C_Blue@\C_Red\h\C_LightBlue[\C_LightCyan\Y3\C_LightBlue]\C_LightGreen\#> '
+
+# Select whether to left-pad the output prompts to match the length of the
+# input ones.  This allows you for example to use a simple '>' as an output
+# prompt, and yet have the output line up with the input.  If set to false,
+# the output prompts will be unpadded (flush left).
+prompts_pad_left 1
+
+
+# Remove all blank lines in between prompts, like a normal shell.
+separate_in 0
+separate_out 0
+separate_out2 0
+
+# Allow special syntax (!, magics and aliases) in multiline input
+multi_line_specials 1
+
+############################################################################
+# ALIASES
+
+# Declare some common aliases. Type alias? at an ipython prompt for details on
+# the syntax, use @unalias to delete existing aliases.
+
+# Don't go too crazy here, the file pysh.py called below runs @rehash, which
+# loads ALL of your $PATH as aliases (except for Python keywords and
+# builtins).
+
+# Some examples:
+
+# A simple alias without arguments
+#alias cl clear
+
+# An alias which expands the full line before the end of the alias.  This
+# lists only directories:
+#alias ldir pwd;ls -oF --color %l | grep /$
+
+# An alias with two positional arguments:
+#alias parts echo 'First <%s> Second <%s>'
+
+# In use these two aliases give (note that ldir is already built into IPython
+# for Unix):
+
+#fperez[IPython]16> ldir
+#/usr/local/home/fperez/ipython/ipython/IPython
+#drwxr-xr-x  2 fperez  4096 Jun 21 01:01 CVS/
+#drwxr-xr-x  3 fperez  4096 Jun 21 01:10 Extensions/
+#drwxr-xr-x  3 fperez  4096 Jun 21 01:27 UserConfig/
+
+#fperez[IPython]17> parts Hello world and goodbye
+#First <Hello> Second <world> and goodbye

IPython/UserConfig/ipythonrc-scipy

@@ -0,0 +1,43 b''
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+#
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# This is an example of a 'profile' file which includes a base file and adds
+# some customizaton for a particular purpose.
+
+# If this file is found in the user's ~/.ipython directory as ipythonrc-scipy,
+# it can be loaded by calling passing the '-profile scipy' (or '-p scipy')
+# option to IPython.
+
+# This example is meant to load several modules to turn ipython into a very
+# capable environment for high-end numerical work, similar to IDL or MatLab
+# but with the beauty of the Python language.
+
+# load our basic configuration with generic options
+include ipythonrc
+
+# import ...
+# Load SciPy by itself so that 'help scipy' works
+import_mod scipy
+
+# from ... import ...
+import_some
+
+# Now we load all of SciPy
+# from ... import *
+import_all scipy IPython.numutils
+
+# code 
+execute print 'Welcome to the SciPy Scientific Computing Environment.'
+execute scipy.alter_numeric()
+
+# File with alternate printer system for Numeric Arrays.
+# Files in the 'Extensions' directory will be found by IPython automatically
+# (otherwise give the explicit path):
+execfile Extensions/numeric_formats.py

IPython/UserConfig/ipythonrc-tutorial

@@ -0,0 +1,37 b''
+# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
+#***************************************************************************
+#
+# Configuration file for ipython -- ipythonrc format
+#
+# The format of this file is one of 'key value' lines.
+# Lines containing only whitespace at the beginning and then a # are ignored
+# as comments. But comments can NOT be put on lines with data.
+#***************************************************************************
+
+# If this file is found in the user's ~/.ipython directory as
+# ipythonrc-tutorial, it can be loaded by calling passing the '-profile
+# tutorial' (or '-p tutorial') option to IPython.
+
+# This profile loads a special input line filter to allow typing lines which
+# begin with '>>> ' or '... '. These two strings, if present at the start of
+# the input line, are stripped. This allows for direct pasting of code from
+# examples such as those available in the standard Python tutorial.
+
+# First load basic user configuration
+include ipythonrc
+
+# import ...
+# Module with alternate input syntax for pasting python input
+import_mod IPython.Extensions.InterpreterPasteInput
+
+# from ... import *
+import_all
+
+# from ... import ...
+import_some  
+
+# code
+execute
+
+# Files to execute
+execfile

IPython/__init__.py

@@ -0,0 +1,63 b''
+# -*- coding: utf-8 -*-
+"""
+IPython -- An enhanced Interactive Python
+
+One of Python's nicest features is its interactive interpreter. This allows
+very fast testing of ideas without the overhead of creating test files as is
+typical in most programming languages. However, the interpreter supplied with
+the standard Python distribution is fairly primitive (and IDLE isn't really
+much better).
+
+IPython tries to:
+
+  i - provide an efficient environment for interactive work in Python
+  programming. It tries to address what we see as shortcomings of the standard
+  Python prompt, and adds many features to make interactive work much more
+  efficient.
+
+  ii - offer a flexible framework so that it can be used as the base
+  environment for other projects and problems where Python can be the
+  underlying language. Specifically scientific environments like Mathematica,
+  IDL and Mathcad inspired its design, but similar ideas can be useful in many
+  fields. Python is a fabulous language for implementing this kind of system
+  (due to its dynamic and introspective features), and with suitable libraries
+  entire systems could be built leveraging Python's power.
+
+  iii - serve as an embeddable, ready to go interpreter for your own programs.
+
+IPython requires Python 2.2 or newer.
+
+$Id: __init__.py 530 2005-03-02 07:11:15Z fperez $"""
+
+#*****************************************************************************
+#       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.
+#*****************************************************************************
+
+# Enforce proper version requirements
+import sys
+if sys.version[0:3] < '2.2':
+    raise ImportError, 'Python Version 2.2 or above is required.'
+        
+# Define what gets imported with a 'from IPython import *'
+__all__ = ['deep_reload','genutils','ultraTB','DPyGetOpt','Itpl','hooks',
+           'ConfigLoader','OutputTrap','Release','Struct','Shell']
+
+# Load __all__ in IPython namespace so that a simple 'import IPython' gives
+# access to them via IPython.<name>
+glob,loc = globals(),locals()
+for name in __all__:
+    __import__(name,glob,loc,[])
+
+# Release data
+from IPython import Release # do it explicitly so pydoc can see it - pydoc bug
+__author__  = '%s <%s>\n%s <%s>\n%s <%s>' % \
+              ( Release.authors['Fernando'] + Release.authors['Janko'] + \
+                Release.authors['Nathan'] )
+__license__ = Release.license
+__version__ = Release.version
+
+# Namespace cleanup
+del name,glob,loc

IPython/background_jobs.py

@@ -0,0 +1,504 b''
+# -*- coding: utf-8 -*-
+"""Manage background (threaded) jobs conveniently from an interactive shell.
+
+This module provides a BackgroundJobManager class.  This is the main class
+meant for public usage, it implements an object which can create and manage
+new background jobs.
+
+It also provides the actual job classes managed by these BackgroundJobManager
+objects, see their docstrings below.
+
+
+This system was inspired by discussions with B. Granger and the
+BackgroundCommand class described in the book Python Scripting for
+Computational Science, by H. P. Langtangen:
+
+http://folk.uio.no/hpl/scripting
+
+(although ultimately no code from this text was used, as IPython's system is a
+separate implementation).
+
+$Id: background_jobs.py 515 2005-02-15 07:41:41Z fperez $
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2005 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
+
+# Code begins
+import threading,sys
+
+from IPython.ultraTB import AutoFormattedTB
+from IPython.genutils import warn,error
+
+# declares Python 2.2 compatibility symbols:
+try:
+    basestring
+except NameError:
+    import types
+    basestring = (types.StringType, types.UnicodeType)
+    True = 1==1
+    False = 1==0
+
+class BackgroundJobManager:
+    """Class to manage a pool of backgrounded threaded jobs.
+
+    Below, we assume that 'jobs' is a BackgroundJobManager instance.
+    
+    Usage summary (see the method docstrings for details):
+
+      jobs.new(...) -> start a new job
+      
+      jobs() or jobs.status() -> print status summary of all jobs
+
+      jobs[N] -> returns job number N.
+
+      foo = jobs[N].result -> assign to variable foo the result of job N
+
+      jobs[N].traceback() -> print the traceback of dead job N
+
+      jobs.remove(N) -> remove (finished) job N
+
+      jobs.flush_finished() -> remove all finished jobs
+      
+    As a convenience feature, BackgroundJobManager instances provide the
+    utility result and traceback methods which retrieve the corresponding
+    information from the jobs list:
+
+      jobs.result(N) <--> jobs[N].result
+      jobs.traceback(N) <--> jobs[N].traceback()
+
+    While this appears minor, it allows you to use tab completion
+    interactively on the job manager instance.
+
+    In interactive mode, IPython provides the magic fuction %bg for quick
+    creation of backgrounded expression-based jobs. Type bg? for details."""
+
+    def __init__(self):
+        # Lists for job management
+        self.jobs_run  = []
+        self.jobs_comp = []
+        self.jobs_dead = []
+        # A dict of all jobs, so users can easily access any of them
+        self.jobs_all = {}
+        # For reporting
+        self._comp_report = []
+        self._dead_report = []
+        # Store status codes locally for fast lookups
+        self._s_created   = BackgroundJobBase.stat_created_c
+        self._s_running   = BackgroundJobBase.stat_running_c
+        self._s_completed = BackgroundJobBase.stat_completed_c
+        self._s_dead      = BackgroundJobBase.stat_dead_c
+
+    def new(self,func_or_exp,*args,**kwargs):
+        """Add a new background job and start it in a separate thread.
+
+        There are two types of jobs which can be created:
+
+        1. Jobs based on expressions which can be passed to an eval() call.
+        The expression must be given as a string.  For example:
+
+          job_manager.new('myfunc(x,y,z=1)'[,glob[,loc]])
+
+        The given expression is passed to eval(), along with the optional
+        global/local dicts provided.  If no dicts are given, they are
+        extracted automatically from the caller's frame.
+        
+        A Python statement is NOT a valid eval() expression.  Basically, you
+        can only use as an eval() argument something which can go on the right
+        of an '=' sign and be assigned to a variable.
+
+        For example,"print 'hello'" is not valid, but '2+3' is.
+
+        2. Jobs given a function object, optionally passing additional
+        positional arguments:
+
+          job_manager.new(myfunc,x,y)
+
+        The function is called with the given arguments.
+
+        If you need to pass keyword arguments to your function, you must
+        supply them as a dict named kw:
+
+          job_manager.new(myfunc,x,y,kw=dict(z=1))
+
+        The reason for this assymmetry is that the new() method needs to
+        maintain access to its own keywords, and this prevents name collisions
+        between arguments to new() and arguments to your own functions.
+
+        In both cases, the result is stored in the job.result field of the
+        background job object.
+
+
+        Notes and caveats:
+
+        1. All threads running share the same standard output.  Thus, if your
+        background jobs generate output, it will come out on top of whatever
+        you are currently writing.  For this reason, background jobs are best
+        used with silent functions which simply return their output.
+
+        2. Threads also all work within the same global namespace, and this
+        system does not lock interactive variables.  So if you send job to the
+        background which operates on a mutable object for a long time, and
+        start modifying that same mutable object interactively (or in another
+        backgrounded job), all sorts of bizarre behaviour will occur.
+
+        3. If a background job is spending a lot of time inside a C extension
+        module which does not release the Python Global Interpreter Lock
+        (GIL), this will block the IPython prompt.  This is simply because the
+        Python interpreter can only switch between threads at Python
+        bytecodes.  While the execution is inside C code, the interpreter must
+        simply wait unless the extension module releases the GIL.
+
+        4. There is no way, due to limitations in the Python threads library,
+        to kill a thread once it has started."""
+        
+        if callable(func_or_exp):
+            kw  = kwargs.get('kw',{})
+            job = BackgroundJobFunc(func_or_exp,*args,**kw)
+        elif isinstance(func_or_exp,basestring):
+            if not args:
+                frame = sys._getframe(1)
+                glob, loc = frame.f_globals, frame.f_locals
+            elif len(args)==1:
+                glob = loc = args[0]
+            elif len(args)==2:
+                glob,loc = args
+            else:
+                raise ValueError,\
+                      'Expression jobs take at most 2 args (globals,locals)'
+            job = BackgroundJobExpr(func_or_exp,glob,loc)
+        else:
+            raise
+        jkeys = self.jobs_all.keys()
+        if jkeys:
+            job.num = max(jkeys)+1
+        else:
+            job.num = 0
+        self.jobs_run.append(job)
+        self.jobs_all[job.num] = job
+        print 'Starting job # %s in a separate thread.' % job.num
+        job.start()
+        return job
+
+    def __getitem__(self,key):
+        return self.jobs_all[key]
+
+    def __call__(self):
+        """An alias to self.status(),
+
+        This allows you to simply call a job manager instance much like the
+        Unix jobs shell command."""
+
+        return self.status()
+
+    def _update_status(self):
+        """Update the status of the job lists.
+
+        This method moves finished jobs to one of two lists:
+          - self.jobs_comp: jobs which completed successfully
+          - self.jobs_dead: jobs which finished but died.
+
+        It also copies those jobs to corresponding _report lists.  These lists
+        are used to report jobs completed/dead since the last update, and are
+        then cleared by the reporting function after each call."""
+        
+        run,comp,dead = self._s_running,self._s_completed,self._s_dead
+        jobs_run = self.jobs_run
+        for num in range(len(jobs_run)):
+            job  = jobs_run[num]
+            stat = job.stat_code
+            if stat == run:
+                continue
+            elif stat == comp:
+                self.jobs_comp.append(job)
+                self._comp_report.append(job)
+                jobs_run[num] = False
+            elif stat == dead:
+                self.jobs_dead.append(job)
+                self._dead_report.append(job)
+                jobs_run[num] = False
+        self.jobs_run = filter(None,self.jobs_run)
+
+    def _group_report(self,group,name):
+        """Report summary for a given job group.
+
+        Return True if the group had any elements."""
+
+        if group:
+            print '%s jobs:' % name
+            for job in group:
+                print '%s : %s' % (job.num,job)
+            print
+            return True
+
+    def _group_flush(self,group,name):
+        """Flush a given job group
+
+        Return True if the group had any elements."""
+
+        njobs = len(group)
+        if njobs:
+            plural = {1:''}.setdefault(njobs,'s')
+            print 'Flushing %s %s job%s.' % (njobs,name,plural)
+            group[:] = []
+            return True
+        
+    def _status_new(self):
+        """Print the status of newly finished jobs.
+
+        Return True if any new jobs are reported.
+
+        This call resets its own state every time, so it only reports jobs
+        which have finished since the last time it was called."""
+
+        self._update_status()
+        new_comp = self._group_report(self._comp_report,'Completed')
+        new_dead = self._group_report(self._dead_report,
+                                      'Dead, call job.traceback() for details')
+        self._comp_report[:] = []
+        self._dead_report[:] = []
+        return new_comp or new_dead
+                
+    def status(self,verbose=0):
+        """Print a status of all jobs currently being managed."""
+
+        self._update_status()
+        self._group_report(self.jobs_run,'Running')
+        self._group_report(self.jobs_comp,'Completed')
+        self._group_report(self.jobs_dead,'Dead')
+        # Also flush the report queues
+        self._comp_report[:] = []
+        self._dead_report[:] = []
+
+    def remove(self,num):
+        """Remove a finished (completed or dead) job."""
+
+        try:
+            job = self.jobs_all[num]
+        except KeyError:
+            error('Job #%s not found' % num)
+        else:
+            stat_code = job.stat_code
+            if stat_code == self._s_running:
+                error('Job #%s is still running, it can not be removed.' % num)
+                return
+            elif stat_code == self._s_completed:
+                self.jobs_comp.remove(job)
+            elif stat_code == self._s_dead:
+                self.jobs_dead.remove(job)
+
+    def flush_finished(self):
+        """Flush all jobs finished (completed and dead) from lists.
+
+        Running jobs are never flushed.
+
+        It first calls _status_new(), to update info. If any jobs have
+        completed since the last _status_new() call, the flush operation
+        aborts."""
+
+        if self._status_new():
+            error('New jobs completed since last '\
+                  '_status_new(), aborting flush.')
+            return
+
+        # Remove the finished jobs from the master dict
+        jobs_all = self.jobs_all
+        for job in self.jobs_comp+self.jobs_dead:
+            del(jobs_all[job.num])
+
+        # Now flush these lists completely
+        fl_comp = self._group_flush(self.jobs_comp,'Completed')
+        fl_dead = self._group_flush(self.jobs_dead,'Dead')
+        if not (fl_comp or fl_dead):
+            print 'No jobs to flush.'
+
+    def result(self,num):
+        """result(N) -> return the result of job N."""
+        try:
+            return self.jobs_all[num].result
+        except KeyError:
+            error('Job #%s not found' % num)
+
+    def traceback(self,num):
+        try:
+            self.jobs_all[num].traceback()
+        except KeyError:
+            error('Job #%s not found' % num)
+
+
+class BackgroundJobBase(threading.Thread):
+    """Base class to build BackgroundJob classes.
+
+    The derived classes must implement:
+
+    - Their own __init__, since the one here raises NotImplementedError.  The
+    derived constructor must call self._init() at the end, to provide common
+    initialization.
+
+    - A strform attribute used in calls to __str__.
+
+    - A call() method, which will make the actual execution call and must
+    return a value to be held in the 'result' field of the job object."""
+
+    # Class constants for status, in string and as numerical codes (when
+    # updating jobs lists, we don't want to do string comparisons).  This will
+    # be done at every user prompt, so it has to be as fast as possible
+    stat_created   = 'Created'; stat_created_c = 0
+    stat_running   = 'Running'; stat_running_c = 1
+    stat_completed = 'Completed'; stat_completed_c = 2
+    stat_dead      = 'Dead (Exception), call job.traceback() for details'
+    stat_dead_c = -1
+
+    def __init__(self):
+        raise NotImplementedError, \
+              "This class can not be instantiated directly."
+
+    def _init(self):
+        """Common initialization for all BackgroundJob objects"""
+        
+        for attr in ['call','strform']:
+            assert hasattr(self,attr), "Missing attribute <%s>" % attr
+        
+        # The num tag can be set by an external job manager
+        self.num = None
+      
+        self.status    = BackgroundJobBase.stat_created
+        self.stat_code = BackgroundJobBase.stat_created_c
+        self.finished  = False
+        self.result    = '<BackgroundJob has not completed>'
+        # reuse the ipython traceback handler if we can get to it, otherwise
+        # make a new one
+        try:
+            self._make_tb = __IPYTHON__.InteractiveTB.text
+        except:
+            self._make_tb = AutoFormattedTB(mode = 'Context',
+                                           color_scheme='NoColor',
+                                           tb_offset = 1).text
+        # Hold a formatted traceback if one is generated.
+        self._tb = None
+        
+        threading.Thread.__init__(self)
+
+    def __str__(self):
+        return self.strform
+
+    def __repr__(self):
+        return '<BackgroundJob: %s>' % self.strform
+
+    def traceback(self):
+        print self._tb
+        
+    def run(self):
+        try:
+            self.status    = BackgroundJobBase.stat_running
+            self.stat_code = BackgroundJobBase.stat_running_c
+            self.result    = self.call()
+        except:
+            self.status    = BackgroundJobBase.stat_dead
+            self.stat_code = BackgroundJobBase.stat_dead_c
+            self.finished  = None
+            self.result    = ('<BackgroundJob died, call job.traceback() for details>')
+            self._tb       = self._make_tb()
+        else:
+            self.status    = BackgroundJobBase.stat_completed
+            self.stat_code = BackgroundJobBase.stat_completed_c
+            self.finished  = True
+
+class BackgroundJobExpr(BackgroundJobBase):
+    """Evaluate an expression as a background job (uses a separate thread)."""
+
+    def __init__(self,expression,glob=None,loc=None):
+        """Create a new job from a string which can be fed to eval().
+
+        global/locals dicts can be provided, which will be passed to the eval
+        call."""
+
+        # fail immediately if the given expression can't be compiled
+        self.code = compile(expression,'<BackgroundJob compilation>','eval')
+                
+        if glob is None:
+            glob = {}
+        if loc is None:
+            loc = {}
+            
+        self.expression = self.strform = expression
+        self.glob = glob
+        self.loc = loc
+        self._init()
+        
+    def call(self):
+        return eval(self.code,self.glob,self.loc)
+
+class BackgroundJobFunc(BackgroundJobBase):
+    """Run a function call as a background job (uses a separate thread)."""
+
+    def __init__(self,func,*args,**kwargs):
+        """Create a new job from a callable object.
+
+        Any positional arguments and keyword args given to this constructor
+        after the initial callable are passed directly to it."""
+
+        assert callable(func),'first argument must be callable'
+        
+        if args is None:
+            args = []
+        if kwargs is None:
+            kwargs = {}
+        
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        # The string form will only include the function passed, because
+        # generating string representations of the arguments is a potentially
+        # _very_ expensive operation (e.g. with large arrays).
+        self.strform = str(func)
+        self._init()
+
+    def call(self):
+        return self.func(*self.args,**self.kwargs)
+
+
+if __name__=='__main__':
+
+    import time
+
+    def sleepfunc(interval=2,*a,**kw):
+        args = dict(interval=interval,
+                    args=a,
+                    kwargs=kw)
+        time.sleep(interval)
+        return args
+
+    def diefunc(interval=2,*a,**kw):
+        time.sleep(interval)
+        die
+
+    def printfunc(interval=1,reps=5):
+        for n in range(reps):
+            time.sleep(interval)
+            print 'In the background...'
+
+    jobs = BackgroundJobManager()
+    # first job will have # 0
+    jobs.new(sleepfunc,4)
+    jobs.new(sleepfunc,kw={'reps':2})
+    # This makes a job which will die
+    jobs.new(diefunc,1)
+    jobs.new('printfunc(1,3)')
+
+    # after a while, you can get the traceback of a dead job.  Run the line
+    # below again interactively until it prints a traceback (check the status
+    # of the job):
+    print jobs[1].status
+    jobs[1].traceback()
+    
+    # Run this line again until the printed result changes
+    print "The result of job #0 is:",jobs[0].result

IPython/deep_reload.py

@@ -0,0 +1,184 b''
+# -*- coding: utf-8 -*-
+"""
+A module to change reload() so that it acts recursively.
+To enable it type:
+    >>> import __builtin__, deep_reload
+    >>> __builtin__.reload = deep_reload.reload
+You can then disable it with:
+    >>> __builtin__.reload = deep_reload.original_reload
+    
+Alternatively, you can add a dreload builtin alongside normal reload with:
+    >>> __builtin__.dreload = deep_reload.reload
+    
+This code is almost entirely based on knee.py from the standard library.
+
+$Id: deep_reload.py 410 2004-11-04 07:58:17Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001 Nathaniel Gray <[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 # do it explicitly so pydoc can see it - pydoc bug
+__author__  = '%s <%s>' %  Release.authors['Nathan']
+__license__ = Release.license
+__version__ = "0.5"
+__date__    = "21 August 2001"
+
+import sys, imp, __builtin__
+
+# Replacement for __import__()
+def deep_import_hook(name, globals=None, locals=None, fromlist=None):
+    parent = determine_parent(globals)
+    q, tail = find_head_package(parent, name)
+    m = load_tail(q, tail)
+    if not fromlist:
+        return q
+    if hasattr(m, "__path__"):
+        ensure_fromlist(m, fromlist)
+    return m
+
+def determine_parent(globals):
+    if not globals or  not globals.has_key("__name__"):
+        return None
+    pname = globals['__name__']
+    if globals.has_key("__path__"):
+        parent = sys.modules[pname]
+        assert globals is parent.__dict__
+        return parent
+    if '.' in pname:
+        i = pname.rfind('.')
+        pname = pname[:i]
+        parent = sys.modules[pname]
+        assert parent.__name__ == pname
+        return parent
+    return None
+
+def find_head_package(parent, name):
+    # Import the first
+    if '.' in name:
+        # 'some.nested.package' -> head = 'some', tail = 'nested.package'
+        i = name.find('.')
+        head = name[:i]
+        tail = name[i+1:]
+    else:
+        # 'packagename' -> head = 'packagename', tail = ''
+        head = name
+        tail = ""
+    if parent:
+        # If this is a subpackage then qname = parent's name + head
+        qname = "%s.%s" % (parent.__name__, head)
+    else:
+        qname = head
+    q = import_module(head, qname, parent)
+    if q: return q, tail
+    if parent:
+        qname = head
+        parent = None
+        q = import_module(head, qname, parent)
+        if q: return q, tail
+    raise ImportError, "No module named " + qname
+
+def load_tail(q, tail):
+    m = q
+    while tail:
+        i = tail.find('.')
+        if i < 0: i = len(tail)
+        head, tail = tail[:i], tail[i+1:]
+
+        # fperez: fix dotted.name reloading failures by changing:
+        #mname = "%s.%s" % (m.__name__, head)
+        # to:
+        mname = m.__name__
+        # This needs more testing!!! (I don't understand this module too well)
+        
+        #print '** head,tail=|%s|->|%s|, mname=|%s|' % (head,tail,mname)  # dbg
+        m = import_module(head, mname, m)
+        if not m:
+            raise ImportError, "No module named " + mname
+    return m
+
+def ensure_fromlist(m, fromlist, recursive=0):
+    for sub in fromlist:
+        if sub == "*":
+            if not recursive:
+                try:
+                    all = m.__all__
+                except AttributeError:
+                    pass
+                else:
+                    ensure_fromlist(m, all, 1)
+            continue
+        if sub != "*" and not hasattr(m, sub):
+            subname = "%s.%s" % (m.__name__, sub)
+            submod = import_module(sub, subname, m)
+            if not submod:
+                raise ImportError, "No module named " + subname
+
+# Need to keep track of what we've already reloaded to prevent cyclic evil
+found_now = {}
+
+def import_module(partname, fqname, parent):
+    global found_now
+    if found_now.has_key(fqname):
+        try:
+            return sys.modules[fqname]    
+        except KeyError:
+            pass
+    
+    print 'Reloading', fqname #, sys.excepthook is sys.__excepthook__, \
+            #sys.displayhook is sys.__displayhook__
+    
+    found_now[fqname] = 1
+    try:
+        fp, pathname, stuff = imp.find_module(partname,
+                                              parent and parent.__path__)
+    except ImportError:
+        return None
+        
+    try:
+        m = imp.load_module(fqname, fp, pathname, stuff)
+    finally:
+        if fp: fp.close()
+        
+    if parent:
+        setattr(parent, partname, m)
+
+    return m
+
+def deep_reload_hook(module):
+    name = module.__name__
+    if '.' not in name:
+        return import_module(name, name, None)
+    i = name.rfind('.')
+    pname = name[:i]
+    parent = sys.modules[pname]
+    return import_module(name[i+1:], name, parent)
+
+# Save the original hooks
+original_reload = __builtin__.reload
+
+# Replacement for reload()
+def reload(module, exclude=['sys', '__builtin__', '__main__']):
+    """Recursively reload all modules used in the given module.  Optionally
+    takes a list of modules to exclude from reloading.  The default exclude
+    list contains sys, __main__, and __builtin__, to prevent, e.g., resetting 
+    display, exception, and io hooks.
+    """
+    global found_now
+    for i in exclude:
+        found_now[i] = 1
+    original_import = __builtin__.__import__
+    __builtin__.__import__ = deep_import_hook    
+    try:
+        ret = deep_reload_hook(module)
+    finally:
+        __builtin__.__import__ = original_import
+        found_now = {}
+    return ret
+
+# Uncomment the following to automatically activate deep reloading whenever
+# this module is imported
+#__builtin__.reload = reload

IPython/genutils.py

@@ -0,0 +1,1519 b''
+# -*- coding: utf-8 -*-
+"""
+General purpose utilities.
+
+This is a grab-bag of stuff I find useful in most programs I write. Some of
+these things are also convenient when working at the command line.
+
+$Id: genutils.py 543 2005-03-18 09:23:48Z fperez $"""
+
+#*****************************************************************************
+#       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
+
+#****************************************************************************
+# required modules
+import __main__
+import types,commands,time,sys,os,re,shutil
+import tempfile
+from IPython.Itpl import Itpl,itpl,printpl
+from IPython import DPyGetOpt
+
+#****************************************************************************
+# Exceptions
+class Error(Exception):
+    """Base class for exceptions in this module."""
+    pass
+
+#----------------------------------------------------------------------------
+class Stream:
+    """Simple class to hold the various I/O streams in Term"""
+
+    def __init__(self,stream,name):
+        self.stream = stream
+        self.name = name
+        try:
+            self.fileno = stream.fileno()
+        except AttributeError:
+            msg = ("Stream <%s> looks suspicious: it lacks a 'fileno' attribute."
+                   % name)
+            print >> sys.stderr, 'WARNING:',msg
+        try:
+            self.mode = stream.mode
+        except AttributeError:
+            msg = ("Stream <%s> looks suspicious: it lacks a 'mode' attribute."
+                   % name)
+            print >> sys.stderr, 'WARNING:',msg
+
+class Term:
+    """ Term holds the file or file-like objects for handling I/O operations.
+
+    These are normally just sys.stdin, sys.stdout and sys.stderr but for
+    Windows they can can replaced to allow editing the strings before they are
+    displayed."""
+
+    # In the future, having IPython channel all its I/O operations through
+    # this class will make it easier to embed it into other environments which
+    # are not a normal terminal (such as a GUI-based shell)
+    in_s  = Stream(sys.stdin,'cin')
+    out_s = Stream(sys.stdout,'cout')
+    err_s = Stream(sys.stderr,'cerr')
+
+    # Store the three streams in (err,out,in) order so that if we need to reopen
+    # them, the error channel is reopened first to provide info.
+    streams = [err_s,out_s,in_s]
+
+    # The class globals should be the actual 'bare' streams for normal I/O to work
+    cin  = streams[2].stream
+    cout = streams[1].stream
+    cerr = streams[0].stream
+    
+    def reopen_all(cls):
+        """Reopen all streams if necessary.
+
+        This should only be called if it is suspected that someting closed
+        accidentally one of the I/O streams."""
+
+        any_closed = 0
+
+        for sn in range(len(cls.streams)):
+            st = cls.streams[sn]
+            if st.stream.closed:
+                any_closed = 1
+                new_stream = os.fdopen(os.dup(st.fileno), st.mode,0)
+                cls.streams[sn] = Stream(new_stream,st.name)
+                print >> cls.streams[0].stream, \
+                      '\nWARNING:\nStream Term.%s had to be reopened!' % st.name
+
+        # Rebuild the class globals
+        cls.cin = cls.streams[2].stream
+        cls.cout = cls.streams[1].stream
+        cls.cerr = cls.streams[0].stream
+
+    reopen_all = classmethod(reopen_all)
+
+    def set_stdout(cls,stream):
+        """Set the stream """
+        cls.cout = stream
+    set_stdout = classmethod(set_stdout)
+
+    def set_stderr(cls,stream):
+        cls.cerr = stream
+    set_stderr = classmethod(set_stderr)
+
+# Windows-specific code to load Gary Bishop's readline and configure it
+# automatically for the users
+# Note: os.name on cygwin returns posix, so this should only pick up 'native'
+# windows.  Cygwin returns 'cygwin' for sys.platform.
+if os.name == 'nt':
+    try:
+        import readline
+    except ImportError:
+        pass
+    else:
+        try:
+            _out = readline.GetOutputFile()
+        except AttributeError:
+            pass
+        else:
+            Term.set_stdout(_out)
+            Term.set_stderr(_out)
+            del _out
+
+#****************************************************************************
+# Generic warning/error printer, used by everything else
+def warn(msg,level=2,exit_val=1):
+    """Standard warning printer. Gives formatting consistency.
+
+    Output is sent to Term.cerr (sys.stderr by default).
+    
+    Options:
+    
+    -level(2): allows finer control:
+      0 -> Do nothing, dummy function.
+      1 -> Print message.
+      2 -> Print 'WARNING:' + message. (Default level).
+      3 -> Print 'ERROR:' + message.
+      4 -> Print 'FATAL ERROR:' + message and trigger a sys.exit(exit_val).
+
+    -exit_val (1): exit value returned by sys.exit() for a level 4
+    warning. Ignored for all other levels."""
+    
+    if level>0:
+        header = ['','','WARNING: ','ERROR: ','FATAL ERROR: ']
+        print >> Term.cerr, '%s%s' % (header[level],msg)
+        if level == 4:
+            print >> Term.cerr,'Exiting.\n'
+            sys.exit(exit_val)
+
+def info(msg):
+    """Equivalent to warn(msg,level=1)."""
+
+    warn(msg,level=1)
+
+def error(msg):
+    """Equivalent to warn(msg,level=3)."""
+
+    warn(msg,level=3)
+
+def fatal(msg,exit_val=1):
+    """Equivalent to warn(msg,exit_val=exit_val,level=4)."""
+
+    warn(msg,exit_val=exit_val,level=4)
+
+#----------------------------------------------------------------------------
+StringTypes = types.StringTypes
+
+# Basic timing functionality
+
+# If possible (Unix), use the resource module instead of time.clock()
+try:
+    import resource
+    def clock():
+        """clock() -> floating point number
+
+        Return the CPU time in seconds (user time only, system time is
+        ignored) since the start of the process.  This is done via a call to
+        resource.getrusage, so it avoids the wraparound problems in
+        time.clock()."""
+        
+        return resource.getrusage(resource.RUSAGE_SELF)[0]
+    
+    def clock2():
+        """clock2() -> (t_user,t_system)
+
+        Similar to clock(), but return a tuple of user/system times."""
+        return resource.getrusage(resource.RUSAGE_SELF)[:2]
+
+except ImportError:
+    clock = time.clock
+    def clock2():
+        """Under windows, system CPU time can't be measured.
+
+        This just returns clock() and zero."""
+        return time.clock(),0.0
+
+def timings_out(reps,func,*args,**kw):
+    """timings_out(reps,func,*args,**kw) -> (t_total,t_per_call,output)
+
+    Execute a function reps times, return a tuple with the elapsed total
+    CPU time in seconds, the time per call and the function's output.
+
+    Under Unix, the return value is the sum of user+system time consumed by
+    the process, computed via the resource module.  This prevents problems
+    related to the wraparound effect which the time.clock() function has.
+    
+    Under Windows the return value is in wall clock seconds. See the
+    documentation for the time module for more details."""
+
+    reps = int(reps)
+    assert reps >=1, 'reps must be >= 1'
+    if reps==1:
+        start = clock()
+        out = func(*args,**kw)
+        tot_time = clock()-start
+    else:
+        rng = xrange(reps-1) # the last time is executed separately to store output
+        start = clock()
+        for dummy in rng: func(*args,**kw)
+        out = func(*args,**kw)  # one last time
+        tot_time = clock()-start
+    av_time = tot_time / reps
+    return tot_time,av_time,out
+
+def timings(reps,func,*args,**kw):
+    """timings(reps,func,*args,**kw) -> (t_total,t_per_call)
+
+    Execute a function reps times, return a tuple with the elapsed total CPU
+    time in seconds and the time per call. These are just the first two values
+    in timings_out()."""
+
+    return timings_out(reps,func,*args,**kw)[0:2]
+
+def timing(func,*args,**kw):
+    """timing(func,*args,**kw) -> t_total
+
+    Execute a function once, return the elapsed total CPU time in
+    seconds. This is just the first value in timings_out()."""
+
+    return timings_out(1,func,*args,**kw)[0]
+
+#****************************************************************************
+# file and system
+
+def system(cmd,verbose=0,debug=0,header=''):
+    """Execute a system command, return its exit status.
+
+    Options:
+
+    - verbose (0): print the command to be executed.
+    
+    - debug (0): only print, do not actually execute.
+
+    - header (''): Header to print on screen prior to the executed command (it
+    is only prepended to the command, no newlines are added).
+
+    Note: a stateful version of this function is available through the
+    SystemExec class."""
+
+    stat = 0
+    if verbose or debug: print header+cmd
+    sys.stdout.flush()
+    if not debug: stat = os.system(cmd)
+    return stat
+
+def shell(cmd,verbose=0,debug=0,header=''):
+    """Execute a command in the system shell, always return None.
+
+    Options:
+
+    - verbose (0): print the command to be executed.
+    
+    - debug (0): only print, do not actually execute.
+
+    - header (''): Header to print on screen prior to the executed command (it
+    is only prepended to the command, no newlines are added).
+
+    Note: this is similar to genutils.system(), but it returns None so it can
+    be conveniently used in interactive loops without getting the return value
+    (typically 0) printed many times."""
+
+    stat = 0
+    if verbose or debug: print header+cmd
+    # flush stdout so we don't mangle python's buffering
+    sys.stdout.flush()
+    if not debug:
+        os.system(cmd)
+
+def getoutput(cmd,verbose=0,debug=0,header='',split=0):
+    """Dummy substitute for perl's backquotes.
+
+    Executes a command and returns the output.
+
+    Accepts the same arguments as system(), plus:
+
+    - split(0): if true, the output is returned as a list split on newlines.
+
+    Note: a stateful version of this function is available through the
+    SystemExec class."""
+
+    if verbose or debug: print header+cmd
+    if not debug:
+        output = commands.getoutput(cmd)
+        if split:
+            return output.split('\n')
+        else:
+            return output
+
+def getoutputerror(cmd,verbose=0,debug=0,header='',split=0):
+    """Return (standard output,standard error) of executing cmd in a shell.
+
+    Accepts the same arguments as system(), plus:
+
+    - split(0): if true, each of stdout/err is returned as a list split on
+    newlines.
+
+    Note: a stateful version of this function is available through the
+    SystemExec class."""
+
+    if verbose or debug: print header+cmd
+    if not cmd:
+        if split:
+            return [],[]
+        else:
+            return '',''
+    if not debug:
+        pin,pout,perr = os.popen3(cmd)
+        tout = pout.read().rstrip()
+        terr = perr.read().rstrip()
+        pin.close()
+        pout.close()
+        perr.close()
+        if split:
+            return tout.split('\n'),terr.split('\n')
+        else:
+            return tout,terr
+
+# for compatibility with older naming conventions
+xsys = system
+bq = getoutput
+
+class SystemExec:
+    """Access the system and getoutput functions through a stateful interface.
+
+    Note: here we refer to the system and getoutput functions from this
+    library, not the ones from the standard python library.
+    
+    This class offers the system and getoutput functions as methods, but the
+    verbose, debug and header parameters can be set for the instance (at
+    creation time or later) so that they don't need to be specified on each
+    call.
+
+    For efficiency reasons, there's no way to override the parameters on a
+    per-call basis other than by setting instance attributes. If you need
+    local overrides, it's best to directly call system() or getoutput().
+
+    The following names are provided as alternate options:
+     - xsys: alias to system
+     - bq: alias to getoutput
+
+    An instance can then be created as:
+     >>> sysexec = SystemExec(verbose=1,debug=0,header='Calling: ')
+
+    And used as:
+     >>> sysexec.xsys('pwd')
+     >>> dirlist = sysexec.bq('ls -l')
+    """
+    
+    def __init__(self,verbose=0,debug=0,header='',split=0):
+        """Specify the instance's values for verbose, debug and header."""
+        setattr_list(self,'verbose debug header split')
+
+    def system(self,cmd):
+        """Stateful interface to system(), with the same keyword parameters."""
+
+        system(cmd,self.verbose,self.debug,self.header)
+
+    def shell(self,cmd):
+        """Stateful interface to shell(), with the same keyword parameters."""
+
+        shell(cmd,self.verbose,self.debug,self.header)
+
+    xsys = system  # alias
+
+    def getoutput(self,cmd):
+        """Stateful interface to getoutput()."""
+
+        return getoutput(cmd,self.verbose,self.debug,self.header,self.split)
+
+    def getoutputerror(self,cmd):
+        """Stateful interface to getoutputerror()."""
+
+        return getoutputerror(cmd,self.verbose,self.debug,self.header,self.split)
+
+    bq = getoutput  # alias
+
+#-----------------------------------------------------------------------------
+def mutex_opts(dict,ex_op):
+    """Check for presence of mutually exclusive keys in a dict.
+
+    Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...]"""
+    for op1,op2 in ex_op:
+        if op1 in dict and op2 in dict:
+            raise ValueError,'\n*** ERROR in Arguments *** '\
+                  'Options '+op1+' and '+op2+' are mutually exclusive.'
+
+#-----------------------------------------------------------------------------
+def filefind(fname,alt_dirs = None):
+    """Return the given filename either in the current directory, if it
+    exists, or in a specified list of directories.
+
+    ~ expansion is done on all file and directory names.
+
+    Upon an unsuccessful search, raise an IOError exception."""
+
+    if alt_dirs is None:
+        try:
+            alt_dirs = get_home_dir()
+        except HomeDirError:
+            alt_dirs = os.getcwd()
+    search = [fname] + list_strings(alt_dirs)
+    search = map(os.path.expanduser,search)
+    #print 'search list for',fname,'list:',search  # dbg
+    fname = search[0]
+    if os.path.isfile(fname):
+        return fname
+    for direc in search[1:]:
+        testname = os.path.join(direc,fname)
+        #print 'testname',testname  # dbg
+        if os.path.isfile(testname):
+            return testname
+    raise IOError,'File' + `fname` + \
+          ' not found in current or supplied directories:' + `alt_dirs`
+
+#----------------------------------------------------------------------------
+def target_outdated(target,deps):
+    """Determine whether a target is out of date.
+
+    target_outdated(target,deps) -> 1/0
+
+    deps: list of filenames which MUST exist.
+    target: single filename which may or may not exist.
+
+    If target doesn't exist or is older than any file listed in deps, return
+    true, otherwise return false.
+    """
+    try:
+        target_time = os.path.getmtime(target)
+    except os.error:
+        return 1
+    for dep in deps:
+        dep_time = os.path.getmtime(dep)
+        if dep_time > target_time:
+            #print "For target",target,"Dep failed:",dep # dbg
+            #print "times (dep,tar):",dep_time,target_time # dbg
+            return 1
+    return 0
+
+#-----------------------------------------------------------------------------
+def target_update(target,deps,cmd):
+    """Update a target with a given command given a list of dependencies.
+
+    target_update(target,deps,cmd) -> runs cmd if target is outdated.
+
+    This is just a wrapper around target_outdated() which calls the given
+    command if target is outdated."""
+
+    if target_outdated(target,deps):
+        xsys(cmd)
+
+#----------------------------------------------------------------------------
+def unquote_ends(istr):
+    """Remove a single pair of quotes from the endpoints of a string."""
+
+    if not istr:
+        return istr
+    if (istr[0]=="'" and istr[-1]=="'") or \
+       (istr[0]=='"' and istr[-1]=='"'):
+        return istr[1:-1]
+    else:
+        return istr
+
+#----------------------------------------------------------------------------
+def process_cmdline(argv,names=[],defaults={},usage=''):
+    """ Process command-line options and arguments.
+
+    Arguments:
+
+    - argv: list of arguments, typically sys.argv.
+    
+    - names: list of option names. See DPyGetOpt docs for details on options
+    syntax.
+
+    - defaults: dict of default values.
+
+    - usage: optional usage notice to print if a wrong argument is passed.
+
+    Return a dict of options and a list of free arguments."""
+
+    getopt = DPyGetOpt.DPyGetOpt()
+    getopt.setIgnoreCase(0)
+    getopt.parseConfiguration(names)
+
+    try:
+        getopt.processArguments(argv)
+    except:
+        print usage
+        warn(`sys.exc_value`,level=4)
+
+    defaults.update(getopt.optionValues)
+    args = getopt.freeValues
+    
+    return defaults,args
+
+#----------------------------------------------------------------------------
+def optstr2types(ostr):
+    """Convert a string of option names to a dict of type mappings.
+
+    optstr2types(str) -> {None:'string_opts',int:'int_opts',float:'float_opts'}
+
+    This is used to get the types of all the options in a string formatted
+    with the conventions of DPyGetOpt. The 'type' None is used for options
+    which are strings (they need no further conversion). This function's main
+    use is to get a typemap for use with read_dict().
+    """
+
+    typeconv = {None:'',int:'',float:''}
+    typemap = {'s':None,'i':int,'f':float}
+    opt_re = re.compile(r'([\w]*)([^:=]*:?=?)([sif]?)')
+
+    for w in ostr.split():
+        oname,alias,otype = opt_re.match(w).groups()
+        if otype == '' or alias == '!':   # simple switches are integers too
+            otype = 'i'
+        typeconv[typemap[otype]] += oname + ' '
+    return typeconv
+
+#----------------------------------------------------------------------------
+def read_dict(filename,type_conv=None,**opt):
+
+    """Read a dictionary of key=value pairs from an input file, optionally
+    performing conversions on the resulting values.
+
+    read_dict(filename,type_conv,**opt) -> dict
+
+    Only one value per line is accepted, the format should be
+     # optional comments are ignored
+     key value\n
+
+    Args:
+
+      - type_conv: A dictionary specifying which keys need to be converted to
+      which types. By default all keys are read as strings. This dictionary
+      should have as its keys valid conversion functions for strings
+      (int,long,float,complex, or your own).  The value for each key
+      (converter) should be a whitespace separated string containing the names
+      of all the entries in the file to be converted using that function. For
+      keys to be left alone, use None as the conversion function (only needed
+      with purge=1, see below).
+
+      - opt: dictionary with extra options as below (default in parens)
+
+        purge(0): if set to 1, all keys *not* listed in type_conv are purged out
+        of the dictionary to be returned. If purge is going to be used, the
+        set of keys to be left as strings also has to be explicitly specified
+        using the (non-existent) conversion function None.
+
+        fs(None): field separator. This is the key/value separator to be used
+        when parsing the file. The None default means any whitespace [behavior
+        of string.split()].
+
+        strip(0): if 1, strip string values of leading/trailinig whitespace.
+
+        warn(1): warning level if requested keys are not found in file.
+          - 0: silently ignore.
+          - 1: inform but proceed.
+          - 2: raise KeyError exception.
+
+        no_empty(0): if 1, remove keys with whitespace strings as a value.
+
+        unique([]): list of keys (or space separated string) which can't be
+        repeated. If one such key is found in the file, each new instance
+        overwrites the previous one. For keys not listed here, the behavior is
+        to make a list of all appearances.
+
+    Example:
+    If the input file test.ini has:
+      i 3
+      x 4.5
+      y 5.5
+      s hi ho
+    Then:
+
+    >>> type_conv={int:'i',float:'x',None:'s'}
+    >>> read_dict('test.ini')
+    {'i': '3', 's': 'hi ho', 'x': '4.5', 'y': '5.5'}
+    >>> read_dict('test.ini',type_conv)
+    {'i': 3, 's': 'hi ho', 'x': 4.5, 'y': '5.5'}
+    >>> read_dict('test.ini',type_conv,purge=1)
+    {'i': 3, 's': 'hi ho', 'x': 4.5}
+    """
+
+    # starting config
+    opt.setdefault('purge',0)
+    opt.setdefault('fs',None)  # field sep defaults to any whitespace
+    opt.setdefault('strip',0)
+    opt.setdefault('warn',1)
+    opt.setdefault('no_empty',0)
+    opt.setdefault('unique','')
+    if type(opt['unique']) in StringTypes:
+        unique_keys = qw(opt['unique'])
+    elif type(opt['unique']) in (types.TupleType,types.ListType):
+        unique_keys = opt['unique']
+    else:
+        raise ValueError, 'Unique keys must be given as a string, List or Tuple'
+
+    dict = {}
+    # first read in table of values as strings
+    file = open(filename,'r')
+    for line in file.readlines():
+        line = line.strip()
+        if len(line) and line[0]=='#': continue
+        if len(line)>0:
+            lsplit = line.split(opt['fs'],1)
+            try:
+                key,val = lsplit
+            except ValueError:
+                key,val = lsplit[0],''
+            key = key.strip()
+            if opt['strip']: val = val.strip()
+            if val == "''" or val == '""': val = ''
+            if opt['no_empty'] and (val=='' or val.isspace()):
+                continue
+            # if a key is found more than once in the file, build a list
+            # unless it's in the 'unique' list. In that case, last found in file
+            # takes precedence. User beware.
+            try:
+                if dict[key] and key in unique_keys:
+                    dict[key] = val
+                elif type(dict[key]) is types.ListType:
+                    dict[key].append(val)
+                else:
+                    dict[key] = [dict[key],val]
+            except KeyError:
+                dict[key] = val
+    # purge if requested
+    if opt['purge']:
+        accepted_keys = qwflat(type_conv.values())
+        for key in dict.keys():
+            if key in accepted_keys: continue
+            del(dict[key])
+    # now convert if requested
+    if type_conv==None: return dict
+    conversions = type_conv.keys()
+    try: conversions.remove(None)
+    except: pass
+    for convert in conversions:
+        for val in qw(type_conv[convert]):
+            try:
+                dict[val] = convert(dict[val])
+            except KeyError,e:
+                if opt['warn'] == 0:
+                    pass
+                elif opt['warn'] == 1:
+                    print >>sys.stderr, 'Warning: key',val,\
+                          'not found in file',filename
+                elif opt['warn'] == 2:
+                    raise KeyError,e
+                else:
+                    raise ValueError,'Warning level must be 0,1 or 2'
+
+    return dict
+
+#----------------------------------------------------------------------------
+def flag_calls(func):
+    """Wrap a function to detect and flag when it gets called.
+
+    This is a decorator which takes a function and wraps it in a function with
+    a 'called' attribute. wrapper.called is initialized to False.
+
+    The wrapper.called attribute is set to False right before each call to the
+    wrapped function, so if the call fails it remains False.  After the call
+    completes, wrapper.called is set to True and the output is returned.
+
+    Testing for truth in wrapper.called allows you to determine if a call to
+    func() was attempted and succeeded."""
+    
+    def wrapper(*args,**kw):
+        wrapper.called = False
+        out = func(*args,**kw)
+        wrapper.called = True
+        return out
+
+    wrapper.called = False
+    wrapper.__doc__ = func.__doc__
+    return wrapper
+
+#----------------------------------------------------------------------------
+class HomeDirError(Error):
+    pass
+
+def get_home_dir():
+    """Return the closest possible equivalent to a 'home' directory.
+
+    We first try $HOME.  Absent that, on NT it's $HOMEDRIVE\$HOMEPATH.
+
+    Currently only Posix and NT are implemented, a HomeDirError exception is
+    raised for all other OSes. """ #'
+
+    try:
+        return os.environ['HOME']
+    except KeyError:
+        if os.name == 'posix':
+            raise HomeDirError,'undefined $HOME, IPython can not proceed.'
+        elif os.name == 'nt':
+            # For some strange reason, win9x returns 'nt' for os.name.
+            try:
+                return os.path.join(os.environ['HOMEDRIVE'],os.environ['HOMEPATH'])
+            except:
+                try:
+                    # Use the registry to get the 'My Documents' folder.
+                    import _winreg as wreg
+                    key = wreg.OpenKey(wreg.HKEY_CURRENT_USER,
+                                       "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
+                    homedir = wreg.QueryValueEx(key,'Personal')[0]
+                    key.Close()
+                    return homedir
+                except:
+                    return 'C:\\'
+        elif os.name == 'dos':
+            # Desperate, may do absurd things in classic MacOS. May work under DOS.
+            return 'C:\\'
+        else:
+            raise HomeDirError,'support for your operating system not implemented.'
+
+#****************************************************************************
+# strings and text
+
+class LSString(str):
+    """String derivative with a special access attributes.
+
+    These are normal strings, but with the special attributes:
+
+        .l (or .list) : value as list (split on newlines).
+        .n (or .nlstr): original value (the string itself).
+        .s (or .spstr): value as whitespace-separated string.
+        
+    Any values which require transformations are computed only once and
+    cached.
+
+    Such strings are very useful to efficiently interact with the shell, which
+    typically only understands whitespace-separated options for commands."""
+
+    def get_list(self):
+        try:
+            return self.__list
+        except AttributeError:
+            self.__list = self.split('\n')
+            return self.__list
+
+    l = list = property(get_list)
+
+    def get_spstr(self):
+        try:
+            return self.__spstr
+        except AttributeError:
+            self.__spstr = self.replace('\n',' ')
+            return self.__spstr
+
+    s = spstr = property(get_spstr)
+
+    def get_nlstr(self):
+        return self
+
+    n = nlstr = property(get_nlstr)
+
+class SList(list):
+    """List derivative with a special access attributes.
+
+    These are normal lists, but with the special attributes:
+
+        .l (or .list) : value as list (the list itself).
+        .n (or .nlstr): value as a string, joined on newlines.
+        .s (or .spstr): value as a string, joined on spaces.
+
+    Any values which require transformations are computed only once and
+    cached."""
+
+    def get_list(self):
+        return self
+
+    l = list = property(get_list)
+
+    def get_spstr(self):
+        try:
+            return self.__spstr
+        except AttributeError:
+            self.__spstr = ' '.join(self)
+            return self.__spstr
+
+    s = spstr = property(get_spstr)
+
+    def get_nlstr(self):
+        try:
+            return self.__nlstr
+        except AttributeError:
+            self.__nlstr = '\n'.join(self)
+            return self.__nlstr
+
+    n = nlstr = property(get_nlstr)
+
+def raw_input_multi(header='', ps1='==> ', ps2='..> ',terminate_str = '.'):
+    """Take multiple lines of input.
+
+    A list with each line of input as a separate element is returned when a
+    termination string is entered (defaults to a single '.'). Input can also
+    terminate via EOF (^D in Unix, ^Z-RET in Windows).
+
+    Lines of input which end in \\ are joined into single entries (and a
+    secondary continuation prompt is issued as long as the user terminates
+    lines with \\). This allows entering very long strings which are still
+    meant to be treated as single entities.
+    """
+
+    try:
+        if header:
+            header += '\n'
+        lines = [raw_input(header + ps1)]
+    except EOFError:
+        return []
+    terminate = [terminate_str]
+    try:
+        while lines[-1:] != terminate:
+            new_line = raw_input(ps1)
+            while new_line.endswith('\\'):
+                new_line = new_line[:-1] + raw_input(ps2)
+            lines.append(new_line)
+                
+        return lines[:-1]  # don't return the termination command
+    except EOFError:
+        print
+        return lines
+
+#----------------------------------------------------------------------------
+def raw_input_ext(prompt='',  ps2='... '):
+    """Similar to raw_input(), but accepts extended lines if input ends with \\."""
+
+    line = raw_input(prompt)
+    while line.endswith('\\'):
+        line = line[:-1] + raw_input(ps2)
+    return line
+
+#----------------------------------------------------------------------------
+def ask_yes_no(prompt,default=None):
+    """Asks a question and returns an integer 1/0 (y/n) answer.
+
+    If default is given (one of 'y','n'), it is used if the user input is
+    empty. Otherwise the question is repeated until an answer is given.
+    If EOF occurs 20 times consecutively, the default answer is assumed,
+    or if there is no default, an exception is raised to prevent infinite
+    loops.
+
+    Valid answers are: y/yes/n/no (match is not case sensitive)."""
+
+    answers = {'y':1,'n':0,'yes':1,'no':0}
+    ans = None
+    eofs, max_eofs = 0, 20
+    while ans not in answers.keys():
+        try:
+            ans = raw_input(prompt+' ').lower()
+            if not ans:  # response was an empty string
+                ans = default
+            eofs = 0
+        except (EOFError,KeyboardInterrupt):
+            eofs = eofs + 1
+            if eofs >= max_eofs:
+                if default in answers.keys():
+                    ans = default
+                else:
+                    raise
+            
+    return answers[ans]
+
+#----------------------------------------------------------------------------
+class EvalDict:
+    """
+    Emulate a dict which evaluates its contents in the caller's frame.
+
+    Usage:
+    >>>number = 19
+    >>>text = "python"
+    >>>print "%(text.capitalize())s %(number/9.0).1f rules!" % EvalDict()
+    """
+
+    # This version is due to [e-mail] on c.l.py, and is basically a
+    # modified (shorter) version of:
+    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66018 by
+    # Skip Montanaro ([e-mail]).
+
+    def __getitem__(self, name):
+        frame = sys._getframe(1)
+        return eval(name, frame.f_globals, frame.f_locals)
+
+EvalString = EvalDict  # for backwards compatibility
+#----------------------------------------------------------------------------
+def qw(words,flat=0,sep=None,maxsplit=-1):
+    """Similar to Perl's qw() operator, but with some more options.
+
+    qw(words,flat=0,sep=' ',maxsplit=-1) -> words.split(sep,maxsplit)
+
+    words can also be a list itself, and with flat=1, the output will be
+    recursively flattened. Examples:
+
+    >>> qw('1 2')
+    ['1', '2']
+    >>> qw(['a b','1 2',['m n','p q']])
+    [['a', 'b'], ['1', '2'], [['m', 'n'], ['p', 'q']]]
+    >>> qw(['a b','1 2',['m n','p q']],flat=1)
+    ['a', 'b', '1', '2', 'm', 'n', 'p', 'q']    """
+
+    if type(words) in StringTypes:
+        return [word.strip() for word in words.split(sep,maxsplit)
+                if word and not word.isspace() ]
+    if flat:
+        return flatten(map(qw,words,[1]*len(words)))
+    return map(qw,words)
+
+#----------------------------------------------------------------------------
+def qwflat(words,sep=None,maxsplit=-1):
+    """Calls qw(words) in flat mode. It's just a convenient shorthand."""
+    return qw(words,1,sep,maxsplit)
+
+#-----------------------------------------------------------------------------
+def list_strings(arg):
+    """Always return a list of strings, given a string or list of strings
+    as input."""
+
+    if type(arg) in StringTypes: return [arg]
+    else: return arg
+
+#----------------------------------------------------------------------------
+def grep(pat,list,case=1):
+    """Simple minded grep-like function.
+    grep(pat,list) returns occurrences of pat in list, None on failure.
+
+    It only does simple string matching, with no support for regexps. Use the
+    option case=0 for case-insensitive matching."""
+
+    # This is pretty crude. At least it should implement copying only references
+    # to the original data in case it's big. Now it copies the data for output.
+    out=[]
+    if case:
+        for term in list:
+            if term.find(pat)>-1: out.append(term)
+    else:
+        lpat=pat.lower()
+        for term in list:
+            if term.lower().find(lpat)>-1: out.append(term)
+
+    if len(out): return out
+    else: return None
+
+#----------------------------------------------------------------------------
+def dgrep(pat,*opts):
+    """Return grep() on dir()+dir(__builtins__).
+
+    A very common use of grep() when working interactively."""
+
+    return grep(pat,dir(__main__)+dir(__main__.__builtins__),*opts)
+
+#----------------------------------------------------------------------------
+def idgrep(pat):
+    """Case-insensitive dgrep()"""
+
+    return dgrep(pat,0)
+
+#----------------------------------------------------------------------------
+def igrep(pat,list):
+    """Synonym for case-insensitive grep."""
+
+    return grep(pat,list,case=0)
+
+#----------------------------------------------------------------------------
+def indent(str,nspaces=4,ntabs=0):
+    """Indent a string a given number of spaces or tabstops.
+    
+    indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
+    """
+    if str is None:
+        return
+    ind = '\t'*ntabs+' '*nspaces
+    outstr = '%s%s' % (ind,str.replace(os.linesep,os.linesep+ind))
+    if outstr.endswith(os.linesep+ind):
+        return outstr[:-len(ind)]
+    else:
+        return outstr
+    
+#-----------------------------------------------------------------------------
+def native_line_ends(filename,backup=1):
+    """Convert (in-place) a file to line-ends native to the current OS.
+
+    If the optional backup argument is given as false, no backup of the
+    original file is left.  """
+
+    backup_suffixes = {'posix':'~','dos':'.bak','nt':'.bak','mac':'.bak'}
+
+    bak_filename = filename + backup_suffixes[os.name]
+
+    original = open(filename).read()
+    shutil.copy2(filename,bak_filename)
+    try:
+        new = open(filename,'wb')
+        new.write(os.linesep.join(original.splitlines()))
+        new.write(os.linesep) # ALWAYS put an eol at the end of the file
+        new.close()
+    except:
+        os.rename(bak_filename,filename)
+    if not backup:
+        try:
+            os.remove(bak_filename)
+        except:
+            pass
+    
+#----------------------------------------------------------------------------
+def get_pager_cmd(pager_cmd = None):
+    """Return a pager command.
+
+    Makes some attempts at finding an OS-correct one."""
+    
+    if os.name == 'posix':
+        default_pager_cmd = 'less -r'  # -r for color control sequences
+    elif os.name in ['nt','dos']:
+        default_pager_cmd = 'type'
+
+    if pager_cmd is None:
+        try:
+            pager_cmd = os.environ['PAGER']
+        except:
+            pager_cmd = default_pager_cmd
+    return pager_cmd
+
+#-----------------------------------------------------------------------------
+def get_pager_start(pager,start):
+    """Return the string for paging files with an offset.
+
+    This is the '+N' argument which less and more (under Unix) accept.
+    """
+
+    if pager in ['less','more']:
+        if start:
+            start_string = '+' + str(start)
+        else:
+            start_string = ''
+    else:
+        start_string = ''
+    return start_string
+
+#----------------------------------------------------------------------------
+def page_dumb(strng,start=0,screen_lines=25):
+    """Very dumb 'pager' in Python, for when nothing else works.
+
+    Only moves forward, same interface as page(), except for pager_cmd and
+    mode."""
+
+    out_ln  = strng.splitlines()[start:]
+    screens = chop(out_ln,screen_lines-1)
+    if len(screens) == 1:
+        print >>Term.cout, os.linesep.join(screens[0])
+    else:
+        for scr in screens[0:-1]:
+            print >>Term.cout, os.linesep.join(scr)
+            ans = raw_input('---Return to continue, q to quit--- ')
+            if ans.lower().startswith('q'):
+                return
+        print >>Term.cout, os.linesep.join(screens[-1])
+
+#----------------------------------------------------------------------------
+def page(strng,start=0,screen_lines=0,pager_cmd = None):
+    """Print a string, piping through a pager after a certain length.
+
+    The screen_lines parameter specifies the number of *usable* lines of your
+    terminal screen (total lines minus lines you need to reserve to show other
+    information).
+
+    If you set screen_lines to a number <=0, page() will try to auto-determine
+    your screen size and will only use up to (screen_size+screen_lines) for
+    printing, paging after that. That is, if you want auto-detection but need
+    to reserve the bottom 3 lines of the screen, use screen_lines = -3, and for
+    auto-detection without any lines reserved simply use screen_lines = 0.
+
+    If a string won't fit in the allowed lines, it is sent through the
+    specified pager command. If none given, look for PAGER in the environment,
+    and ultimately default to less.
+
+    If no system pager works, the string is sent through a 'dumb pager'
+    written in python, very simplistic.
+    """
+    
+    # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
+    TERM = os.environ.get('TERM','dumb')
+    if TERM in ['dumb','emacs'] and os.name != 'nt':
+        print strng
+        return
+    # chop off the topmost part of the string we don't want to see
+    str_lines = strng.split(os.linesep)[start:]
+    str_toprint = os.linesep.join(str_lines)
+    num_newlines = len(str_lines)
+    len_str = len(str_toprint)
+    
+    # Dumb heuristics to guesstimate number of on-screen lines the string
+    # takes.  Very basic, but good enough for docstrings in reasonable
+    # terminals. If someone later feels like refining it, it's not hard.
+    numlines = max(num_newlines,int(len_str/80)+1)
+
+    screen_lines_def = 25 # default value if we can't auto-determine
+
+    # auto-determine screen size
+    if screen_lines <= 0:
+        if TERM=='xterm':
+            try:
+                import curses
+                if hasattr(curses,'initscr'):
+                    use_curses = 1
+                else:
+                    use_curses = 0
+            except ImportError:
+                use_curses = 0
+        else:
+            # curses causes problems on many terminals other than xterm.
+            use_curses = 0
+        if use_curses:
+                scr = curses.initscr()
+                screen_lines_real,screen_cols = scr.getmaxyx()
+                curses.endwin()
+                screen_lines += screen_lines_real
+                #print '***Screen size:',screen_lines_real,'lines x',\
+                #screen_cols,'columns.' # dbg
+        else:
+                screen_lines += screen_lines_def
+
+    #print 'numlines',numlines,'screenlines',screen_lines  # dbg
+    if numlines <= screen_lines :
+        #print '*** normal print'  # dbg
+        print >>Term.cout, str_toprint
+    else:
+        # Try to open pager and default to internal one if that fails.
+        # All failure modes are tagged as 'retval=1', to match the return
+        # value of a failed system command.  If any intermediate attempt
+        # sets retval to 1, at the end we resort to our own page_dumb() pager.
+        pager_cmd = get_pager_cmd(pager_cmd)
+        pager_cmd += ' ' + get_pager_start(pager_cmd,start)
+        if os.name == 'nt':
+            if pager_cmd.startswith('type'):
+                # The default WinXP 'type' command is failing on complex strings.
+                retval = 1
+            else:
+                tmpname = tempfile.mktemp('.txt')
+                tmpfile = file(tmpname,'wt')
+                tmpfile.write(strng)
+                tmpfile.close()
+                cmd = "%s < %s" % (pager_cmd,tmpname)
+                if os.system(cmd):
+                  retval = 1
+                else:
+                  retval = None
+                os.remove(tmpname)
+        else:
+            try:
+                retval = None
+                # if I use popen4, things hang. No idea why.
+                #pager,shell_out = os.popen4(pager_cmd)
+                pager = os.popen(pager_cmd,'w')
+                pager.write(strng)
+                pager.close()
+                retval = pager.close()  # success returns None
+            except IOError,msg:  # broken pipe when user quits
+                if msg.args == (32,'Broken pipe'):
+                    retval = None
+                else:
+                    retval = 1
+            except OSError:
+                # Other strange problems, sometimes seen in Win2k/cygwin
+                retval = 1
+        if retval is not None:
+            page_dumb(strng,screen_lines=screen_lines)
+
+#----------------------------------------------------------------------------
+def page_file(fname,start = 0, pager_cmd = None):
+    """Page a file, using an optional pager command and starting line.
+    """
+
+    pager_cmd = get_pager_cmd(pager_cmd)
+    pager_cmd += ' ' + get_pager_start(pager_cmd,start)
+
+    try:
+        if os.environ['TERM'] in ['emacs','dumb']:
+            raise EnvironmentError
+        xsys(pager_cmd + ' ' + fname)
+    except:
+        try:
+            if start > 0:
+                start -= 1
+            page(open(fname).read(),start)
+        except:
+            print 'Unable to show file',`fname`
+
+#----------------------------------------------------------------------------
+def snip_print(str,width = 75,print_full = 0,header = ''):
+    """Print a string snipping the midsection to fit in width.
+
+    print_full: mode control:
+      - 0: only snip long strings
+      - 1: send to page() directly.
+      - 2: snip long strings and ask for full length viewing with page()
+    Return 1 if snipping was necessary, 0 otherwise."""
+
+    if print_full == 1:
+        page(header+str)
+        return 0
+
+    print header,
+    if len(str) < width:
+        print str
+        snip = 0
+    else:
+        whalf = int((width -5)/2)
+        print str[:whalf] + ' <...> ' + str[-whalf:]
+        snip = 1
+    if snip and print_full == 2:
+        if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
+            page(str)
+    return snip
+
+#****************************************************************************
+# lists, dicts and structures
+
+def belong(candidates,checklist):
+    """Check whether a list of items appear in a given list of options.
+
+    Returns a list of 1 and 0, one for each candidate given."""
+
+    return [x in checklist for x in candidates]
+
+#----------------------------------------------------------------------------
+def uniq_stable(elems):
+    """uniq_stable(elems) -> list
+
+    Return from an iterable, a list of all the unique elements in the input,
+    but maintaining the order in which they first appear.
+
+    A naive solution to this problem which just makes a dictionary with the
+    elements as keys fails to respect the stability condition, since
+    dictionaries are unsorted by nature.
+
+    Note: All elements in the input must be valid dictionary keys for this
+    routine to work, as it internally uses a dictionary for efficiency
+    reasons."""
+    
+    unique = []
+    unique_dict = {}
+    for nn in elems:
+        if nn not in unique_dict:
+            unique.append(nn)
+            unique_dict[nn] = None
+    return unique
+
+#----------------------------------------------------------------------------
+class NLprinter:
+    """Print an arbitrarily nested list, indicating index numbers.
+
+    An instance of this class called nlprint is available and callable as a
+    function.
+    
+    nlprint(list,indent=' ',sep=': ') -> prints indenting each level by 'indent'
+    and using 'sep' to separate the index from the value. """
+
+    def __init__(self):
+        self.depth = 0
+    
+    def __call__(self,lst,pos='',**kw):
+        """Prints the nested list numbering levels."""
+        kw.setdefault('indent',' ')
+        kw.setdefault('sep',': ')
+        kw.setdefault('start',0)
+        kw.setdefault('stop',len(lst))
+        # we need to remove start and stop from kw so they don't propagate
+        # into a recursive call for a nested list.
+        start = kw['start']; del kw['start']
+        stop = kw['stop']; del kw['stop']
+        if self.depth == 0 and 'header' in kw.keys():
+            print kw['header']
+            
+        for idx in range(start,stop):
+            elem = lst[idx]
+            if type(elem)==type([]):
+                self.depth += 1
+                self.__call__(elem,itpl('$pos$idx,'),**kw)
+                self.depth -= 1
+            else:
+                printpl(kw['indent']*self.depth+'$pos$idx$kw["sep"]$elem')
+
+nlprint = NLprinter()
+#----------------------------------------------------------------------------
+def all_belong(candidates,checklist):
+    """Check whether a list of items ALL appear in a given list of options.
+
+    Returns a single 1 or 0 value."""
+
+    return 1-(0 in [x in checklist for x in candidates])
+
+#----------------------------------------------------------------------------
+def sort_compare(lst1,lst2,inplace = 1):
+    """Sort and compare two lists.
+
+    By default it does it in place, thus modifying the lists. Use inplace = 0
+    to avoid that (at the cost of temporary copy creation)."""
+    if not inplace:
+        lst1 = lst1[:]
+        lst2 = lst2[:]
+    lst1.sort(); lst2.sort()
+    return lst1 == lst2
+
+#----------------------------------------------------------------------------
+def mkdict(**kwargs):
+    """Return a dict from a keyword list.
+
+    It's just syntactic sugar for making ditcionary creation more convenient:
+    # the standard way
+    >>>data = { 'red' : 1, 'green' : 2, 'blue' : 3 }
+    # a cleaner way
+    >>>data = dict(red=1, green=2, blue=3)
+
+    If you need more than this, look at the Struct() class."""
+
+    return kwargs
+
+#----------------------------------------------------------------------------
+def list2dict(lst):
+    """Takes a list of (key,value) pairs and turns it into a dict."""
+
+    dic = {}
+    for k,v in lst: dic[k] = v
+    return dic
+
+#----------------------------------------------------------------------------
+def list2dict2(lst,default=''):
+    """Takes a list and turns it into a dict.
+    Much slower than list2dict, but more versatile. This version can take
+    lists with sublists of arbitrary length (including sclars)."""
+
+    dic = {}
+    for elem in lst:
+        if type(elem) in (types.ListType,types.TupleType):
+            size = len(elem)
+            if  size == 0:
+                pass
+            elif size == 1:
+                dic[elem] = default
+            else:
+                k,v = elem[0], elem[1:]
+                if len(v) == 1: v = v[0]
+                dic[k] = v
+        else:
+            dic[elem] = default
+    return dic
+
+#----------------------------------------------------------------------------
+def flatten(seq):
+    """Flatten a list of lists (NOT recursive, only works for 2d lists)."""
+
+    # bug in python??? (YES. Fixed in 2.2, let's leave the kludgy fix in).
+
+    # if the x=0 isn't made, a *global* variable x is left over after calling
+    # this function, with the value of the last element in the return
+    # list. This does seem like a bug big time to me.
+
+    # the problem is fixed with the x=0, which seems to force the creation of
+    # a local name
+
+    x = 0 
+    return [x for subseq in seq for x in subseq]
+
+#----------------------------------------------------------------------------
+def get_slice(seq,start=0,stop=None,step=1):
+    """Get a slice of a sequence with variable step. Specify start,stop,step."""
+    if stop == None:
+        stop = len(seq)
+    item = lambda i: seq[i]
+    return map(item,xrange(start,stop,step))
+
+#----------------------------------------------------------------------------
+def chop(seq,size):
+    """Chop a sequence into chunks of the given size."""
+    chunk = lambda i: seq[i:i+size]
+    return map(chunk,xrange(0,len(seq),size))
+
+#----------------------------------------------------------------------------
+def with(object, **args):
+    """Set multiple attributes for an object, similar to Pascal's with.
+
+    Example:
+    with(jim,
+         born = 1960,
+         haircolour = 'Brown',
+         eyecolour = 'Green')
+
+    Credit: Greg Ewing, in
+    http://mail.python.org/pipermail/python-list/2001-May/040703.html"""
+
+    object.__dict__.update(args)
+
+#----------------------------------------------------------------------------
+def setattr_list(obj,alist,nspace = None):
+    """Set a list of attributes for an object taken from a namespace.
+
+    setattr_list(obj,alist,nspace) -> sets in obj all the attributes listed in
+    alist with their values taken from nspace, which must be a dict (something
+    like locals() will often do) If nspace isn't given, locals() of the
+    *caller* is used, so in most cases you can omit it.
+
+    Note that alist can be given as a string, which will be automatically
+    split into a list on whitespace. If given as a list, it must be a list of
+    *strings* (the variable names themselves), not of variables."""
+
+    # this grabs the local variables from the *previous* call frame -- that is
+    # the locals from the function that called setattr_list().
+    # - snipped from weave.inline()
+    if nspace is None:
+        call_frame = sys._getframe().f_back
+        nspace = call_frame.f_locals
+
+    if type(alist) in StringTypes:
+        alist = alist.split()
+    for attr in alist:
+        val = eval(attr,nspace)
+        setattr(obj,attr,val)
+
+#----------------------------------------------------------------------------
+def getattr_list(obj,alist,*args):
+    """getattr_list(obj,alist[, default]) -> attribute list.
+
+    Get a list of named attributes for an object. When a default argument is
+    given, it is returned when the attribute doesn't exist; without it, an
+    exception is raised in that case.
+
+    Note that alist can be given as a string, which will be automatically
+    split into a list on whitespace. If given as a list, it must be a list of
+    *strings* (the variable names themselves), not of variables."""
+
+    if type(alist) in StringTypes:
+        alist = alist.split()
+    if args:
+        if len(args)==1:
+            default = args[0]
+            return map(lambda attr: getattr(obj,attr,default),alist)
+        else:
+            raise ValueError,'getattr_list() takes only one optional argument'
+    else:
+        return map(lambda attr: getattr(obj,attr),alist)
+    
+#----------------------------------------------------------------------------
+def map_method(method,object_list,*argseq,**kw):
+    """map_method(method,object_list,*args,**kw) -> list
+
+    Return a list of the results of applying the methods to the items of the
+    argument sequence(s).  If more than one sequence is given, the method is
+    called with an argument list consisting of the corresponding item of each
+    sequence. All sequences must be of the same length.
+
+    Keyword arguments are passed verbatim to all objects called.
+
+    This is Python code, so it's not nearly as fast as the builtin map()."""
+
+    out_list = []
+    idx = 0
+    for object in object_list:
+        try:
+            handler = getattr(object, method)
+        except AttributeError:
+            out_list.append(None)
+        else:
+            if argseq:
+                args = map(lambda lst:lst[idx],argseq)
+                #print 'ob',object,'hand',handler,'ar',args # dbg
+                out_list.append(handler(args,**kw))
+            else:
+                out_list.append(handler(**kw))
+        idx += 1
+    return out_list
+
+#----------------------------------------------------------------------------
+# Proposed popitem() extension, written as a method
+
+class NotGiven: pass
+
+def popkey(dct,key,default=NotGiven):
+    """Return dct[key] and delete dct[key].
+
+    If default is given, return it if dct[key] doesn't exist, otherwise raise
+    KeyError.  """
+
+    try:
+        val = dct[key]
+    except KeyError:
+        if default is NotGiven:
+            raise
+        else:
+            return default
+    else:
+        del dct[key]
+        return val
+#*************************** end of file <genutils.py> **********************
+

IPython/hooks.py

@@ -0,0 +1,72 b''
+"""hooks for IPython.
+
+In Python, it is possible to overwrite any method of any object if you really
+want to.  But IPython exposes a few 'hooks', methods which are _designed_ to
+be overwritten by users for customization purposes.  This module defines the
+default versions of all such hooks, which get used by IPython if not
+overridden by the user.
+
+hooks are simple functions, but they should be declared with 'self' as their
+first argument, because when activated they are registered into IPython as
+instance methods.  The self argument will be the IPython running instance
+itself, so hooks have full access to the entire IPython object.
+
+If you wish to define a new hook and activate it, you need to put the
+necessary code into a python file which can be either imported or execfile()'d
+from within your ipythonrc configuration.
+
+For example, suppose that you have a module called 'myiphooks' in your
+PYTHONPATH, which contains the following definition:
+
+import os
+def calljed(self,filename, linenum):
+    "My editor hook calls the jed editor directly."
+    print "Calling my own editor, jed ..."
+    os.system('jed +%d %s' % (linenum,filename))
+
+You can then execute the following line of code to make it the new IPython
+editor hook, after having imported 'myiphooks':
+
+ip_set_hook('editor',myiphooks.calljed)
+
+The ip_set_hook function is put by IPython into the builtin namespace, so it
+is always available from all running code.
+
+$Id: hooks.py 535 2005-03-02 08:42:25Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2005 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
+
+import os
+
+# List here all the default hooks.  For now it's just the editor, but over
+# time we'll move here all the public API for user-accessible things.
+__all__ = ['editor']
+
+def editor(self,filename, linenum):
+    """Open the default editor at the given filename and linenumber.
+
+    This is IPython's default editor hook, you can use it as an example to
+    write your own modified one.  To set your own editor function as the
+    new editor hook, call ip_set_hook('editor',yourfunc)."""
+
+    # IPython configures a default editor at startup by reading $EDITOR from
+    # the environment, and falling back on vi (unix) or notepad (win32).
+    editor = self.rc.editor
+    
+    # marker for at which line to open the file (for existing objects)
+    if linenum is None or editor=='notepad':
+        linemark = ''
+    else:
+        linemark = '+%d' % linenum
+    # Call the actual editor
+    os.system('%s %s %s' % (editor,linemark,filename))