crlf -> lf

IPython/ColorANSI.py

@@ -1,170 +1,170 b''
-# -*- coding: utf-8 -*-
-"""Tools for coloring text in ANSI terminals.
-
-$Id: ColorANSI.py 2167 2007-03-21 06:57:50Z fperez $"""
-
-#*****************************************************************************
-#       Copyright (C) 2002-2006 Fernando Perez. <[e-mail]>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
-__all__ = ['TermColors','InputTermColors','ColorScheme','ColorSchemeTable']
-
-import os
-
-from IPython.ipstruct import Struct
-
-def make_color_table(in_class):
-    """Build a set of color attributes in a class.
-
-    Helper function for building the *TermColors classes."""
-    
-    color_templates = (
-        ("Black"       , "0;30"),
-        ("Red"         , "0;31"),
-        ("Green"       , "0;32"),
-        ("Brown"       , "0;33"),
-        ("Blue"        , "0;34"),
-        ("Purple"      , "0;35"),
-        ("Cyan"        , "0;36"),
-        ("LightGray"   , "0;37"),
-        ("DarkGray"    , "1;30"),
-        ("LightRed"    , "1;31"),
-        ("LightGreen"  , "1;32"),
-        ("Yellow"      , "1;33"),
-        ("LightBlue"   , "1;34"),
-        ("LightPurple" , "1;35"),
-        ("LightCyan"   , "1;36"),
-        ("White"       , "1;37"),  )
-
-    for name,value in color_templates:
-        setattr(in_class,name,in_class._base % value)
-
-class TermColors:
-    """Color escape sequences.
-
-    This class defines the escape sequences for all the standard (ANSI?) 
-    colors in terminals. Also defines a NoColor escape which is just the null
-    string, suitable for defining 'dummy' color schemes in terminals which get
-    confused by color escapes.
-
-    This class should be used as a mixin for building color schemes."""
-    
-    NoColor = ''  # for color schemes in color-less terminals.
-    Normal = '\033[0m'   # Reset normal coloring
-    _base  = '\033[%sm'  # Template for all other colors
-
-# Build the actual color table as a set of class attributes:
-make_color_table(TermColors)
-
-class InputTermColors:
-    """Color escape sequences for input prompts.
-
-    This class is similar to TermColors, but the escapes are wrapped in \001
-    and \002 so that readline can properly know the length of each line and
-    can wrap lines accordingly.  Use this class for any colored text which
-    needs to be used in input prompts, such as in calls to raw_input().
-
-    This class defines the escape sequences for all the standard (ANSI?) 
-    colors in terminals. Also defines a NoColor escape which is just the null
-    string, suitable for defining 'dummy' color schemes in terminals which get
-    confused by color escapes.
-
-    This class should be used as a mixin for building color schemes."""
-    
-    NoColor = ''  # for color schemes in color-less terminals.
-
-    if os.name == 'nt' and os.environ.get('TERM','dumb') == 'emacs':
-        # (X)emacs on W32 gets confused with \001 and \002 so we remove them
-        Normal = '\033[0m'   # Reset normal coloring
-        _base  = '\033[%sm'  # Template for all other colors
-    else:
-        Normal = '\001\033[0m\002'   # Reset normal coloring
-        _base  = '\001\033[%sm\002'  # Template for all other colors
-
-# Build the actual color table as a set of class attributes:
-make_color_table(InputTermColors)
-
-class ColorScheme:
-    """Generic color scheme class. Just a name and a Struct."""
-    def __init__(self,__scheme_name_,colordict=None,**colormap):
-        self.name = __scheme_name_
-        if colordict is None:
-            self.colors = Struct(**colormap)
-        else:
-            self.colors = Struct(colordict)
-
-    def copy(self,name=None):
-        """Return a full copy of the object, optionally renaming it."""
-        if name is None:
-            name = self.name
-        return ColorScheme(name,self.colors.__dict__)
-        
-class ColorSchemeTable(dict):
-    """General class to handle tables of color schemes.
-
-    It's basically a dict of color schemes with a couple of shorthand
-    attributes and some convenient methods.
-    
-    active_scheme_name -> obvious
-    active_colors -> actual color table of the active scheme"""
-
-    def __init__(self,scheme_list=None,default_scheme=''):
-        """Create a table of color schemes.
-
-        The table can be created empty and manually filled or it can be
-        created with a list of valid color schemes AND the specification for
-        the default active scheme.
-        """
-        
-        # create object attributes to be set later
-        self.active_scheme_name = ''
-        self.active_colors = None
-        
-        if scheme_list:
-            if default_scheme == '':
-                raise ValueError,'you must specify the default color scheme'
-            for scheme in scheme_list:
-                self.add_scheme(scheme)
-            self.set_active_scheme(default_scheme)
-
-    def copy(self):
-        """Return full copy of object"""
-        return ColorSchemeTable(self.values(),self.active_scheme_name)
-
-    def add_scheme(self,new_scheme):
-        """Add a new color scheme to the table."""
-        if not isinstance(new_scheme,ColorScheme):
-            raise ValueError,'ColorSchemeTable only accepts ColorScheme instances'
-        self[new_scheme.name] = new_scheme
-        
-    def set_active_scheme(self,scheme,case_sensitive=0):
-        """Set the currently active scheme.
-
-        Names are by default compared in a case-insensitive way, but this can
-        be changed by setting the parameter case_sensitive to true."""
-
-        scheme_names = self.keys()
-        if case_sensitive:
-            valid_schemes = scheme_names
-            scheme_test = scheme
-        else:
-            valid_schemes = [s.lower() for s in scheme_names]
-            scheme_test = scheme.lower()
-        try:
-            scheme_idx = valid_schemes.index(scheme_test)
-        except ValueError:
-            raise ValueError,'Unrecognized color scheme: ' + scheme + \
-                  '\nValid schemes: '+str(scheme_names).replace("'', ",'')
-        else:
-            active = scheme_names[scheme_idx]
-            self.active_scheme_name = active
-            self.active_colors = self[active].colors
-            # Now allow using '' as an index for the current active scheme
-            self[''] = self[active]
+# -*- coding: utf-8 -*-
+"""Tools for coloring text in ANSI terminals.
+
+$Id: ColorANSI.py 2167 2007-03-21 06:57:50Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2002-2006 Fernando Perez. <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+__all__ = ['TermColors','InputTermColors','ColorScheme','ColorSchemeTable']
+
+import os
+
+from IPython.ipstruct import Struct
+
+def make_color_table(in_class):
+    """Build a set of color attributes in a class.
+
+    Helper function for building the *TermColors classes."""
+    
+    color_templates = (
+        ("Black"       , "0;30"),
+        ("Red"         , "0;31"),
+        ("Green"       , "0;32"),
+        ("Brown"       , "0;33"),
+        ("Blue"        , "0;34"),
+        ("Purple"      , "0;35"),
+        ("Cyan"        , "0;36"),
+        ("LightGray"   , "0;37"),
+        ("DarkGray"    , "1;30"),
+        ("LightRed"    , "1;31"),
+        ("LightGreen"  , "1;32"),
+        ("Yellow"      , "1;33"),
+        ("LightBlue"   , "1;34"),
+        ("LightPurple" , "1;35"),
+        ("LightCyan"   , "1;36"),
+        ("White"       , "1;37"),  )
+
+    for name,value in color_templates:
+        setattr(in_class,name,in_class._base % value)
+
+class TermColors:
+    """Color escape sequences.
+
+    This class defines the escape sequences for all the standard (ANSI?) 
+    colors in terminals. Also defines a NoColor escape which is just the null
+    string, suitable for defining 'dummy' color schemes in terminals which get
+    confused by color escapes.
+
+    This class should be used as a mixin for building color schemes."""
+    
+    NoColor = ''  # for color schemes in color-less terminals.
+    Normal = '\033[0m'   # Reset normal coloring
+    _base  = '\033[%sm'  # Template for all other colors
+
+# Build the actual color table as a set of class attributes:
+make_color_table(TermColors)
+
+class InputTermColors:
+    """Color escape sequences for input prompts.
+
+    This class is similar to TermColors, but the escapes are wrapped in \001
+    and \002 so that readline can properly know the length of each line and
+    can wrap lines accordingly.  Use this class for any colored text which
+    needs to be used in input prompts, such as in calls to raw_input().
+
+    This class defines the escape sequences for all the standard (ANSI?) 
+    colors in terminals. Also defines a NoColor escape which is just the null
+    string, suitable for defining 'dummy' color schemes in terminals which get
+    confused by color escapes.
+
+    This class should be used as a mixin for building color schemes."""
+    
+    NoColor = ''  # for color schemes in color-less terminals.
+
+    if os.name == 'nt' and os.environ.get('TERM','dumb') == 'emacs':
+        # (X)emacs on W32 gets confused with \001 and \002 so we remove them
+        Normal = '\033[0m'   # Reset normal coloring
+        _base  = '\033[%sm'  # Template for all other colors
+    else:
+        Normal = '\001\033[0m\002'   # Reset normal coloring
+        _base  = '\001\033[%sm\002'  # Template for all other colors
+
+# Build the actual color table as a set of class attributes:
+make_color_table(InputTermColors)
+
+class ColorScheme:
+    """Generic color scheme class. Just a name and a Struct."""
+    def __init__(self,__scheme_name_,colordict=None,**colormap):
+        self.name = __scheme_name_
+        if colordict is None:
+            self.colors = Struct(**colormap)
+        else:
+            self.colors = Struct(colordict)
+
+    def copy(self,name=None):
+        """Return a full copy of the object, optionally renaming it."""
+        if name is None:
+            name = self.name
+        return ColorScheme(name,self.colors.__dict__)
+        
+class ColorSchemeTable(dict):
+    """General class to handle tables of color schemes.
+
+    It's basically a dict of color schemes with a couple of shorthand
+    attributes and some convenient methods.
+    
+    active_scheme_name -> obvious
+    active_colors -> actual color table of the active scheme"""
+
+    def __init__(self,scheme_list=None,default_scheme=''):
+        """Create a table of color schemes.
+
+        The table can be created empty and manually filled or it can be
+        created with a list of valid color schemes AND the specification for
+        the default active scheme.
+        """
+        
+        # create object attributes to be set later
+        self.active_scheme_name = ''
+        self.active_colors = None
+        
+        if scheme_list:
+            if default_scheme == '':
+                raise ValueError,'you must specify the default color scheme'
+            for scheme in scheme_list:
+                self.add_scheme(scheme)
+            self.set_active_scheme(default_scheme)
+
+    def copy(self):
+        """Return full copy of object"""
+        return ColorSchemeTable(self.values(),self.active_scheme_name)
+
+    def add_scheme(self,new_scheme):
+        """Add a new color scheme to the table."""
+        if not isinstance(new_scheme,ColorScheme):
+            raise ValueError,'ColorSchemeTable only accepts ColorScheme instances'
+        self[new_scheme.name] = new_scheme
+        
+    def set_active_scheme(self,scheme,case_sensitive=0):
+        """Set the currently active scheme.
+
+        Names are by default compared in a case-insensitive way, but this can
+        be changed by setting the parameter case_sensitive to true."""
+
+        scheme_names = self.keys()
+        if case_sensitive:
+            valid_schemes = scheme_names
+            scheme_test = scheme
+        else:
+            valid_schemes = [s.lower() for s in scheme_names]
+            scheme_test = scheme.lower()
+        try:
+            scheme_idx = valid_schemes.index(scheme_test)
+        except ValueError:
+            raise ValueError,'Unrecognized color scheme: ' + scheme + \
+                  '\nValid schemes: '+str(scheme_names).replace("'', ",'')
+        else:
+            active = scheme_names[scheme_idx]
+            self.active_scheme_name = active
+            self.active_colors = self[active].colors
+            # Now allow using '' as an index for the current active scheme
+            self[''] = self[active]

IPython/ConfigLoader.py

@@ -1,116 +1,116 b''
-# -*- coding: utf-8 -*-
-"""Configuration loader
-
-$Id: ConfigLoader.py 1005 2006-01-12 08:39:26Z fperez $"""
-
-#*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
-import exceptions
-import os
-from pprint import pprint
-
-from IPython import ultraTB
-from IPython.ipstruct import Struct
-from IPython.genutils import *
-
-class ConfigLoaderError(exceptions.Exception):
-    """Exception for ConfigLoader class."""
-
-    def __init__(self,args=None):
-        self.args = args
-
-class ConfigLoader:
-
-    """Configuration file loader capable of handling recursive inclusions and
-    with parametrized conflict resolution for multiply found keys."""
-
-    def __init__(self,conflict=None,field_sep=None,reclimit=15):
-
-        """The reclimit parameter controls the number of recursive
-        configuration file inclusions. This way we can stop early on (before
-        python's own recursion limit is hit) if there is a circular
-        inclusion.
-
-        - conflict: dictionary for conflict resolutions (see Struct.merge())
-
-        """
-        self.conflict = conflict
-        self.field_sep = field_sep
-        self.reset(reclimit)
-        
-    def reset(self,reclimit=15):
-        self.reclimit = reclimit
-        self.recdepth = 0
-        self.included = []
-        
-    def load(self,fname,convert=None,recurse_key='',incpath = '.',**kw):
-        """Load a configuration file, return the resulting Struct.
-
-        Call: load_config(fname,convert=None,conflict=None,recurse_key='')
-
-         - fname: file to load from.
-         - convert: dictionary of type conversions (see read_dict())
-         - recurse_key: keyword in dictionary to trigger recursive file
-         inclusions.
-         """
-
-        if self.recdepth > self.reclimit:
-            raise ConfigLoaderError, 'maximum recursive inclusion of rcfiles '+\
-                  'exceeded: ' + `self.recdepth` + \
-                  '.\nMaybe you have a circular chain of inclusions?'
-        self.recdepth += 1
-        fname = filefind(fname,incpath)
-        data = Struct()
-        # avoid including the same file more than once
-        if fname in self.included:
-            return data
-        Xinfo = ultraTB.AutoFormattedTB()
-        if convert==None and recurse_key : convert = {qwflat:recurse_key}
-        # for production, change warn to 0:
-        data.merge(read_dict(fname,convert,fs=self.field_sep,strip=1,
-                             warn=0,no_empty=0,**kw))
-        # keep track of successfully loaded files
-        self.included.append(fname)
-        if recurse_key in data.keys():
-            for incfilename in data[recurse_key]:
-                found=0
-                try:
-                    incfile = filefind(incfilename,incpath)
-                except IOError:
-                    if os.name in ['nt','dos']:
-                        try:
-                            # Try again with '.ini' extension
-                            incfilename += '.ini'
-                            incfile = filefind(incfilename,incpath)
-                        except IOError:
-                            found = 0
-                        else:
-                            found = 1
-                    else:
-                        found = 0
-                else:
-                    found = 1
-                if found:
-                    try:
-                        data.merge(self.load(incfile,convert,recurse_key,
-                                             incpath,**kw),
-                                   self.conflict)
-                    except:
-                        Xinfo()
-                        warn('Problem loading included file: '+
-                             `incfilename` + '. Ignoring it...')
-                else:
-                    warn('File `%s` not found. Included by %s' % (incfilename,fname))
-
-        return data
-
-# end ConfigLoader
+# -*- coding: utf-8 -*-
+"""Configuration loader
+
+$Id: ConfigLoader.py 1005 2006-01-12 08:39:26Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+import exceptions
+import os
+from pprint import pprint
+
+from IPython import ultraTB
+from IPython.ipstruct import Struct
+from IPython.genutils import *
+
+class ConfigLoaderError(exceptions.Exception):
+    """Exception for ConfigLoader class."""
+
+    def __init__(self,args=None):
+        self.args = args
+
+class ConfigLoader:
+
+    """Configuration file loader capable of handling recursive inclusions and
+    with parametrized conflict resolution for multiply found keys."""
+
+    def __init__(self,conflict=None,field_sep=None,reclimit=15):
+
+        """The reclimit parameter controls the number of recursive
+        configuration file inclusions. This way we can stop early on (before
+        python's own recursion limit is hit) if there is a circular
+        inclusion.
+
+        - conflict: dictionary for conflict resolutions (see Struct.merge())
+
+        """
+        self.conflict = conflict
+        self.field_sep = field_sep
+        self.reset(reclimit)
+        
+    def reset(self,reclimit=15):
+        self.reclimit = reclimit
+        self.recdepth = 0
+        self.included = []
+        
+    def load(self,fname,convert=None,recurse_key='',incpath = '.',**kw):
+        """Load a configuration file, return the resulting Struct.
+
+        Call: load_config(fname,convert=None,conflict=None,recurse_key='')
+
+         - fname: file to load from.
+         - convert: dictionary of type conversions (see read_dict())
+         - recurse_key: keyword in dictionary to trigger recursive file
+         inclusions.
+         """
+
+        if self.recdepth > self.reclimit:
+            raise ConfigLoaderError, 'maximum recursive inclusion of rcfiles '+\
+                  'exceeded: ' + `self.recdepth` + \
+                  '.\nMaybe you have a circular chain of inclusions?'
+        self.recdepth += 1
+        fname = filefind(fname,incpath)
+        data = Struct()
+        # avoid including the same file more than once
+        if fname in self.included:
+            return data
+        Xinfo = ultraTB.AutoFormattedTB()
+        if convert==None and recurse_key : convert = {qwflat:recurse_key}
+        # for production, change warn to 0:
+        data.merge(read_dict(fname,convert,fs=self.field_sep,strip=1,
+                             warn=0,no_empty=0,**kw))
+        # keep track of successfully loaded files
+        self.included.append(fname)
+        if recurse_key in data.keys():
+            for incfilename in data[recurse_key]:
+                found=0
+                try:
+                    incfile = filefind(incfilename,incpath)
+                except IOError:
+                    if os.name in ['nt','dos']:
+                        try:
+                            # Try again with '.ini' extension
+                            incfilename += '.ini'
+                            incfile = filefind(incfilename,incpath)
+                        except IOError:
+                            found = 0
+                        else:
+                            found = 1
+                    else:
+                        found = 0
+                else:
+                    found = 1
+                if found:
+                    try:
+                        data.merge(self.load(incfile,convert,recurse_key,
+                                             incpath,**kw),
+                                   self.conflict)
+                    except:
+                        Xinfo()
+                        warn('Problem loading included file: '+
+                             `incfilename` + '. Ignoring it...')
+                else:
+                    warn('File `%s` not found. Included by %s' % (incfilename,fname))
+
+        return data
+
+# end ConfigLoader

IPython/CrashHandler.py

@@ -1,228 +1,228 b''
-# -*- coding: utf-8 -*-
-"""sys.excepthook for IPython itself, leaves a detailed report on disk.
-
-$Id: CrashHandler.py 2908 2007-12-30 21:07:46Z vivainio $"""
-
-#*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-from IPython import Release
-__author__   = '%s <%s>' % Release.authors['Fernando']
-__license__  = Release.license
-__version__  = Release.version
-
-#****************************************************************************
-# Required modules
-
-# From the standard library
-import os
-import sys
-from pprint import pprint,pformat
-
-# Homebrewed
-from IPython.Itpl import Itpl,itpl,printpl
-from IPython.ColorANSI import ColorScheme,ColorSchemeTable  # too long names
-from IPython import ultraTB
-from IPython.genutils import *
-
-#****************************************************************************
-class CrashHandler:
-    """Customizable crash handlers for IPython-based systems.
-
-    Instances of this class provide a __call__ method which can be used as a
-    sys.excepthook, i.e., the __call__ signature is:
-
-        def __call__(self,etype, evalue, etb)
-
-    """
-
-    def __init__(self,IP,app_name,contact_name,contact_email,
-                 bug_tracker,crash_report_fname,
-                 show_crash_traceback=True):
-        """New crash handler.
-
-        Inputs:
-
-        - IP: a running IPython instance, which will be queried at crash time
-        for internal information.
-
-        - app_name: a string containing the name of your application.
-
-        - contact_name: a string with the name of the person to contact.
-
-        - contact_email: a string with the email address of the contact.
-
-        - bug_tracker: a string with the URL for your project's bug tracker.
-
-        - crash_report_fname: a string with the filename for the crash report
-        to be saved in.  These reports are left in the ipython user directory
-        as determined by the running IPython instance.
-
-        Optional inputs:
-        
-        - show_crash_traceback(True): if false, don't print the crash
-        traceback on stderr, only generate the on-disk report
-
-
-        Non-argument instance attributes:
-
-        These instances contain some non-argument attributes which allow for 
-        further customization of the crash handler's behavior.  Please see the
-        source for further details.
-        """
-
-        # apply args into instance
-        self.IP = IP  # IPython instance
-        self.app_name = app_name
-        self.contact_name = contact_name
-        self.contact_email = contact_email
-        self.bug_tracker = bug_tracker
-        self.crash_report_fname = crash_report_fname
-        self.show_crash_traceback = show_crash_traceback
-        
-        # Hardcoded defaults, which can be overridden either by subclasses or
-        # at runtime for the instance.
-
-        # Template for the user message.  Subclasses which completely override
-        # this, or user apps, can modify it to suit their tastes.  It gets
-        # expanded using itpl, so calls of the kind $self.foo are valid.
-        self.user_message_template = """
-Oops, $self.app_name crashed. We do our best to make it stable, but...
-
-A crash report was automatically generated with the following information:
-  - A verbatim copy of the crash traceback.
-  - A copy of your input history during this session.
-  - Data on your current $self.app_name configuration.
-
-It was left in the file named:
-\t'$self.crash_report_fname'
-If you can email this file to the developers, the information in it will help
-them in understanding and correcting the problem.
-
-You can mail it to: $self.contact_name at $self.contact_email
-with the subject '$self.app_name Crash Report'.
-
-If you want to do it now, the following command will work (under Unix):
-mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
-
-To ensure accurate tracking of this issue, please file a report about it at:
-$self.bug_tracker
-"""
-
-    def __call__(self,etype, evalue, etb):
-        """Handle an exception, call for compatible with sys.excepthook"""
-
-        # Report tracebacks shouldn't use color in general (safer for users)
-        color_scheme = 'NoColor'
-
-        # Use this ONLY for developer debugging (keep commented out for release)
-        #color_scheme = 'Linux'   # dbg
-        
-        try:
-            rptdir = self.IP.rc.ipythondir
-        except:
-            rptdir = os.getcwd()
-        if not os.path.isdir(rptdir):
-            rptdir = os.getcwd()
-        report_name = os.path.join(rptdir,self.crash_report_fname)
-        # write the report filename into the instance dict so it can get
-        # properly expanded out in the user message template
-        self.crash_report_fname = report_name
-        TBhandler = ultraTB.VerboseTB(color_scheme=color_scheme,
-                                           long_header=1)
-        traceback = TBhandler.text(etype,evalue,etb,context=31)
-
-        # print traceback to screen
-        if self.show_crash_traceback:
-            print >> sys.stderr, traceback
-
-        # and generate a complete report on disk
-        try:
-            report = open(report_name,'w')
-        except:
-            print >> sys.stderr, 'Could not create crash report on disk.'
-            return
-
-        # Inform user on stderr of what happened
-        msg = itpl('\n'+'*'*70+'\n'+self.user_message_template)
-        print >> sys.stderr, msg
-
-        # Construct report on disk
-        report.write(self.make_report(traceback))
-        report.close()
-        raw_input("Press enter to exit:")
-
-    def make_report(self,traceback):
-        """Return a string containing a crash report."""
-
-        sec_sep = '\n\n'+'*'*75+'\n\n'
-
-        report = []
-        rpt_add = report.append
-        
-        rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
-        rpt_add('IPython version: %s \n\n' % Release.version)
-        rpt_add('SVN revision   : %s \n\n' % Release.revision)
-        rpt_add('Platform info  : os.name -> %s, sys.platform -> %s' %
-                     (os.name,sys.platform) )
-        rpt_add(sec_sep+'Current user configuration structure:\n\n')
-        rpt_add(pformat(self.IP.rc.dict()))
-        rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
-        try:
-            rpt_add(sec_sep+"History of session input:")
-            for line in self.IP.user_ns['_ih']:
-                rpt_add(line)
-            rpt_add('\n*** Last line of input (may not be in above history):\n')
-            rpt_add(self.IP._last_input_line+'\n')
-        except:
-            pass
-
-        return ''.join(report)
-
-class IPythonCrashHandler(CrashHandler):
-    """sys.excepthook for IPython itself, leaves a detailed report on disk."""
-    
-    def __init__(self,IP):
-
-        # Set here which of the IPython authors should be listed as contact
-        AUTHOR_CONTACT = 'Ville'
-        
-        # Set argument defaults
-        app_name = 'IPython'
-        bug_tracker = 'http://projects.scipy.org/ipython/ipython/report'
-        contact_name,contact_email = Release.authors[AUTHOR_CONTACT][:2]
-        crash_report_fname = 'IPython_crash_report.txt'
-        # Call parent constructor
-        CrashHandler.__init__(self,IP,app_name,contact_name,contact_email,
-                              bug_tracker,crash_report_fname)
-
-    def make_report(self,traceback):
-        """Return a string containing a crash report."""
-
-        sec_sep = '\n\n'+'*'*75+'\n\n'
-
-        report = []
-        rpt_add = report.append
-        
-        rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
-        rpt_add('IPython version: %s \n\n' % Release.version)
-        rpt_add('SVN revision   : %s \n\n' % Release.revision)
-        rpt_add('Platform info  : os.name -> %s, sys.platform -> %s' %
-                     (os.name,sys.platform) )
-        rpt_add(sec_sep+'Current user configuration structure:\n\n')
-        rpt_add(pformat(self.IP.rc.dict()))
-        rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
-        try:
-            rpt_add(sec_sep+"History of session input:")
-            for line in self.IP.user_ns['_ih']:
-                rpt_add(line)
-            rpt_add('\n*** Last line of input (may not be in above history):\n')
-            rpt_add(self.IP._last_input_line+'\n')
-        except:
-            pass
-
-        return ''.join(report)
+# -*- coding: utf-8 -*-
+"""sys.excepthook for IPython itself, leaves a detailed report on disk.
+
+$Id: CrashHandler.py 2908 2007-12-30 21:07:46Z vivainio $"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__   = '%s <%s>' % Release.authors['Fernando']
+__license__  = Release.license
+__version__  = Release.version
+
+#****************************************************************************
+# Required modules
+
+# From the standard library
+import os
+import sys
+from pprint import pprint,pformat
+
+# Homebrewed
+from IPython.Itpl import Itpl,itpl,printpl
+from IPython.ColorANSI import ColorScheme,ColorSchemeTable  # too long names
+from IPython import ultraTB
+from IPython.genutils import *
+
+#****************************************************************************
+class CrashHandler:
+    """Customizable crash handlers for IPython-based systems.
+
+    Instances of this class provide a __call__ method which can be used as a
+    sys.excepthook, i.e., the __call__ signature is:
+
+        def __call__(self,etype, evalue, etb)
+
+    """
+
+    def __init__(self,IP,app_name,contact_name,contact_email,
+                 bug_tracker,crash_report_fname,
+                 show_crash_traceback=True):
+        """New crash handler.
+
+        Inputs:
+
+        - IP: a running IPython instance, which will be queried at crash time
+        for internal information.
+
+        - app_name: a string containing the name of your application.
+
+        - contact_name: a string with the name of the person to contact.
+
+        - contact_email: a string with the email address of the contact.
+
+        - bug_tracker: a string with the URL for your project's bug tracker.
+
+        - crash_report_fname: a string with the filename for the crash report
+        to be saved in.  These reports are left in the ipython user directory
+        as determined by the running IPython instance.
+
+        Optional inputs:
+        
+        - show_crash_traceback(True): if false, don't print the crash
+        traceback on stderr, only generate the on-disk report
+
+
+        Non-argument instance attributes:
+
+        These instances contain some non-argument attributes which allow for 
+        further customization of the crash handler's behavior.  Please see the
+        source for further details.
+        """
+
+        # apply args into instance
+        self.IP = IP  # IPython instance
+        self.app_name = app_name
+        self.contact_name = contact_name
+        self.contact_email = contact_email
+        self.bug_tracker = bug_tracker
+        self.crash_report_fname = crash_report_fname
+        self.show_crash_traceback = show_crash_traceback
+        
+        # Hardcoded defaults, which can be overridden either by subclasses or
+        # at runtime for the instance.
+
+        # Template for the user message.  Subclasses which completely override
+        # this, or user apps, can modify it to suit their tastes.  It gets
+        # expanded using itpl, so calls of the kind $self.foo are valid.
+        self.user_message_template = """
+Oops, $self.app_name crashed. We do our best to make it stable, but...
+
+A crash report was automatically generated with the following information:
+  - A verbatim copy of the crash traceback.
+  - A copy of your input history during this session.
+  - Data on your current $self.app_name configuration.
+
+It was left in the file named:
+\t'$self.crash_report_fname'
+If you can email this file to the developers, the information in it will help
+them in understanding and correcting the problem.
+
+You can mail it to: $self.contact_name at $self.contact_email
+with the subject '$self.app_name Crash Report'.
+
+If you want to do it now, the following command will work (under Unix):
+mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
+
+To ensure accurate tracking of this issue, please file a report about it at:
+$self.bug_tracker
+"""
+
+    def __call__(self,etype, evalue, etb):
+        """Handle an exception, call for compatible with sys.excepthook"""
+
+        # Report tracebacks shouldn't use color in general (safer for users)
+        color_scheme = 'NoColor'
+
+        # Use this ONLY for developer debugging (keep commented out for release)
+        #color_scheme = 'Linux'   # dbg
+        
+        try:
+            rptdir = self.IP.rc.ipythondir
+        except:
+            rptdir = os.getcwd()
+        if not os.path.isdir(rptdir):
+            rptdir = os.getcwd()
+        report_name = os.path.join(rptdir,self.crash_report_fname)
+        # write the report filename into the instance dict so it can get
+        # properly expanded out in the user message template
+        self.crash_report_fname = report_name
+        TBhandler = ultraTB.VerboseTB(color_scheme=color_scheme,
+                                           long_header=1)
+        traceback = TBhandler.text(etype,evalue,etb,context=31)
+
+        # print traceback to screen
+        if self.show_crash_traceback:
+            print >> sys.stderr, traceback
+
+        # and generate a complete report on disk
+        try:
+            report = open(report_name,'w')
+        except:
+            print >> sys.stderr, 'Could not create crash report on disk.'
+            return
+
+        # Inform user on stderr of what happened
+        msg = itpl('\n'+'*'*70+'\n'+self.user_message_template)
+        print >> sys.stderr, msg
+
+        # Construct report on disk
+        report.write(self.make_report(traceback))
+        report.close()
+        raw_input("Press enter to exit:")
+
+    def make_report(self,traceback):
+        """Return a string containing a crash report."""
+
+        sec_sep = '\n\n'+'*'*75+'\n\n'
+
+        report = []
+        rpt_add = report.append
+        
+        rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
+        rpt_add('IPython version: %s \n\n' % Release.version)
+        rpt_add('SVN revision   : %s \n\n' % Release.revision)
+        rpt_add('Platform info  : os.name -> %s, sys.platform -> %s' %
+                     (os.name,sys.platform) )
+        rpt_add(sec_sep+'Current user configuration structure:\n\n')
+        rpt_add(pformat(self.IP.rc.dict()))
+        rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
+        try:
+            rpt_add(sec_sep+"History of session input:")
+            for line in self.IP.user_ns['_ih']:
+                rpt_add(line)
+            rpt_add('\n*** Last line of input (may not be in above history):\n')
+            rpt_add(self.IP._last_input_line+'\n')
+        except:
+            pass
+
+        return ''.join(report)
+
+class IPythonCrashHandler(CrashHandler):
+    """sys.excepthook for IPython itself, leaves a detailed report on disk."""
+    
+    def __init__(self,IP):
+
+        # Set here which of the IPython authors should be listed as contact
+        AUTHOR_CONTACT = 'Ville'
+        
+        # Set argument defaults
+        app_name = 'IPython'
+        bug_tracker = 'http://projects.scipy.org/ipython/ipython/report'
+        contact_name,contact_email = Release.authors[AUTHOR_CONTACT][:2]
+        crash_report_fname = 'IPython_crash_report.txt'
+        # Call parent constructor
+        CrashHandler.__init__(self,IP,app_name,contact_name,contact_email,
+                              bug_tracker,crash_report_fname)
+
+    def make_report(self,traceback):
+        """Return a string containing a crash report."""
+
+        sec_sep = '\n\n'+'*'*75+'\n\n'
+
+        report = []
+        rpt_add = report.append
+        
+        rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
+        rpt_add('IPython version: %s \n\n' % Release.version)
+        rpt_add('SVN revision   : %s \n\n' % Release.revision)
+        rpt_add('Platform info  : os.name -> %s, sys.platform -> %s' %
+                     (os.name,sys.platform) )
+        rpt_add(sec_sep+'Current user configuration structure:\n\n')
+        rpt_add(pformat(self.IP.rc.dict()))
+        rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
+        try:
+            rpt_add(sec_sep+"History of session input:")
+            for line in self.IP.user_ns['_ih']:
+                rpt_add(line)
+            rpt_add('\n*** Last line of input (may not be in above history):\n')
+            rpt_add(self.IP._last_input_line+'\n')
+        except:
+            pass
+
+        return ''.join(report)

IPython/DPyGetOpt.py

@@ -1,693 +1,693 b''
-# -*- coding: utf-8 -*-
-"""DPyGetOpt -- Demiurge Python GetOptions Module
-
- $Id: DPyGetOpt.py 2872 2007-11-25 17:58:05Z fperez $
-
-This module is modeled after perl's Getopt::Long module-- which
-is, in turn, modeled after GNU's extended getopt() function.
-
-Upon instantiation, the option specification should be a sequence
-(list) of option definitions.
-
-Options that take no arguments should simply contain the name of
-the option.  If a ! is post-pended, the option can be negated by
-prepending 'no';  ie 'debug!' specifies that -debug and -nodebug
-should be accepted.
-
-Mandatory arguments to options are specified using a postpended
-'=' + a type specifier.  '=s' specifies a mandatory string
-argument, '=i' specifies a mandatory integer argument, and '=f'
-specifies a mandatory real number.  In all cases, the '=' can be
-substituted with ':' to specify that the argument is optional.
-
-Dashes '-' in option names are allowed.
-
-If an option has the character '@' postpended (after the
-argumentation specification), it can appear multiple times within
-each argument list that is processed. The results will be stored
-in a list.
-
-The option name can actually be a list of names separated by '|'
-characters;  ie-- 'foo|bar|baz=f@' specifies that all -foo, -bar,
-and -baz options that appear on within the parsed argument list
-must have a real number argument and that the accumulated list
-of values will be available under the name 'foo'
-
-$Id: DPyGetOpt.py 2872 2007-11-25 17:58:05Z fperez $"""
-
-#*****************************************************************************
-#
-# Copyright (c) 2001 Bill Bumgarner <[e-mail]>
-#
-#
-# Published under the terms of the MIT license, hereby reproduced:
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-#*****************************************************************************
-
-__author__  = 'Bill Bumgarner <[e-mail]>'
-__license__ = 'MIT'
-__version__ = '1.2'
-
-# Modified to use re instead of regex and regsub modules.
-# 2001/5/7, Jonathan Hogg <[e-mail]>
-
-import re
-import string
-import sys
-import types
-
-class Error(Exception):
-    """Base class for exceptions in the DPyGetOpt module."""
-
-class ArgumentError(Error):
-    """Exception indicating an error in the arguments passed to
-    DPyGetOpt.processArguments."""
-
-class SpecificationError(Error):
-    """Exception indicating an error with an option specification."""
-
-class TerminationError(Error):
-    """Exception indicating an error with an option processing terminator."""
-
-specificationExpr = re.compile('(?P<required>.)(?P<type>.)(?P<multi>@?)')
-
-ArgRequired     = 'Requires an Argument'
-ArgOptional     = 'Argument Optional'
-
-# The types modules is not used for these identifiers because there
-# is no identifier for 'boolean' or 'generic'
-StringArgType   = 'String Argument Type'
-IntegerArgType  = 'Integer Argument Type'
-RealArgType             = 'Real Argument Type'
-BooleanArgType  = 'Boolean Argument Type'
-GenericArgType  = 'Generic Argument Type'
-
-# dictionary of conversion functions-- boolean and generic options
-# do not accept arguments and do not need conversion functions;
-# the identity function is used purely for convenience.
-ConversionFunctions = {
-        StringArgType : lambda x: x,
-        IntegerArgType : string.atoi,
-        RealArgType : string.atof,
-        BooleanArgType : lambda x: x,
-        GenericArgType : lambda x: x,
-        }
-
-class DPyGetOpt:
-
-    def __init__(self, spec = None, terminators = ['--']):
-        """
-        Declare and intialize instance variables
-
-        Yes, declaration is not necessary... but one of the things
-        I sorely miss from C/Obj-C is the concept of having an
-        interface definition that clearly declares all instance
-        variables and methods without providing any implementation
-         details.   it is a useful reference!
-
-        all instance variables are initialized to 0/Null/None of
-        the appropriate type-- not even the default value...
-        """
-
-#               sys.stderr.write(string.join(spec) + "\n")
-
-        self.allowAbbreviations = 1  # boolean, 1 if abbreviations will
-                                                                                  # be expanded
-        self.freeValues         = [] # list, contains free values
-        self.ignoreCase         = 0  # boolean, YES if ignoring case
-        self.needsParse         = 0  # boolean, YES if need to reparse parameter spec
-        self.optionNames        = {} # dict, all option names-- value is index of tuple
-        self.optionStartExpr    = None # regexp defining the start of an option (ie; '-', '--')
-        self.optionTuples       = [] # list o' tuples containing defn of options AND aliases
-        self.optionValues       = {} # dict, option names (after alias expansion) -> option value(s)
-        self.orderMixed         = 0  # boolean, YES if options can be mixed with args
-        self.posixCompliance    = 0  # boolean, YES indicates posix like behaviour
-        self.spec               = [] # list, raw specs (in case it must be reparsed)
-        self.terminators        = terminators # list, strings that terminate argument processing
-        self.termValues         = [] # list, values after terminator
-        self.terminator         = None # full name of terminator that ended
-                                               # option processing
-
-        # set up defaults
-        self.setPosixCompliance()
-        self.setIgnoreCase()
-        self.setAllowAbbreviations()
-
-        # parse spec-- if present
-        if spec:
-            self.parseConfiguration(spec)
-
-    def setPosixCompliance(self, aFlag = 0):
-        """
-        Enables and disables posix compliance.
-
-        When enabled, '+' can be used as an option prefix and free
-        values can be mixed with options.
-        """
-        self.posixCompliance = aFlag
-        self.needsParse = 1
-
-        if self.posixCompliance:
-            self.optionStartExpr = re.compile('(--|-)(?P<option>[A-Za-z0-9_-]+)(?P<arg>=.*)?')
-            self.orderMixed = 0
-        else:
-            self.optionStartExpr = re.compile('(--|-|\+)(?P<option>[A-Za-z0-9_-]+)(?P<arg>=.*)?')
-            self.orderMixed = 1
-
-    def isPosixCompliant(self):
-        """
-        Returns the value of the posix compliance flag.
-        """
-        return self.posixCompliance
-
-    def setIgnoreCase(self, aFlag = 1):
-        """
-        Enables and disables ignoring case during option processing.
-        """
-        self.needsParse = 1
-        self.ignoreCase = aFlag
-
-    def ignoreCase(self):
-        """
-        Returns 1 if the option processor will ignore case when
-        processing options.
-        """
-        return self.ignoreCase
-
-    def setAllowAbbreviations(self, aFlag = 1):
-        """
-        Enables and disables the expansion of abbreviations during
-        option processing.
-        """
-        self.allowAbbreviations = aFlag
-
-    def willAllowAbbreviations(self):
-        """
-        Returns 1 if abbreviated options will be automatically
-        expanded to the non-abbreviated form (instead of causing an
-        unrecognized option error).
-        """
-        return self.allowAbbreviations
-
-    def addTerminator(self, newTerm):
-        """
-        Adds newTerm as terminator of option processing.
-
-        Whenever the option processor encounters one of the terminators
-        during option processing, the processing of options terminates
-        immediately, all remaining options are stored in the termValues
-        instance variable and the full name of the terminator is stored
-        in the terminator instance variable.
-        """
-        self.terminators = self.terminators + [newTerm]
-
-    def _addOption(self, oTuple):
-        """
-        Adds the option described by oTuple (name, (type, mode,
-        default), alias) to optionTuples.  Adds index keyed under name
-        to optionNames.  Raises SpecificationError if name already in
-        optionNames
-        """
-        (name, (type, mode, default, multi), realName) = oTuple
-
-        # verify name and add to option names dictionary
-        if self.optionNames.has_key(name):
-            if realName:
-                raise SpecificationError('Alias \'' + name + '\' for \'' +
-                                         realName +
-                                         '\' already used for another option or alias.')
-            else:
-                raise SpecificationError('Option named \'' + name +
-                                         '\' specified more than once. Specification: '
-                                         + option)
-
-        # validated. add to optionNames
-        self.optionNames[name] = self.tupleIndex
-        self.tupleIndex = self.tupleIndex + 1
-
-        # add to optionTuples
-        self.optionTuples = self.optionTuples + [oTuple]
-
-        # if type is boolean, add negation
-        if type == BooleanArgType:
-            alias            = 'no' + name
-            specTuple = (type, mode, 0, multi)
-            oTuple = (alias, specTuple, name)
-
-            # verify name and add to option names dictionary
-            if self.optionNames.has_key(alias):
-                if realName:
-                    raise SpecificationError('Negated alias \'' + name +
-                                             '\' for \'' + realName +
-                                             '\' already used for another option or alias.')
-                else:
-                    raise SpecificationError('Negated option named \'' + name +
-                                             '\' specified more than once. Specification: '
-                                             + option)
-
-            # validated. add to optionNames
-            self.optionNames[alias] = self.tupleIndex
-            self.tupleIndex = self.tupleIndex + 1
-
-            # add to optionTuples
-            self.optionTuples = self.optionTuples + [oTuple]
-
-    def addOptionConfigurationTuple(self, oTuple):
-        (name, argSpec, realName) = oTuple
-        if self.ignoreCase:
-            name = string.lower(name)
-            if realName:
-                realName = string.lower(realName)
-            else:
-                realName = name
-
-            oTuple = (name, argSpec, realName)
-
-        # add option
-        self._addOption(oTuple)
-
-    def addOptionConfigurationTuples(self, oTuple):
-        if type(oTuple) is ListType:
-            for t in oTuple:
-                self.addOptionConfigurationTuple(t)
-        else:
-            self.addOptionConfigurationTuple(oTuple)
-
-    def parseConfiguration(self, spec):
-        # destroy previous stored information + store raw spec
-        self.spec                       = spec
-        self.optionTuples       = []
-        self.optionNames  = {}
-        self.tupleIndex   = 0
-
-        tupleIndex = 0
-
-        # create some regex's for parsing each spec
-        splitExpr = \
-                                 re.compile('(?P<names>\w+[-A-Za-z0-9|]*)?(?P<spec>!|[=:][infs]@?)?')
-        for option in spec:
- # push to lower case (does not negatively affect
- # specification)
-            if self.ignoreCase:
-                option = string.lower(option)
-
-            # break into names, specification
-            match = splitExpr.match(option)
-            if match is None:
-                raise SpecificationError('Invalid specification {' + option +
-                                         '}')
-
-            names                     = match.group('names')
-            specification = match.group('spec')
-
-            # break name into name, aliases
-            nlist = string.split(names, '|')
-
-            # get name
-            name      = nlist[0]
-            aliases = nlist[1:]
-
-            # specificationExpr = regex.symcomp('\(<required>.\)\(<type>.\)\(<multi>@?\)')
-            if not specification:
-                #spec tuple is ('type', 'arg mode', 'default value', 'multiple')
-                argType         = GenericArgType
-                argMode         = None
-                argDefault      = 1
-                argMultiple     = 0
-            elif specification == '!':
-                argType         = BooleanArgType
-                argMode         = None
-                argDefault      = 1
-                argMultiple     = 0
-            else:
-                # parse
-                match = specificationExpr.match(specification)
-                if match is None:
-                    # failed to parse, die
-                    raise SpecificationError('Invalid configuration for option \''
-                                             + option + '\'')
-
-                # determine mode
-                required = match.group('required')
-                if required == '=':
-                    argMode = ArgRequired
-                elif required == ':':
-                    argMode = ArgOptional
-                else:
-                    raise SpecificationError('Unknown requirement configuration \''
-                                             + required + '\'')
-
-                # determine type
-                type = match.group('type')
-                if type == 's':
-                    argType   = StringArgType
-                    argDefault = ''
-                elif type == 'i':
-                    argType   = IntegerArgType
-                    argDefault = 1
-                elif type == 'f' or type == 'n':
-                    argType   = RealArgType
-                    argDefault = 1
-                else:
-                    raise SpecificationError('Unknown type specifier \'' +
-                                             type + '\'')
-
-                # determine quantity
-                if match.group('multi') == '@':
-                    argMultiple = 1
-                else:
-                    argMultiple = 0
-            ## end else (of not specification)
-
-            # construct specification tuple
-            specTuple = (argType, argMode, argDefault, argMultiple)
-
-            # add the option-- option tuple is (name, specTuple, real name)
-            oTuple = (name, specTuple, name)
-            self._addOption(oTuple)
-
-            for alias in aliases:
-                # drop to all lower (if configured to do so)
-                if self.ignoreCase:
-                    alias = string.lower(alias)
-                # create configuration tuple
-                oTuple = (alias, specTuple, name)
-                # add
-                self._addOption(oTuple)
-
-        # successfully parsed....
-        self.needsParse = 0
-
-    def _getArgTuple(self, argName):
-        """
-        Returns a list containing all the specification tuples that
-        match argName.  If none match, None is returned.  If one
-        matches, a list with one tuple is returned.  If more than one
-        match, a list containing all the tuples that matched is
-        returned.
-
-        In other words, this function does not pass judgement upon the
-        validity of multiple matches.
-        """
-        # is it in the optionNames dict?
-
-        try:
-#                       sys.stderr.write(argName + string.join(self.optionNames.keys()) + "\n")
-
-            # yes, get index
-            tupleIndex = self.optionNames[argName]
-            # and return tuple as element of list
-            return [self.optionTuples[tupleIndex]]
-        except KeyError:
-            # are abbreviations allowed?
-            if not self.allowAbbreviations:
-                # No! terefore, this cannot be valid argument-- nothing found
-                return None
-
-        # argName might be an abbreviation (and, abbreviations must
-        # be allowed... or this would not have been reached!)
-
-        # create regex for argName
-        argExpr = re.compile('^' + argName)
-
-        tuples = filter(lambda x, argExpr=argExpr: argExpr.search(x[0]) is not None,
-                                                  self.optionTuples)
-
-        if not len(tuples):
-            return None
-        else:
-            return tuples
-
-    def _isTerminator(self, optionName):
-        """
-        Returns the full name of the terminator if optionName is a valid
-        terminator.  If it is, sets self.terminator to the full name of
-        the terminator.
-
-        If more than one terminator matched, raises a TerminationError with a
-        string describing the ambiguity.
-        """
-
-#               sys.stderr.write(optionName + "\n")
-#               sys.stderr.write(repr(self.terminators))
-
-        if optionName in self.terminators:
-            self.terminator = optionName
-        elif not self.allowAbbreviations:
-            return None
-
-# regex thing in bogus
-#               termExpr = regex.compile('^' + optionName)
-
-        terms = filter(lambda x, on=optionName: string.find(x,on) == 0, self.terminators)
-
-        if not len(terms):
-            return None
-        elif len(terms) > 1:
-            raise TerminationError('Ambiguous terminator \'' + optionName +
-                                   '\' matches ' + repr(terms))
-
-        self.terminator = terms[0]
-        return self.terminator
-
-    def processArguments(self, args = None):
-        """
-        Processes args, a list of arguments (including options).
-
-        If args is the same as sys.argv, automatically trims the first
-        argument (the executable name/path).
-
-        If an exception is not raised, the argument list was parsed
-        correctly.
-
-        Upon successful completion, the freeValues instance variable
-        will contain all the arguments that were not associated with an
-        option in the order they were encountered.  optionValues is a
-        dictionary containing the value of each option-- the method
-        valueForOption() can be used to query this dictionary.
-        terminator will contain the argument encountered that terminated
-        option processing (or None, if a terminator was never
-        encountered) and termValues will contain all of the options that
-        appeared after the Terminator (or an empty list).
-        """
-
-        if hasattr(sys, "argv") and args == sys.argv:
-            args = sys.argv[1:]
-
-        max             = len(args) # maximum index + 1
-        self.freeValues = []        # array to hold return values
-        self.optionValues= {}
-        index           = 0         # initial index
-        self.terminator = None
-        self.termValues  = []
-
-        while index < max:
-            # obtain argument
-            arg = args[index]
-            # increment index -- REMEMBER; it is NOW incremented
-            index = index + 1
-
-            # terminate immediately if option terminator encountered
-            if self._isTerminator(arg):
-                self.freeValues = self.freeValues + args[index:]
-                self.termValues = args[index:]
-                return
-
-            # is this possibly an option?
-            match = self.optionStartExpr.match(arg)
-            if match is None:
-                # not an option-- add to freeValues
-                self.freeValues = self.freeValues + [arg]
-                if not self.orderMixed:
-                    # mixing not allowed;  add rest of args as freeValues
-                    self.freeValues = self.freeValues + args[index:]
-                    # return to caller
-                    return
-                else:
-                    continue
-
-            # grab name
-            optName = match.group('option')
-
-            # obtain next argument-- index has already been incremented
-            nextArg = match.group('arg')
-            if nextArg:
-                nextArg = nextArg[1:]
-                index = index - 1 # put it back
-            else:
-                try:
-                    nextArg = args[index]
-                except:
-                    nextArg = None
-
-            # transpose to lower case, if necessary
-            if self.ignoreCase:
-                optName = string.lower(optName)
-
-            # obtain defining tuple
-            tuples = self._getArgTuple(optName)
-
-            if tuples == None:
-                raise ArgumentError('Illegal option \'' + arg + '\'')
-            elif len(tuples) > 1:
-                raise ArgumentError('Ambiguous option \'' + arg +
-                                    '\';  matches ' +
-                                    repr(map(lambda x: x[0], tuples)))
-            else:
-                config = tuples[0]
-
-            # config is now set to the configuration tuple for the
-            # argument
-            (fullName, spec, realName) = config
-            (optType, optMode, optDefault, optMultiple) = spec
-
-            # if opt mode required, but nextArg is none, raise an error
-            if (optMode == ArgRequired):
-                if (not nextArg) or self._isTerminator(nextArg):
-#                                       print nextArg
-                    raise ArgumentError('Option \'' + arg +
-                                        '\' requires an argument of type ' +
-                                        optType)
-
-            if (not optMode == None) and nextArg and (not self._isTerminator(nextArg)):
-                # nextArg defined, option configured to possibly consume arg
-                try:
-                    # grab conversion function-- the try is more for internal diagnostics
-                    func = ConversionFunctions[optType]
-                    try:
-                        optionValue = func(nextArg)
-                        index = index + 1
-                    except:
-                        # only raise conversion error if REQUIRED to consume argument
-                        if optMode == ArgRequired:
-                            raise ArgumentError('Invalid argument to option \''
-                                                + arg + '\';  should be \'' +
-                                                optType + '\'')
-                        else:
-                            optionValue = optDefault
-                except ArgumentError:
-                    raise
-                except:
-                    raise ArgumentError('(' + arg +
-                                        ') Conversion function for \'' +
-                                        optType + '\' not found.')
-            else:
-                optionValue = optDefault
-
-            # add value to options dictionary
-            if optMultiple:
-                # can be multiple values
-                try:
-                    # try to append element
-                    self.optionValues[realName] = self.optionValues[realName] + [optionValue]
-                except:
-                    # failed-- must not exist;  add it
-                    self.optionValues[realName] = [optionValue]
-            else:
-                # only one value per
-                if self.isPosixCompliant and self.optionValues.has_key(realName):
-                    raise ArgumentError('Argument \'' + arg +
-                                        '\' occurs multiple times.')
-
-                self.optionValues[realName] = optionValue
-
-    def valueForOption(self, optionName, defaultValue = None):
-        """
-        Return the value associated with optionName.  If optionName was
-        not encountered during parsing of the arguments, returns the
-        defaultValue (which defaults to None).
-        """
-        try:
-            optionValue = self.optionValues[optionName]
-        except:
-            optionValue = defaultValue
-
-        return optionValue
-
-##
-## test/example section
-##
-test_error = 'Test Run Amok!'
-def _test():
-    """
-    A relatively complete test suite.
-    """
-    try:
-        DPyGetOpt(['foo', 'bar=s', 'foo'])
-    except Error, exc:
-        print 'EXCEPTION (should be \'foo\' already used..): %s' % exc
-
-    try:
-        DPyGetOpt(['foo|bar|apple=s@', 'baz|apple!'])
-    except Error, exc:
-        print 'EXCEPTION (should be duplicate alias/name error): %s' % exc
-
-    x = DPyGetOpt(['apple|atlas=i@', 'application|executable=f@'])
-    try:
-        x.processArguments(['-app', '29.3'])
-    except Error, exc:
-        print 'EXCEPTION (should be ambiguous argument): %s' % exc
-
-    x = DPyGetOpt(['foo'], ['antigravity', 'antithesis'])
-    try:
-        x.processArguments(['-foo', 'anti'])
-    except Error, exc:
-        print 'EXCEPTION (should be ambiguous terminator): %s' % exc
-
-    profile = ['plain-option',
-                              'boolean-option!',
-                              'list-of-integers=i@',
-                              'list-real-option|list-real-alias|list-real-pseudonym=f@',
-                              'optional-string-option:s',
-                              'abbreviated-string-list=s@']
-
-    terminators = ['terminator']
-
-    args = ['-plain-option',
-                      '+noboolean-option',
-                      '--list-of-integers', '1',
-                      '+list-of-integers', '2',
-                      '-list-of-integers', '3',
-                      'freeargone',
-                      '-list-real-option', '1.1',
-                      '+list-real-alias', '1.2',
-                      '--list-real-pseudonym', '1.3',
-                      'freeargtwo',
-                      '-abbreviated-string-list', 'String1',
-                      '--abbreviated-s', 'String2',
-                      '-abbrev', 'String3',
-                      '-a', 'String4',
-                      '-optional-string-option',
-                      'term',
-                      'next option should look like an invalid arg',
-                      '-a']
-
-
-    print 'Using profile: ' + repr(profile)
-    print 'With terminator: ' + repr(terminators)
-    print 'Processing arguments: ' + repr(args)
-
-    go = DPyGetOpt(profile, terminators)
-    go.processArguments(args)
-
-    print 'Options (and values): ' + repr(go.optionValues)
-    print 'free args: ' + repr(go.freeValues)
-    print 'term args: ' + repr(go.termValues)
+# -*- coding: utf-8 -*-
+"""DPyGetOpt -- Demiurge Python GetOptions Module
+
+ $Id: DPyGetOpt.py 2872 2007-11-25 17:58:05Z fperez $
+
+This module is modeled after perl's Getopt::Long module-- which
+is, in turn, modeled after GNU's extended getopt() function.
+
+Upon instantiation, the option specification should be a sequence
+(list) of option definitions.
+
+Options that take no arguments should simply contain the name of
+the option.  If a ! is post-pended, the option can be negated by
+prepending 'no';  ie 'debug!' specifies that -debug and -nodebug
+should be accepted.
+
+Mandatory arguments to options are specified using a postpended
+'=' + a type specifier.  '=s' specifies a mandatory string
+argument, '=i' specifies a mandatory integer argument, and '=f'
+specifies a mandatory real number.  In all cases, the '=' can be
+substituted with ':' to specify that the argument is optional.
+
+Dashes '-' in option names are allowed.
+
+If an option has the character '@' postpended (after the
+argumentation specification), it can appear multiple times within
+each argument list that is processed. The results will be stored
+in a list.
+
+The option name can actually be a list of names separated by '|'
+characters;  ie-- 'foo|bar|baz=f@' specifies that all -foo, -bar,
+and -baz options that appear on within the parsed argument list
+must have a real number argument and that the accumulated list
+of values will be available under the name 'foo'
+
+$Id: DPyGetOpt.py 2872 2007-11-25 17:58:05Z fperez $"""
+
+#*****************************************************************************
+#
+# Copyright (c) 2001 Bill Bumgarner <[e-mail]>
+#
+#
+# Published under the terms of the MIT license, hereby reproduced:
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+#*****************************************************************************
+
+__author__  = 'Bill Bumgarner <[e-mail]>'
+__license__ = 'MIT'
+__version__ = '1.2'
+
+# Modified to use re instead of regex and regsub modules.
+# 2001/5/7, Jonathan Hogg <[e-mail]>
+
+import re
+import string
+import sys
+import types
+
+class Error(Exception):
+    """Base class for exceptions in the DPyGetOpt module."""
+
+class ArgumentError(Error):
+    """Exception indicating an error in the arguments passed to
+    DPyGetOpt.processArguments."""
+
+class SpecificationError(Error):
+    """Exception indicating an error with an option specification."""
+
+class TerminationError(Error):
+    """Exception indicating an error with an option processing terminator."""
+
+specificationExpr = re.compile('(?P<required>.)(?P<type>.)(?P<multi>@?)')
+
+ArgRequired     = 'Requires an Argument'
+ArgOptional     = 'Argument Optional'
+
+# The types modules is not used for these identifiers because there
+# is no identifier for 'boolean' or 'generic'
+StringArgType   = 'String Argument Type'
+IntegerArgType  = 'Integer Argument Type'
+RealArgType             = 'Real Argument Type'
+BooleanArgType  = 'Boolean Argument Type'
+GenericArgType  = 'Generic Argument Type'
+
+# dictionary of conversion functions-- boolean and generic options
+# do not accept arguments and do not need conversion functions;
+# the identity function is used purely for convenience.
+ConversionFunctions = {
+        StringArgType : lambda x: x,
+        IntegerArgType : string.atoi,
+        RealArgType : string.atof,
+        BooleanArgType : lambda x: x,
+        GenericArgType : lambda x: x,
+        }
+
+class DPyGetOpt:
+
+    def __init__(self, spec = None, terminators = ['--']):
+        """
+        Declare and intialize instance variables
+
+        Yes, declaration is not necessary... but one of the things
+        I sorely miss from C/Obj-C is the concept of having an
+        interface definition that clearly declares all instance
+        variables and methods without providing any implementation
+         details.   it is a useful reference!
+
+        all instance variables are initialized to 0/Null/None of
+        the appropriate type-- not even the default value...
+        """
+
+#               sys.stderr.write(string.join(spec) + "\n")
+
+        self.allowAbbreviations = 1  # boolean, 1 if abbreviations will
+                                                                                  # be expanded
+        self.freeValues         = [] # list, contains free values
+        self.ignoreCase         = 0  # boolean, YES if ignoring case
+        self.needsParse         = 0  # boolean, YES if need to reparse parameter spec
+        self.optionNames        = {} # dict, all option names-- value is index of tuple
+        self.optionStartExpr    = None # regexp defining the start of an option (ie; '-', '--')
+        self.optionTuples       = [] # list o' tuples containing defn of options AND aliases
+        self.optionValues       = {} # dict, option names (after alias expansion) -> option value(s)
+        self.orderMixed         = 0  # boolean, YES if options can be mixed with args
+        self.posixCompliance    = 0  # boolean, YES indicates posix like behaviour
+        self.spec               = [] # list, raw specs (in case it must be reparsed)
+        self.terminators        = terminators # list, strings that terminate argument processing
+        self.termValues         = [] # list, values after terminator
+        self.terminator         = None # full name of terminator that ended
+                                               # option processing
+
+        # set up defaults
+        self.setPosixCompliance()
+        self.setIgnoreCase()
+        self.setAllowAbbreviations()
+
+        # parse spec-- if present
+        if spec:
+            self.parseConfiguration(spec)
+
+    def setPosixCompliance(self, aFlag = 0):
+        """
+        Enables and disables posix compliance.
+
+        When enabled, '+' can be used as an option prefix and free
+        values can be mixed with options.
+        """
+        self.posixCompliance = aFlag
+        self.needsParse = 1
+
+        if self.posixCompliance:
+            self.optionStartExpr = re.compile('(--|-)(?P<option>[A-Za-z0-9_-]+)(?P<arg>=.*)?')
+            self.orderMixed = 0
+        else:
+            self.optionStartExpr = re.compile('(--|-|\+)(?P<option>[A-Za-z0-9_-]+)(?P<arg>=.*)?')
+            self.orderMixed = 1
+
+    def isPosixCompliant(self):
+        """
+        Returns the value of the posix compliance flag.
+        """
+        return self.posixCompliance
+
+    def setIgnoreCase(self, aFlag = 1):
+        """
+        Enables and disables ignoring case during option processing.
+        """
+        self.needsParse = 1
+        self.ignoreCase = aFlag
+
+    def ignoreCase(self):
+        """
+        Returns 1 if the option processor will ignore case when
+        processing options.
+        """
+        return self.ignoreCase
+
+    def setAllowAbbreviations(self, aFlag = 1):
+        """
+        Enables and disables the expansion of abbreviations during
+        option processing.
+        """
+        self.allowAbbreviations = aFlag
+
+    def willAllowAbbreviations(self):
+        """
+        Returns 1 if abbreviated options will be automatically
+        expanded to the non-abbreviated form (instead of causing an
+        unrecognized option error).
+        """
+        return self.allowAbbreviations
+
+    def addTerminator(self, newTerm):
+        """
+        Adds newTerm as terminator of option processing.
+
+        Whenever the option processor encounters one of the terminators
+        during option processing, the processing of options terminates
+        immediately, all remaining options are stored in the termValues
+        instance variable and the full name of the terminator is stored
+        in the terminator instance variable.
+        """
+        self.terminators = self.terminators + [newTerm]
+
+    def _addOption(self, oTuple):
+        """
+        Adds the option described by oTuple (name, (type, mode,
+        default), alias) to optionTuples.  Adds index keyed under name
+        to optionNames.  Raises SpecificationError if name already in
+        optionNames
+        """
+        (name, (type, mode, default, multi), realName) = oTuple
+
+        # verify name and add to option names dictionary
+        if self.optionNames.has_key(name):
+            if realName:
+                raise SpecificationError('Alias \'' + name + '\' for \'' +
+                                         realName +
+                                         '\' already used for another option or alias.')
+            else:
+                raise SpecificationError('Option named \'' + name +
+                                         '\' specified more than once. Specification: '
+                                         + option)
+
+        # validated. add to optionNames
+        self.optionNames[name] = self.tupleIndex
+        self.tupleIndex = self.tupleIndex + 1
+
+        # add to optionTuples
+        self.optionTuples = self.optionTuples + [oTuple]
+
+        # if type is boolean, add negation
+        if type == BooleanArgType:
+            alias            = 'no' + name
+            specTuple = (type, mode, 0, multi)
+            oTuple = (alias, specTuple, name)
+
+            # verify name and add to option names dictionary
+            if self.optionNames.has_key(alias):
+                if realName:
+                    raise SpecificationError('Negated alias \'' + name +
+                                             '\' for \'' + realName +
+                                             '\' already used for another option or alias.')
+                else:
+                    raise SpecificationError('Negated option named \'' + name +
+                                             '\' specified more than once. Specification: '
+                                             + option)
+
+            # validated. add to optionNames
+            self.optionNames[alias] = self.tupleIndex
+            self.tupleIndex = self.tupleIndex + 1
+
+            # add to optionTuples
+            self.optionTuples = self.optionTuples + [oTuple]
+
+    def addOptionConfigurationTuple(self, oTuple):
+        (name, argSpec, realName) = oTuple
+        if self.ignoreCase:
+            name = string.lower(name)
+            if realName:
+                realName = string.lower(realName)
+            else:
+                realName = name
+
+            oTuple = (name, argSpec, realName)
+
+        # add option
+        self._addOption(oTuple)
+
+    def addOptionConfigurationTuples(self, oTuple):
+        if type(oTuple) is ListType:
+            for t in oTuple:
+                self.addOptionConfigurationTuple(t)
+        else:
+            self.addOptionConfigurationTuple(oTuple)
+
+    def parseConfiguration(self, spec):
+        # destroy previous stored information + store raw spec
+        self.spec                       = spec
+        self.optionTuples       = []
+        self.optionNames  = {}
+        self.tupleIndex   = 0
+
+        tupleIndex = 0
+
+        # create some regex's for parsing each spec
+        splitExpr = \
+                                 re.compile('(?P<names>\w+[-A-Za-z0-9|]*)?(?P<spec>!|[=:][infs]@?)?')
+        for option in spec:
+ # push to lower case (does not negatively affect
+ # specification)
+            if self.ignoreCase:
+                option = string.lower(option)
+
+            # break into names, specification
+            match = splitExpr.match(option)
+            if match is None:
+                raise SpecificationError('Invalid specification {' + option +
+                                         '}')
+
+            names                     = match.group('names')
+            specification = match.group('spec')
+
+            # break name into name, aliases
+            nlist = string.split(names, '|')
+
+            # get name
+            name      = nlist[0]
+            aliases = nlist[1:]
+
+            # specificationExpr = regex.symcomp('\(<required>.\)\(<type>.\)\(<multi>@?\)')
+            if not specification:
+                #spec tuple is ('type', 'arg mode', 'default value', 'multiple')
+                argType         = GenericArgType
+                argMode         = None
+                argDefault      = 1
+                argMultiple     = 0
+            elif specification == '!':
+                argType         = BooleanArgType
+                argMode         = None
+                argDefault      = 1
+                argMultiple     = 0
+            else:
+                # parse
+                match = specificationExpr.match(specification)
+                if match is None:
+                    # failed to parse, die
+                    raise SpecificationError('Invalid configuration for option \''
+                                             + option + '\'')
+
+                # determine mode
+                required = match.group('required')
+                if required == '=':
+                    argMode = ArgRequired
+                elif required == ':':
+                    argMode = ArgOptional
+                else:
+                    raise SpecificationError('Unknown requirement configuration \''
+                                             + required + '\'')
+
+                # determine type
+                type = match.group('type')
+                if type == 's':
+                    argType   = StringArgType
+                    argDefault = ''
+                elif type == 'i':
+                    argType   = IntegerArgType
+                    argDefault = 1
+                elif type == 'f' or type == 'n':
+                    argType   = RealArgType
+                    argDefault = 1
+                else:
+                    raise SpecificationError('Unknown type specifier \'' +
+                                             type + '\'')
+
+                # determine quantity
+                if match.group('multi') == '@':
+                    argMultiple = 1
+                else:
+                    argMultiple = 0
+            ## end else (of not specification)
+
+            # construct specification tuple
+            specTuple = (argType, argMode, argDefault, argMultiple)
+
+            # add the option-- option tuple is (name, specTuple, real name)
+            oTuple = (name, specTuple, name)
+            self._addOption(oTuple)
+
+            for alias in aliases:
+                # drop to all lower (if configured to do so)
+                if self.ignoreCase:
+                    alias = string.lower(alias)
+                # create configuration tuple
+                oTuple = (alias, specTuple, name)
+                # add
+                self._addOption(oTuple)
+
+        # successfully parsed....
+        self.needsParse = 0
+
+    def _getArgTuple(self, argName):
+        """
+        Returns a list containing all the specification tuples that
+        match argName.  If none match, None is returned.  If one
+        matches, a list with one tuple is returned.  If more than one
+        match, a list containing all the tuples that matched is
+        returned.
+
+        In other words, this function does not pass judgement upon the
+        validity of multiple matches.
+        """
+        # is it in the optionNames dict?
+
+        try:
+#                       sys.stderr.write(argName + string.join(self.optionNames.keys()) + "\n")
+
+            # yes, get index
+            tupleIndex = self.optionNames[argName]
+            # and return tuple as element of list
+            return [self.optionTuples[tupleIndex]]
+        except KeyError:
+            # are abbreviations allowed?
+            if not self.allowAbbreviations:
+                # No! terefore, this cannot be valid argument-- nothing found
+                return None
+
+        # argName might be an abbreviation (and, abbreviations must
+        # be allowed... or this would not have been reached!)
+
+        # create regex for argName
+        argExpr = re.compile('^' + argName)
+
+        tuples = filter(lambda x, argExpr=argExpr: argExpr.search(x[0]) is not None,
+                                                  self.optionTuples)
+
+        if not len(tuples):
+            return None
+        else:
+            return tuples
+
+    def _isTerminator(self, optionName):
+        """
+        Returns the full name of the terminator if optionName is a valid
+        terminator.  If it is, sets self.terminator to the full name of
+        the terminator.
+
+        If more than one terminator matched, raises a TerminationError with a
+        string describing the ambiguity.
+        """
+
+#               sys.stderr.write(optionName + "\n")
+#               sys.stderr.write(repr(self.terminators))
+
+        if optionName in self.terminators:
+            self.terminator = optionName
+        elif not self.allowAbbreviations:
+            return None
+
+# regex thing in bogus
+#               termExpr = regex.compile('^' + optionName)
+
+        terms = filter(lambda x, on=optionName: string.find(x,on) == 0, self.terminators)
+
+        if not len(terms):
+            return None
+        elif len(terms) > 1:
+            raise TerminationError('Ambiguous terminator \'' + optionName +
+                                   '\' matches ' + repr(terms))
+
+        self.terminator = terms[0]
+        return self.terminator
+
+    def processArguments(self, args = None):
+        """
+        Processes args, a list of arguments (including options).
+
+        If args is the same as sys.argv, automatically trims the first
+        argument (the executable name/path).
+
+        If an exception is not raised, the argument list was parsed
+        correctly.
+
+        Upon successful completion, the freeValues instance variable
+        will contain all the arguments that were not associated with an
+        option in the order they were encountered.  optionValues is a
+        dictionary containing the value of each option-- the method
+        valueForOption() can be used to query this dictionary.
+        terminator will contain the argument encountered that terminated
+        option processing (or None, if a terminator was never
+        encountered) and termValues will contain all of the options that
+        appeared after the Terminator (or an empty list).
+        """
+
+        if hasattr(sys, "argv") and args == sys.argv:
+            args = sys.argv[1:]
+
+        max             = len(args) # maximum index + 1
+        self.freeValues = []        # array to hold return values
+        self.optionValues= {}
+        index           = 0         # initial index
+        self.terminator = None
+        self.termValues  = []
+
+        while index < max:
+            # obtain argument
+            arg = args[index]
+            # increment index -- REMEMBER; it is NOW incremented
+            index = index + 1
+
+            # terminate immediately if option terminator encountered
+            if self._isTerminator(arg):
+                self.freeValues = self.freeValues + args[index:]
+                self.termValues = args[index:]
+                return
+
+            # is this possibly an option?
+            match = self.optionStartExpr.match(arg)
+            if match is None:
+                # not an option-- add to freeValues
+                self.freeValues = self.freeValues + [arg]
+                if not self.orderMixed:
+                    # mixing not allowed;  add rest of args as freeValues
+                    self.freeValues = self.freeValues + args[index:]
+                    # return to caller
+                    return
+                else:
+                    continue
+
+            # grab name
+            optName = match.group('option')
+
+            # obtain next argument-- index has already been incremented
+            nextArg = match.group('arg')
+            if nextArg:
+                nextArg = nextArg[1:]
+                index = index - 1 # put it back
+            else:
+                try:
+                    nextArg = args[index]
+                except:
+                    nextArg = None
+
+            # transpose to lower case, if necessary
+            if self.ignoreCase:
+                optName = string.lower(optName)
+
+            # obtain defining tuple
+            tuples = self._getArgTuple(optName)
+
+            if tuples == None:
+                raise ArgumentError('Illegal option \'' + arg + '\'')
+            elif len(tuples) > 1:
+                raise ArgumentError('Ambiguous option \'' + arg +
+                                    '\';  matches ' +
+                                    repr(map(lambda x: x[0], tuples)))
+            else:
+                config = tuples[0]
+
+            # config is now set to the configuration tuple for the
+            # argument
+            (fullName, spec, realName) = config
+            (optType, optMode, optDefault, optMultiple) = spec
+
+            # if opt mode required, but nextArg is none, raise an error
+            if (optMode == ArgRequired):
+                if (not nextArg) or self._isTerminator(nextArg):
+#                                       print nextArg
+                    raise ArgumentError('Option \'' + arg +
+                                        '\' requires an argument of type ' +
+                                        optType)
+
+            if (not optMode == None) and nextArg and (not self._isTerminator(nextArg)):
+                # nextArg defined, option configured to possibly consume arg
+                try:
+                    # grab conversion function-- the try is more for internal diagnostics
+                    func = ConversionFunctions[optType]
+                    try:
+                        optionValue = func(nextArg)
+                        index = index + 1
+                    except:
+                        # only raise conversion error if REQUIRED to consume argument
+                        if optMode == ArgRequired:
+                            raise ArgumentError('Invalid argument to option \''
+                                                + arg + '\';  should be \'' +
+                                                optType + '\'')
+                        else:
+                            optionValue = optDefault
+                except ArgumentError:
+                    raise
+                except:
+                    raise ArgumentError('(' + arg +
+                                        ') Conversion function for \'' +
+                                        optType + '\' not found.')
+            else:
+                optionValue = optDefault
+
+            # add value to options dictionary
+            if optMultiple:
+                # can be multiple values
+                try:
+                    # try to append element
+                    self.optionValues[realName] = self.optionValues[realName] + [optionValue]
+                except:
+                    # failed-- must not exist;  add it
+                    self.optionValues[realName] = [optionValue]
+            else:
+                # only one value per
+                if self.isPosixCompliant and self.optionValues.has_key(realName):
+                    raise ArgumentError('Argument \'' + arg +
+                                        '\' occurs multiple times.')
+
+                self.optionValues[realName] = optionValue
+
+    def valueForOption(self, optionName, defaultValue = None):
+        """
+        Return the value associated with optionName.  If optionName was
+        not encountered during parsing of the arguments, returns the
+        defaultValue (which defaults to None).
+        """
+        try:
+            optionValue = self.optionValues[optionName]
+        except:
+            optionValue = defaultValue
+
+        return optionValue
+
+##
+## test/example section
+##
+test_error = 'Test Run Amok!'
+def _test():
+    """
+    A relatively complete test suite.
+    """
+    try:
+        DPyGetOpt(['foo', 'bar=s', 'foo'])
+    except Error, exc:
+        print 'EXCEPTION (should be \'foo\' already used..): %s' % exc
+
+    try:
+        DPyGetOpt(['foo|bar|apple=s@', 'baz|apple!'])
+    except Error, exc:
+        print 'EXCEPTION (should be duplicate alias/name error): %s' % exc
+
+    x = DPyGetOpt(['apple|atlas=i@', 'application|executable=f@'])
+    try:
+        x.processArguments(['-app', '29.3'])
+    except Error, exc:
+        print 'EXCEPTION (should be ambiguous argument): %s' % exc
+
+    x = DPyGetOpt(['foo'], ['antigravity', 'antithesis'])
+    try:
+        x.processArguments(['-foo', 'anti'])
+    except Error, exc:
+        print 'EXCEPTION (should be ambiguous terminator): %s' % exc
+
+    profile = ['plain-option',
+                              'boolean-option!',
+                              'list-of-integers=i@',
+                              'list-real-option|list-real-alias|list-real-pseudonym=f@',
+                              'optional-string-option:s',
+                              'abbreviated-string-list=s@']
+
+    terminators = ['terminator']
+
+    args = ['-plain-option',
+                      '+noboolean-option',
+                      '--list-of-integers', '1',
+                      '+list-of-integers', '2',
+                      '-list-of-integers', '3',
+                      'freeargone',
+                      '-list-real-option', '1.1',
+                      '+list-real-alias', '1.2',
+                      '--list-real-pseudonym', '1.3',
+                      'freeargtwo',
+                      '-abbreviated-string-list', 'String1',
+                      '--abbreviated-s', 'String2',
+                      '-abbrev', 'String3',
+                      '-a', 'String4',
+                      '-optional-string-option',
+                      'term',
+                      'next option should look like an invalid arg',
+                      '-a']
+
+
+    print 'Using profile: ' + repr(profile)
+    print 'With terminator: ' + repr(terminators)
+    print 'Processing arguments: ' + repr(args)
+
+    go = DPyGetOpt(profile, terminators)
+    go.processArguments(args)
+
+    print 'Options (and values): ' + repr(go.optionValues)
+    print 'free args: ' + repr(go.freeValues)
+    print 'term args: ' + repr(go.termValues)

IPython/Debugger.py

@@ -1,517 +1,517 b''
-# -*- coding: utf-8 -*-
-"""
-Pdb debugger class.
-
-Modified from the standard pdb.Pdb class to avoid including readline, so that
-the command line completion of other programs which include this isn't
-damaged.
-
-In the future, this class will be expanded with improvements over the standard
-pdb.
-
-The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor
-changes. Licensing should therefore be under the standard Python terms.  For
-details on the PSF (Python Software Foundation) standard license, see:
-
-http://www.python.org/2.2.3/license.html
-
-$Id: Debugger.py 2913 2007-12-31 12:42:14Z vivainio $"""
-
-#*****************************************************************************
-#
-#       This file is licensed under the PSF license.
-#
-#       Copyright (C) 2001 Python Software Foundation, www.python.org
-#       Copyright (C) 2005-2006 Fernando Perez. <[e-mail]>
-#
-#
-#*****************************************************************************
-
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = 'Python'
-
-import bdb
-import cmd
-import linecache
-import os
-import sys
-
-from IPython import PyColorize, ColorANSI, ipapi
-from IPython.genutils import Term
-from IPython.excolors import ExceptionColors
-
-# See if we can use pydb.
-has_pydb = False
-prompt = 'ipdb> '
-#We have to check this directly from sys.argv, config struct not yet available
-if '-pydb' in sys.argv:
-    try:        
-        import pydb
-        if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':
-            # Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we
-            # better protect against it.
-            has_pydb = True
-    except ImportError:
-        print "Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available"
-
-if has_pydb:
-    from pydb import Pdb as OldPdb
-    #print "Using pydb for %run -d and post-mortem" #dbg
-    prompt = 'ipydb> '
-else:
-    from pdb import Pdb as OldPdb
-
-# Allow the set_trace code to operate outside of an ipython instance, even if
-# it does so with some limitations.  The rest of this support is implemented in
-# the Tracer constructor.
-def BdbQuit_excepthook(et,ev,tb):
-    if et==bdb.BdbQuit:
-        print 'Exiting Debugger.'
-    else:
-        BdbQuit_excepthook.excepthook_ori(et,ev,tb)
-
-def BdbQuit_IPython_excepthook(self,et,ev,tb):
-    print 'Exiting Debugger.'
-
-class Tracer(object):
-    """Class for local debugging, similar to pdb.set_trace.
-
-    Instances of this class, when called, behave like pdb.set_trace, but
-    providing IPython's enhanced capabilities.
-
-    This is implemented as a class which must be initialized in your own code
-    and not as a standalone function because we need to detect at runtime
-    whether IPython is already active or not.  That detection is done in the
-    constructor, ensuring that this code plays nicely with a running IPython,
-    while functioning acceptably (though with limitations) if outside of it.
-    """
-
-    def __init__(self,colors=None):
-        """Create a local debugger instance.
-
-        :Parameters:
-
-          - `colors` (None): a string containing the name of the color scheme to
-        use, it must be one of IPython's valid color schemes.  If not given, the
-        function will default to the current IPython scheme when running inside
-        IPython, and to 'NoColor' otherwise.
-
-        Usage example:
-
-        from IPython.Debugger import Tracer; debug_here = Tracer()
-
-        ... later in your code
-        debug_here()  # -> will open up the debugger at that point.
-
-        Once the debugger activates, you can use all of its regular commands to
-        step through code, set breakpoints, etc.  See the pdb documentation
-        from the Python standard library for usage details.
-        """
-
-        global __IPYTHON__
-        try:
-            __IPYTHON__
-        except NameError:
-            # Outside of ipython, we set our own exception hook manually
-            __IPYTHON__ = ipapi.get(True,False)
-            BdbQuit_excepthook.excepthook_ori = sys.excepthook
-            sys.excepthook = BdbQuit_excepthook
-            def_colors = 'NoColor'
-            try:
-                # Limited tab completion support
-                import rlcompleter,readline
-                readline.parse_and_bind('tab: complete')
-            except ImportError:
-                pass
-        else:
-            # In ipython, we use its custom exception handler mechanism
-            ip = ipapi.get()
-            def_colors = ip.options.colors
-            ip.set_custom_exc((bdb.BdbQuit,),BdbQuit_IPython_excepthook)
-
-        if colors is None:
-            colors = def_colors
-        self.debugger = Pdb(colors)
-
-    def __call__(self):
-        """Starts an interactive debugger at the point where called.
-
-        This is similar to the pdb.set_trace() function from the std lib, but
-        using IPython's enhanced debugger."""
-        
-        self.debugger.set_trace(sys._getframe().f_back)
-
-def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
-    """Make new_fn have old_fn's doc string. This is particularly useful
-    for the do_... commands that hook into the help system.
-    Adapted from from a comp.lang.python posting
-    by Duncan Booth."""
-    def wrapper(*args, **kw):
-        return new_fn(*args, **kw)
-    if old_fn.__doc__:
-        wrapper.__doc__ = old_fn.__doc__ + additional_text
-    return wrapper
-
-def _file_lines(fname):
-    """Return the contents of a named file as a list of lines.
-
-    This function never raises an IOError exception: if the file can't be
-    read, it simply returns an empty list."""
-
-    try:
-        outfile = open(fname)
-    except IOError:
-        return []
-    else:
-        out = outfile.readlines()
-        outfile.close()
-        return out
-
-class Pdb(OldPdb):
-    """Modified Pdb class, does not load readline."""
-
-    if sys.version[:3] >= '2.5' or has_pydb:
-        def __init__(self,color_scheme='NoColor',completekey=None,
-                     stdin=None, stdout=None):
-
-            # Parent constructor:
-            if has_pydb and completekey is None:
-                OldPdb.__init__(self,stdin=stdin,stdout=Term.cout)
-            else:
-                OldPdb.__init__(self,completekey,stdin,stdout)
-                
-            self.prompt = prompt # The default prompt is '(Pdb)'
-            
-            # IPython changes...
-            self.is_pydb = has_pydb
-
-            if self.is_pydb:
-
-                # iplib.py's ipalias seems to want pdb's checkline
-                # which located in pydb.fn
-                import pydb.fns
-                self.checkline = lambda filename, lineno: \
-                                 pydb.fns.checkline(self, filename, lineno)
-
-                self.curframe = None
-                self.do_restart = self.new_do_restart
-
-                self.old_all_completions = __IPYTHON__.Completer.all_completions
-                __IPYTHON__.Completer.all_completions=self.all_completions
-
-                self.do_list = decorate_fn_with_doc(self.list_command_pydb,
-                                                    OldPdb.do_list)
-                self.do_l     = self.do_list
-                self.do_frame = decorate_fn_with_doc(self.new_do_frame,
-                                                     OldPdb.do_frame)
-
-            self.aliases = {}
-
-            # Create color table: we copy the default one from the traceback
-            # module and add a few attributes needed for debugging
-            self.color_scheme_table = ExceptionColors.copy()
-
-            # shorthands 
-            C = ColorANSI.TermColors
-            cst = self.color_scheme_table
-
-            cst['NoColor'].colors.breakpoint_enabled = C.NoColor
-            cst['NoColor'].colors.breakpoint_disabled = C.NoColor
-
-            cst['Linux'].colors.breakpoint_enabled = C.LightRed
-            cst['Linux'].colors.breakpoint_disabled = C.Red
-
-            cst['LightBG'].colors.breakpoint_enabled = C.LightRed
-            cst['LightBG'].colors.breakpoint_disabled = C.Red
-
-            self.set_colors(color_scheme)
-
-            # Add a python parser so we can syntax highlight source while
-            # debugging.
-            self.parser = PyColorize.Parser()
-
-
-    else:
-        # Ugly hack: for Python 2.3-2.4, we can't call the parent constructor,
-        # because it binds readline and breaks tab-completion.  This means we
-        # have to COPY the constructor here.
-        def __init__(self,color_scheme='NoColor'):
-            bdb.Bdb.__init__(self)
-            cmd.Cmd.__init__(self,completekey=None) # don't load readline
-            self.prompt = 'ipdb> ' # The default prompt is '(Pdb)'
-            self.aliases = {}
-
-            # These two lines are part of the py2.4 constructor, let's put them
-            # unconditionally here as they won't cause any problems in 2.3.
-            self.mainpyfile = ''
-            self._wait_for_mainpyfile = 0
-
-            # Read $HOME/.pdbrc and ./.pdbrc
-            try:
-                self.rcLines = _file_lines(os.path.join(os.environ['HOME'],
-                                                        ".pdbrc"))
-            except KeyError:
-                self.rcLines = []
-            self.rcLines.extend(_file_lines(".pdbrc"))
-
-            # Create color table: we copy the default one from the traceback
-            # module and add a few attributes needed for debugging
-            ExceptionColors.set_active_scheme(color_scheme)
-            self.color_scheme_table = ExceptionColors.copy()
-
-            # shorthands 
-            C = ColorANSI.TermColors
-            cst = self.color_scheme_table
-
-            cst['NoColor'].colors.breakpoint_enabled = C.NoColor
-            cst['NoColor'].colors.breakpoint_disabled = C.NoColor
-
-            cst['Linux'].colors.breakpoint_enabled = C.LightRed
-            cst['Linux'].colors.breakpoint_disabled = C.Red
-
-            cst['LightBG'].colors.breakpoint_enabled = C.LightRed
-            cst['LightBG'].colors.breakpoint_disabled = C.Red
-
-            self.set_colors(color_scheme)
-
-            # Add a python parser so we can syntax highlight source while
-            # debugging.
-            self.parser = PyColorize.Parser()
-        
-    def set_colors(self, scheme):
-        """Shorthand access to the color table scheme selector method."""
-        self.color_scheme_table.set_active_scheme(scheme)
-
-    def interaction(self, frame, traceback):
-        __IPYTHON__.set_completer_frame(frame)
-        OldPdb.interaction(self, frame, traceback)
-
-    def new_do_up(self, arg):
-        OldPdb.do_up(self, arg)
-        __IPYTHON__.set_completer_frame(self.curframe)
-    do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
-
-    def new_do_down(self, arg):
-        OldPdb.do_down(self, arg)
-        __IPYTHON__.set_completer_frame(self.curframe)
-
-    do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
-
-    def new_do_frame(self, arg):
-        OldPdb.do_frame(self, arg)
-        __IPYTHON__.set_completer_frame(self.curframe)
-
-    def new_do_quit(self, arg):
-        
-        if hasattr(self, 'old_all_completions'):
-            __IPYTHON__.Completer.all_completions=self.old_all_completions
-        
-        
-        return OldPdb.do_quit(self, arg)
-
-    do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
-
-    def new_do_restart(self, arg):
-        """Restart command. In the context of ipython this is exactly the same
-        thing as 'quit'."""
-        self.msg("Restart doesn't make sense here. Using 'quit' instead.")
-        return self.do_quit(arg)
-
-    def postloop(self):
-        __IPYTHON__.set_completer_frame(None)
-
-    def print_stack_trace(self):
-        try:
-            for frame_lineno in self.stack:
-                self.print_stack_entry(frame_lineno, context = 5)
-        except KeyboardInterrupt:
-            pass
-
-    def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
-                          context = 3):
-        #frame, lineno = frame_lineno
-        print >>Term.cout, self.format_stack_entry(frame_lineno, '', context)
-
-    def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
-        import linecache, repr
-        
-        ret = []
-        
-        Colors = self.color_scheme_table.active_colors
-        ColorsNormal = Colors.Normal
-        tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
-        tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
-        tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
-        tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
-                                            ColorsNormal)
-        
-        frame, lineno = frame_lineno
-        
-        return_value = ''
-        if '__return__' in frame.f_locals:
-            rv = frame.f_locals['__return__']
-            #return_value += '->'
-            return_value += repr.repr(rv) + '\n'
-        ret.append(return_value)
-
-        #s = filename + '(' + `lineno` + ')'
-        filename = self.canonic(frame.f_code.co_filename)
-        link = tpl_link % filename
-        
-        if frame.f_code.co_name:
-            func = frame.f_code.co_name
-        else:
-            func = "<lambda>"
-            
-        call = ''
-        if func != '?':         
-            if '__args__' in frame.f_locals:
-                args = repr.repr(frame.f_locals['__args__'])
-            else:
-                args = '()'
-            call = tpl_call % (func, args)
-
-        # The level info should be generated in the same format pdb uses, to
-        # avoid breaking the pdbtrack functionality of python-mode in *emacs.
-        if frame is self.curframe:
-            ret.append('> ')
-        else:
-            ret.append('  ')
-        ret.append('%s(%s)%s\n' % (link,lineno,call))
-            
-        start = lineno - 1 - context//2
-        lines = linecache.getlines(filename)
-        start = max(start, 0)
-        start = min(start, len(lines) - context)
-        lines = lines[start : start + context]
-            
-        for i,line in enumerate(lines):
-            show_arrow = (start + 1 + i == lineno)
-            linetpl = (frame is self.curframe or show_arrow) \
-                      and tpl_line_em \
-                      or tpl_line
-            ret.append(self.__format_line(linetpl, filename,
-                                          start + 1 + i, line,
-                                          arrow = show_arrow) )
-
-        return ''.join(ret)
-
-    def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
-        bp_mark = ""
-        bp_mark_color = ""
-
-        scheme = self.color_scheme_table.active_scheme_name
-        new_line, err = self.parser.format2(line, 'str', scheme)
-        if not err: line = new_line
-
-        bp = None
-        if lineno in self.get_file_breaks(filename):
-            bps = self.get_breaks(filename, lineno)
-            bp = bps[-1]
-        
-        if bp:
-            Colors = self.color_scheme_table.active_colors
-            bp_mark = str(bp.number)
-            bp_mark_color = Colors.breakpoint_enabled
-            if not bp.enabled:
-                bp_mark_color = Colors.breakpoint_disabled
-
-        numbers_width = 7
-        if arrow:
-            # This is the line with the error
-            pad = numbers_width - len(str(lineno)) - len(bp_mark)
-            if pad >= 3:
-                marker = '-'*(pad-3) + '-> '
-            elif pad == 2:
-                 marker = '> '
-            elif pad == 1:
-                 marker = '>'
-            else:
-                 marker = ''
-            num = '%s%s' % (marker, str(lineno))
-            line = tpl_line % (bp_mark_color + bp_mark, num, line)
-        else:
-            num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
-            line = tpl_line % (bp_mark_color + bp_mark, num, line)
-            
-        return line
-
-    def list_command_pydb(self, arg):
-        """List command to use if we have a newer pydb installed"""
-        filename, first, last = OldPdb.parse_list_cmd(self, arg)
-        if filename is not None:
-            self.print_list_lines(filename, first, last)
-        
-    def print_list_lines(self, filename, first, last):
-        """The printing (as opposed to the parsing part of a 'list'
-        command."""
-        try:
-            Colors = self.color_scheme_table.active_colors
-            ColorsNormal = Colors.Normal
-            tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
-            tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
-            src = []
-            for lineno in range(first, last+1):
-                line = linecache.getline(filename, lineno)
-                if not line:
-                    break
-
-                if lineno == self.curframe.f_lineno:
-                    line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
-                else:
-                    line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
-
-                src.append(line)
-                self.lineno = lineno
-
-            print >>Term.cout, ''.join(src)
-
-        except KeyboardInterrupt:
-            pass
-
-    def do_list(self, arg):
-        self.lastcmd = 'list'
-        last = None
-        if arg:
-            try:
-                x = eval(arg, {}, {})
-                if type(x) == type(()):
-                    first, last = x
-                    first = int(first)
-                    last = int(last)
-                    if last < first:
-                        # Assume it's a count
-                        last = first + last
-                else:
-                    first = max(1, int(x) - 5)
-            except:
-                print '*** Error in argument:', `arg`
-                return
-        elif self.lineno is None:
-            first = max(1, self.curframe.f_lineno - 5)
-        else:
-            first = self.lineno + 1
-        if last is None:
-            last = first + 10
-        self.print_list_lines(self.curframe.f_code.co_filename, first, last)
-
-    do_l = do_list
-
-    def do_pdef(self, arg):
-        """The debugger interface to magic_pdef"""
-        namespaces = [('Locals', self.curframe.f_locals),
-                      ('Globals', self.curframe.f_globals)]
-        __IPYTHON__.magic_pdef(arg, namespaces=namespaces)
-
-    def do_pdoc(self, arg):
-        """The debugger interface to magic_pdoc"""
-        namespaces = [('Locals', self.curframe.f_locals),
-                      ('Globals', self.curframe.f_globals)]
-        __IPYTHON__.magic_pdoc(arg, namespaces=namespaces)
-
-    def do_pinfo(self, arg):
-        """The debugger equivalant of ?obj"""
-        namespaces = [('Locals', self.curframe.f_locals),
-                      ('Globals', self.curframe.f_globals)]
-        __IPYTHON__.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)
+# -*- coding: utf-8 -*-
+"""
+Pdb debugger class.
+
+Modified from the standard pdb.Pdb class to avoid including readline, so that
+the command line completion of other programs which include this isn't
+damaged.
+
+In the future, this class will be expanded with improvements over the standard
+pdb.
+
+The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor
+changes. Licensing should therefore be under the standard Python terms.  For
+details on the PSF (Python Software Foundation) standard license, see:
+
+http://www.python.org/2.2.3/license.html
+
+$Id: Debugger.py 2913 2007-12-31 12:42:14Z vivainio $"""
+
+#*****************************************************************************
+#
+#       This file is licensed under the PSF license.
+#
+#       Copyright (C) 2001 Python Software Foundation, www.python.org
+#       Copyright (C) 2005-2006 Fernando Perez. <[e-mail]>
+#
+#
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = 'Python'
+
+import bdb
+import cmd
+import linecache
+import os
+import sys
+
+from IPython import PyColorize, ColorANSI, ipapi
+from IPython.genutils import Term
+from IPython.excolors import ExceptionColors
+
+# See if we can use pydb.
+has_pydb = False
+prompt = 'ipdb> '
+#We have to check this directly from sys.argv, config struct not yet available
+if '-pydb' in sys.argv:
+    try:        
+        import pydb
+        if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':
+            # Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we
+            # better protect against it.
+            has_pydb = True
+    except ImportError:
+        print "Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available"
+
+if has_pydb:
+    from pydb import Pdb as OldPdb
+    #print "Using pydb for %run -d and post-mortem" #dbg
+    prompt = 'ipydb> '
+else:
+    from pdb import Pdb as OldPdb
+
+# Allow the set_trace code to operate outside of an ipython instance, even if
+# it does so with some limitations.  The rest of this support is implemented in
+# the Tracer constructor.
+def BdbQuit_excepthook(et,ev,tb):
+    if et==bdb.BdbQuit:
+        print 'Exiting Debugger.'
+    else:
+        BdbQuit_excepthook.excepthook_ori(et,ev,tb)
+
+def BdbQuit_IPython_excepthook(self,et,ev,tb):
+    print 'Exiting Debugger.'
+
+class Tracer(object):
+    """Class for local debugging, similar to pdb.set_trace.
+
+    Instances of this class, when called, behave like pdb.set_trace, but
+    providing IPython's enhanced capabilities.
+
+    This is implemented as a class which must be initialized in your own code
+    and not as a standalone function because we need to detect at runtime
+    whether IPython is already active or not.  That detection is done in the
+    constructor, ensuring that this code plays nicely with a running IPython,
+    while functioning acceptably (though with limitations) if outside of it.
+    """
+
+    def __init__(self,colors=None):
+        """Create a local debugger instance.
+
+        :Parameters:
+
+          - `colors` (None): a string containing the name of the color scheme to
+        use, it must be one of IPython's valid color schemes.  If not given, the
+        function will default to the current IPython scheme when running inside
+        IPython, and to 'NoColor' otherwise.
+
+        Usage example:
+
+        from IPython.Debugger import Tracer; debug_here = Tracer()
+
+        ... later in your code
+        debug_here()  # -> will open up the debugger at that point.
+
+        Once the debugger activates, you can use all of its regular commands to
+        step through code, set breakpoints, etc.  See the pdb documentation
+        from the Python standard library for usage details.
+        """
+
+        global __IPYTHON__
+        try:
+            __IPYTHON__
+        except NameError:
+            # Outside of ipython, we set our own exception hook manually
+            __IPYTHON__ = ipapi.get(True,False)
+            BdbQuit_excepthook.excepthook_ori = sys.excepthook
+            sys.excepthook = BdbQuit_excepthook
+            def_colors = 'NoColor'
+            try:
+                # Limited tab completion support
+                import rlcompleter,readline
+                readline.parse_and_bind('tab: complete')
+            except ImportError:
+                pass
+        else:
+            # In ipython, we use its custom exception handler mechanism
+            ip = ipapi.get()
+            def_colors = ip.options.colors
+            ip.set_custom_exc((bdb.BdbQuit,),BdbQuit_IPython_excepthook)
+
+        if colors is None:
+            colors = def_colors
+        self.debugger = Pdb(colors)
+
+    def __call__(self):
+        """Starts an interactive debugger at the point where called.
+
+        This is similar to the pdb.set_trace() function from the std lib, but
+        using IPython's enhanced debugger."""
+        
+        self.debugger.set_trace(sys._getframe().f_back)
+
+def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
+    """Make new_fn have old_fn's doc string. This is particularly useful
+    for the do_... commands that hook into the help system.
+    Adapted from from a comp.lang.python posting
+    by Duncan Booth."""
+    def wrapper(*args, **kw):
+        return new_fn(*args, **kw)
+    if old_fn.__doc__:
+        wrapper.__doc__ = old_fn.__doc__ + additional_text
+    return wrapper
+
+def _file_lines(fname):
+    """Return the contents of a named file as a list of lines.
+
+    This function never raises an IOError exception: if the file can't be
+    read, it simply returns an empty list."""
+
+    try:
+        outfile = open(fname)
+    except IOError:
+        return []
+    else:
+        out = outfile.readlines()
+        outfile.close()
+        return out
+
+class Pdb(OldPdb):
+    """Modified Pdb class, does not load readline."""
+
+    if sys.version[:3] >= '2.5' or has_pydb:
+        def __init__(self,color_scheme='NoColor',completekey=None,
+                     stdin=None, stdout=None):
+
+            # Parent constructor:
+            if has_pydb and completekey is None:
+                OldPdb.__init__(self,stdin=stdin,stdout=Term.cout)
+            else:
+                OldPdb.__init__(self,completekey,stdin,stdout)
+                
+            self.prompt = prompt # The default prompt is '(Pdb)'
+            
+            # IPython changes...
+            self.is_pydb = has_pydb
+
+            if self.is_pydb:
+
+                # iplib.py's ipalias seems to want pdb's checkline
+                # which located in pydb.fn
+                import pydb.fns
+                self.checkline = lambda filename, lineno: \
+                                 pydb.fns.checkline(self, filename, lineno)
+
+                self.curframe = None
+                self.do_restart = self.new_do_restart
+
+                self.old_all_completions = __IPYTHON__.Completer.all_completions
+                __IPYTHON__.Completer.all_completions=self.all_completions
+
+                self.do_list = decorate_fn_with_doc(self.list_command_pydb,
+                                                    OldPdb.do_list)
+                self.do_l     = self.do_list
+                self.do_frame = decorate_fn_with_doc(self.new_do_frame,
+                                                     OldPdb.do_frame)
+
+            self.aliases = {}
+
+            # Create color table: we copy the default one from the traceback
+            # module and add a few attributes needed for debugging
+            self.color_scheme_table = ExceptionColors.copy()
+
+            # shorthands 
+            C = ColorANSI.TermColors
+            cst = self.color_scheme_table
+
+            cst['NoColor'].colors.breakpoint_enabled = C.NoColor
+            cst['NoColor'].colors.breakpoint_disabled = C.NoColor
+
+            cst['Linux'].colors.breakpoint_enabled = C.LightRed
+            cst['Linux'].colors.breakpoint_disabled = C.Red
+
+            cst['LightBG'].colors.breakpoint_enabled = C.LightRed
+            cst['LightBG'].colors.breakpoint_disabled = C.Red
+
+            self.set_colors(color_scheme)
+
+            # Add a python parser so we can syntax highlight source while
+            # debugging.
+            self.parser = PyColorize.Parser()
+
+
+    else:
+        # Ugly hack: for Python 2.3-2.4, we can't call the parent constructor,
+        # because it binds readline and breaks tab-completion.  This means we
+        # have to COPY the constructor here.
+        def __init__(self,color_scheme='NoColor'):
+            bdb.Bdb.__init__(self)
+            cmd.Cmd.__init__(self,completekey=None) # don't load readline
+            self.prompt = 'ipdb> ' # The default prompt is '(Pdb)'
+            self.aliases = {}
+
+            # These two lines are part of the py2.4 constructor, let's put them
+            # unconditionally here as they won't cause any problems in 2.3.
+            self.mainpyfile = ''
+            self._wait_for_mainpyfile = 0
+
+            # Read $HOME/.pdbrc and ./.pdbrc
+            try:
+                self.rcLines = _file_lines(os.path.join(os.environ['HOME'],
+                                                        ".pdbrc"))
+            except KeyError:
+                self.rcLines = []
+            self.rcLines.extend(_file_lines(".pdbrc"))
+
+            # Create color table: we copy the default one from the traceback
+            # module and add a few attributes needed for debugging
+            ExceptionColors.set_active_scheme(color_scheme)
+            self.color_scheme_table = ExceptionColors.copy()
+
+            # shorthands 
+            C = ColorANSI.TermColors
+            cst = self.color_scheme_table
+
+            cst['NoColor'].colors.breakpoint_enabled = C.NoColor
+            cst['NoColor'].colors.breakpoint_disabled = C.NoColor
+
+            cst['Linux'].colors.breakpoint_enabled = C.LightRed
+            cst['Linux'].colors.breakpoint_disabled = C.Red
+
+            cst['LightBG'].colors.breakpoint_enabled = C.LightRed
+            cst['LightBG'].colors.breakpoint_disabled = C.Red
+
+            self.set_colors(color_scheme)
+
+            # Add a python parser so we can syntax highlight source while
+            # debugging.
+            self.parser = PyColorize.Parser()
+        
+    def set_colors(self, scheme):
+        """Shorthand access to the color table scheme selector method."""
+        self.color_scheme_table.set_active_scheme(scheme)
+
+    def interaction(self, frame, traceback):
+        __IPYTHON__.set_completer_frame(frame)
+        OldPdb.interaction(self, frame, traceback)
+
+    def new_do_up(self, arg):
+        OldPdb.do_up(self, arg)
+        __IPYTHON__.set_completer_frame(self.curframe)
+    do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
+
+    def new_do_down(self, arg):
+        OldPdb.do_down(self, arg)
+        __IPYTHON__.set_completer_frame(self.curframe)
+
+    do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
+
+    def new_do_frame(self, arg):
+        OldPdb.do_frame(self, arg)
+        __IPYTHON__.set_completer_frame(self.curframe)
+
+    def new_do_quit(self, arg):
+        
+        if hasattr(self, 'old_all_completions'):
+            __IPYTHON__.Completer.all_completions=self.old_all_completions
+        
+        
+        return OldPdb.do_quit(self, arg)
+
+    do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
+
+    def new_do_restart(self, arg):
+        """Restart command. In the context of ipython this is exactly the same
+        thing as 'quit'."""
+        self.msg("Restart doesn't make sense here. Using 'quit' instead.")
+        return self.do_quit(arg)
+
+    def postloop(self):
+        __IPYTHON__.set_completer_frame(None)
+
+    def print_stack_trace(self):
+        try:
+            for frame_lineno in self.stack:
+                self.print_stack_entry(frame_lineno, context = 5)
+        except KeyboardInterrupt:
+            pass
+
+    def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
+                          context = 3):
+        #frame, lineno = frame_lineno
+        print >>Term.cout, self.format_stack_entry(frame_lineno, '', context)
+
+    def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
+        import linecache, repr
+        
+        ret = []
+        
+        Colors = self.color_scheme_table.active_colors
+        ColorsNormal = Colors.Normal
+        tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
+        tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
+        tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
+        tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
+                                            ColorsNormal)
+        
+        frame, lineno = frame_lineno
+        
+        return_value = ''
+        if '__return__' in frame.f_locals:
+            rv = frame.f_locals['__return__']
+            #return_value += '->'
+            return_value += repr.repr(rv) + '\n'
+        ret.append(return_value)
+
+        #s = filename + '(' + `lineno` + ')'
+        filename = self.canonic(frame.f_code.co_filename)
+        link = tpl_link % filename
+        
+        if frame.f_code.co_name:
+            func = frame.f_code.co_name
+        else:
+            func = "<lambda>"
+            
+        call = ''
+        if func != '?':         
+            if '__args__' in frame.f_locals:
+                args = repr.repr(frame.f_locals['__args__'])
+            else:
+                args = '()'
+            call = tpl_call % (func, args)
+
+        # The level info should be generated in the same format pdb uses, to
+        # avoid breaking the pdbtrack functionality of python-mode in *emacs.
+        if frame is self.curframe:
+            ret.append('> ')
+        else:
+            ret.append('  ')
+        ret.append('%s(%s)%s\n' % (link,lineno,call))
+            
+        start = lineno - 1 - context//2
+        lines = linecache.getlines(filename)
+        start = max(start, 0)
+        start = min(start, len(lines) - context)
+        lines = lines[start : start + context]
+            
+        for i,line in enumerate(lines):
+            show_arrow = (start + 1 + i == lineno)
+            linetpl = (frame is self.curframe or show_arrow) \
+                      and tpl_line_em \
+                      or tpl_line
+            ret.append(self.__format_line(linetpl, filename,
+                                          start + 1 + i, line,
+                                          arrow = show_arrow) )
+
+        return ''.join(ret)
+
+    def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
+        bp_mark = ""
+        bp_mark_color = ""
+
+        scheme = self.color_scheme_table.active_scheme_name
+        new_line, err = self.parser.format2(line, 'str', scheme)
+        if not err: line = new_line
+
+        bp = None
+        if lineno in self.get_file_breaks(filename):
+            bps = self.get_breaks(filename, lineno)
+            bp = bps[-1]
+        
+        if bp:
+            Colors = self.color_scheme_table.active_colors
+            bp_mark = str(bp.number)
+            bp_mark_color = Colors.breakpoint_enabled
+            if not bp.enabled:
+                bp_mark_color = Colors.breakpoint_disabled
+
+        numbers_width = 7
+        if arrow:
+            # This is the line with the error
+            pad = numbers_width - len(str(lineno)) - len(bp_mark)
+            if pad >= 3:
+                marker = '-'*(pad-3) + '-> '
+            elif pad == 2:
+                 marker = '> '
+            elif pad == 1:
+                 marker = '>'
+            else:
+                 marker = ''
+            num = '%s%s' % (marker, str(lineno))
+            line = tpl_line % (bp_mark_color + bp_mark, num, line)
+        else:
+            num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
+            line = tpl_line % (bp_mark_color + bp_mark, num, line)
+            
+        return line
+
+    def list_command_pydb(self, arg):
+        """List command to use if we have a newer pydb installed"""
+        filename, first, last = OldPdb.parse_list_cmd(self, arg)
+        if filename is not None:
+            self.print_list_lines(filename, first, last)
+        
+    def print_list_lines(self, filename, first, last):
+        """The printing (as opposed to the parsing part of a 'list'
+        command."""
+        try:
+            Colors = self.color_scheme_table.active_colors
+            ColorsNormal = Colors.Normal
+            tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
+            tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
+            src = []
+            for lineno in range(first, last+1):
+                line = linecache.getline(filename, lineno)
+                if not line:
+                    break
+
+                if lineno == self.curframe.f_lineno:
+                    line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
+                else:
+                    line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
+
+                src.append(line)
+                self.lineno = lineno
+
+            print >>Term.cout, ''.join(src)
+
+        except KeyboardInterrupt:
+            pass
+
+    def do_list(self, arg):
+        self.lastcmd = 'list'
+        last = None
+        if arg:
+            try:
+                x = eval(arg, {}, {})
+                if type(x) == type(()):
+                    first, last = x
+                    first = int(first)
+                    last = int(last)
+                    if last < first:
+                        # Assume it's a count
+                        last = first + last
+                else:
+                    first = max(1, int(x) - 5)
+            except:
+                print '*** Error in argument:', `arg`
+                return
+        elif self.lineno is None:
+            first = max(1, self.curframe.f_lineno - 5)
+        else:
+            first = self.lineno + 1
+        if last is None:
+            last = first + 10
+        self.print_list_lines(self.curframe.f_code.co_filename, first, last)
+
+    do_l = do_list
+
+    def do_pdef(self, arg):
+        """The debugger interface to magic_pdef"""
+        namespaces = [('Locals', self.curframe.f_locals),
+                      ('Globals', self.curframe.f_globals)]
+        __IPYTHON__.magic_pdef(arg, namespaces=namespaces)
+
+    def do_pdoc(self, arg):
+        """The debugger interface to magic_pdoc"""
+        namespaces = [('Locals', self.curframe.f_locals),
+                      ('Globals', self.curframe.f_globals)]
+        __IPYTHON__.magic_pdoc(arg, namespaces=namespaces)
+
+    def do_pinfo(self, arg):
+        """The debugger equivalant of ?obj"""
+        namespaces = [('Locals', self.curframe.f_locals),
+                      ('Globals', self.curframe.f_globals)]
+        __IPYTHON__.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)

IPython/Extensions/InterpreterExec.py

@@ -1,259 +1,259 b''
-# -*- coding: utf-8 -*-
-"""Modified input prompt for executing files.
-
-We define a special input line filter to allow typing lines which begin with
-'~', '/' or '.'. If one of those strings is encountered, it is automatically
-executed.
-
-$Id: InterpreterExec.py 2724 2007-09-07 08:05:38Z fperez $"""
-
-#*****************************************************************************
-#       Copyright (C) 2004 W.J. van der Laan <[e-mail]>
-#       Copyright (C) 2004-2006 Fernando Perez <[e-mail]>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-from IPython import Release
-__author__ = 'W.J. van der Laan <[e-mail]>, '\
-             '%s <%s>' %  Release.authors['Fernando']
-__license__ = Release.license
-
-# TODO: deprecated
-def prefilter_shell(self,line,continuation):
-    """Alternate prefilter, modified for shell-like functionality.
-
-    - Execute all lines beginning with '~', '/' or '.'
-    - $var=cmd <=> %sc var=cmd
-    - $$var=cmd <=> %sc -l var=cmd
-    """
-
-    if line:
-        l0 = line[0]
-        if l0 in '~/.':
-            return self._prefilter("!%s"%line,continuation)
-        elif l0=='$':
-            lrest = line[1:]
-            if lrest.startswith('$'):
-                # $$var=cmd <=> %sc -l var=cmd
-                return self._prefilter("%ssc -l %s" % (self.ESC_MAGIC,lrest[1:]),
-                                       continuation)
-            else:
-                # $var=cmd <=> %sc var=cmd
-                return self._prefilter("%ssc %s" % (self.ESC_MAGIC,lrest),
-                                       continuation)
-        else:
-            return self._prefilter(line,continuation)
-    else:
-        return self._prefilter(line,continuation)
-
-# Rebind this to be the new IPython prefilter:
-from IPython.iplib import InteractiveShell
-InteractiveShell.prefilter = prefilter_shell
-# Clean up the namespace.
-del InteractiveShell,prefilter_shell
-
-# Provide pysh and further shell-oriented services
-import os,sys,shutil
-from IPython.genutils import system,shell,getoutput,getoutputerror
-
-# Short aliases for getting shell output as a string and a list
-sout = getoutput
-lout = lambda cmd: getoutput(cmd,split=1)
-
-# Empty function, meant as a docstring holder so help(pysh) works.
-def pysh():
-    """Pysh is a set of modules and extensions to IPython which make shell-like
-    usage with Python syntax more convenient.  Keep in mind that pysh is NOT a
-    full-blown shell, so don't try to make it your /etc/passwd entry!
-    
-    In particular, it has no job control, so if you type Ctrl-Z (under Unix),
-    you'll suspend pysh itself, not the process you just started.
-
-    Since pysh is really nothing but a customized IPython, you should
-    familiarize yourself with IPython's features.  This brief help mainly
-    documents areas in which pysh differs from the normal IPython.
-
-    ALIASES
-    -------
-    All of your $PATH has been loaded as IPython aliases, so you should be
-    able to type any normal system command and have it executed.  See %alias? 
-    and %unalias? for details on the alias facilities.
-
-    SPECIAL SYNTAX
-    --------------
-    Any lines which begin with '~', '/' and '.' will be executed as shell
-    commands instead of as Python code. The special escapes below are also
-    recognized.  !cmd is valid in single or multi-line input, all others are
-    only valid in single-line input:
-
-    !cmd      - pass 'cmd' directly to the shell
-    !!cmd     - execute 'cmd' and return output as a list (split on '\\n')
-    $var=cmd  - capture output of cmd into var, as a string
-    $$var=cmd - capture output of cmd into var, as a list (split on '\\n')
-
-    The $/$$ syntaxes make Python variables from system output, which you can
-    later use for further scripting.  The converse is also possible: when
-    executing an alias or calling to the system via !/!!, you can expand any
-    python variable or expression by prepending it with $.  Full details of
-    the allowed syntax can be found in Python's PEP 215.
-
-    A few brief examples will illustrate these:
-
-        fperez[~/test]|3> !ls *s.py
-        scopes.py  strings.py
-
-    ls is an internal alias, so there's no need to use !:
-        fperez[~/test]|4> ls *s.py
-        scopes.py*  strings.py
-
-    !!ls will return the output into a Python variable:
-        fperez[~/test]|5> !!ls *s.py
-                      <5> ['scopes.py', 'strings.py']
-        fperez[~/test]|6> print _5
-        ['scopes.py', 'strings.py']
-
-    $ and $$ allow direct capture to named variables:
-        fperez[~/test]|7> $astr = ls *s.py
-        fperez[~/test]|8> astr
-                      <8> 'scopes.py\\nstrings.py'
-
-        fperez[~/test]|9> $$alist = ls *s.py
-        fperez[~/test]|10> alist
-                      <10> ['scopes.py', 'strings.py']
-
-    alist is now a normal python list you can loop over.  Using $ will expand
-    back the python values when alias calls are made:
-        fperez[~/test]|11> for f in alist:
-                      |..>     print 'file',f,
-                      |..>     wc -l $f
-                      |..>
-        file scopes.py     13 scopes.py
-        file strings.py      4 strings.py
-
-    Note that you may need to protect your variables with braces if you want
-    to append strings to their names.  To copy all files in alist to .bak
-    extensions, you must use:
-        fperez[~/test]|12> for f in alist:
-                      |..>     cp $f ${f}.bak
-
-    If you try using $f.bak, you'll get an AttributeError exception saying
-    that your string object doesn't have a .bak attribute.  This is because
-    the $ expansion mechanism allows you to expand full Python expressions:
-        fperez[~/test]|13> echo "sys.platform is: $sys.platform"
-        sys.platform is: linux2
-
-    IPython's input history handling is still active, which allows you to
-    rerun a single block of multi-line input by simply using exec:    
-        fperez[~/test]|14> $$alist = ls *.eps
-        fperez[~/test]|15> exec _i11
-        file image2.eps    921 image2.eps
-        file image.eps    921 image.eps
-
-    While these are new special-case syntaxes, they are designed to allow very
-    efficient use of the shell with minimal typing.  At an interactive shell
-    prompt, conciseness of expression wins over readability.
-
-    USEFUL FUNCTIONS AND MODULES
-    ----------------------------
-    The os, sys and shutil modules from the Python standard library are
-    automatically loaded.  Some additional functions, useful for shell usage,
-    are listed below.  You can request more help about them with '?'.
-
-    shell   - execute a command in the underlying system shell    
-    system  - like shell(), but return the exit status of the command
-    sout    - capture the output of a command as a string
-    lout    - capture the output of a command as a list (split on '\\n')
-    getoutputerror - capture (output,error) of a shell command
-
-    sout/lout are the functional equivalents of $/$$.  They are provided to
-    allow you to capture system output in the middle of true python code,
-    function definitions, etc (where $ and $$ are invalid).
-
-    DIRECTORY MANAGEMENT
-    --------------------
-    Since each command passed by pysh to the underlying system is executed in
-    a subshell which exits immediately, you can NOT use !cd to navigate the
-    filesystem.
-
-    Pysh provides its own builtin '%cd' magic command to move in the
-    filesystem (the % is not required with automagic on).  It also maintains a
-    list of visited directories (use %dhist to see it) and allows direct
-    switching to any of them.  Type 'cd?' for more details.
-
-    %pushd, %popd and %dirs are provided for directory stack handling.
-
-    PROMPT CUSTOMIZATION
-    --------------------
-    
-    The supplied ipythonrc-pysh profile comes with an example of a very
-    colored and detailed prompt, mainly to serve as an illustration.  The
-    valid escape sequences, besides color names, are:
-
-        \\#  - Prompt number.
-        \\D  - Dots, as many as there are digits in \\# (so they align).
-        \\w  - Current working directory (cwd).
-        \\W  - Basename of current working directory.
-        \\XN - Where N=0..5. N terms of the cwd, with $HOME written as ~.
-        \\YN - Where N=0..5. Like XN, but if ~ is term N+1 it's also shown.
-        \\u  - Username.
-        \\H  - Full hostname.
-        \\h  - Hostname up to first '.'
-        \\$  - Root symbol ($ or #).
-        \\t  - Current time, in H:M:S format.
-        \\v  - IPython release version.
-        \\n  - Newline.
-        \\r  - Carriage return.
-        \\\\ - An explicitly escaped '\\'.
-
-    You can configure your prompt colors using any ANSI color escape.  Each
-    color escape sets the color for any subsequent text, until another escape
-    comes in and changes things.  The valid color escapes are:
-
-        \\C_Black
-        \\C_Blue
-        \\C_Brown
-        \\C_Cyan
-        \\C_DarkGray
-        \\C_Green
-        \\C_LightBlue
-        \\C_LightCyan
-        \\C_LightGray
-        \\C_LightGreen
-        \\C_LightPurple
-        \\C_LightRed
-        \\C_Purple
-        \\C_Red
-        \\C_White
-        \\C_Yellow
-        \\C_Normal - Stop coloring, defaults to your terminal settings.
-    """
-    pass
-
-# Configure a few things.  Much of this is fairly hackish, since IPython
-# doesn't really expose a clean API for it.  Be careful if you start making
-# many modifications here.
-
-
-#  Set the 'cd' command to quiet mode, a more shell-like behavior
-__IPYTHON__.default_option('cd','-q')
-
-# This is redundant, ipy_user_conf.py will determine this
-# Load all of $PATH as aliases
-__IPYTHON__.magic_rehashx()
-
-# Remove %sc,%sx if present as aliases
-__IPYTHON__.magic_unalias('sc')
-__IPYTHON__.magic_unalias('sx')
-
-# We need different criteria for line-splitting, so that aliases such as
-# 'gnome-terminal' are interpreted as a single alias instead of variable
-# 'gnome' minus variable 'terminal'.
-import re
-__IPYTHON__.line_split = re.compile(r'^([\s*,;/])'
-                                    r'([\?\w\.\-\+]+\w*\s*)'
-                                    r'(\(?.*$)')
-
-# Namespace cleanup
-del re
+# -*- coding: utf-8 -*-
+"""Modified input prompt for executing files.
+
+We define a special input line filter to allow typing lines which begin with
+'~', '/' or '.'. If one of those strings is encountered, it is automatically
+executed.
+
+$Id: InterpreterExec.py 2724 2007-09-07 08:05:38Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2004 W.J. van der Laan <[e-mail]>
+#       Copyright (C) 2004-2006 Fernando Perez <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__ = 'W.J. van der Laan <[e-mail]>, '\
+             '%s <%s>' %  Release.authors['Fernando']
+__license__ = Release.license
+
+# TODO: deprecated
+def prefilter_shell(self,line,continuation):
+    """Alternate prefilter, modified for shell-like functionality.
+
+    - Execute all lines beginning with '~', '/' or '.'
+    - $var=cmd <=> %sc var=cmd
+    - $$var=cmd <=> %sc -l var=cmd
+    """
+
+    if line:
+        l0 = line[0]
+        if l0 in '~/.':
+            return self._prefilter("!%s"%line,continuation)
+        elif l0=='$':
+            lrest = line[1:]
+            if lrest.startswith('$'):
+                # $$var=cmd <=> %sc -l var=cmd
+                return self._prefilter("%ssc -l %s" % (self.ESC_MAGIC,lrest[1:]),
+                                       continuation)
+            else:
+                # $var=cmd <=> %sc var=cmd
+                return self._prefilter("%ssc %s" % (self.ESC_MAGIC,lrest),
+                                       continuation)
+        else:
+            return self._prefilter(line,continuation)
+    else:
+        return self._prefilter(line,continuation)
+
+# Rebind this to be the new IPython prefilter:
+from IPython.iplib import InteractiveShell
+InteractiveShell.prefilter = prefilter_shell
+# Clean up the namespace.
+del InteractiveShell,prefilter_shell
+
+# Provide pysh and further shell-oriented services
+import os,sys,shutil
+from IPython.genutils import system,shell,getoutput,getoutputerror
+
+# Short aliases for getting shell output as a string and a list
+sout = getoutput
+lout = lambda cmd: getoutput(cmd,split=1)
+
+# Empty function, meant as a docstring holder so help(pysh) works.
+def pysh():
+    """Pysh is a set of modules and extensions to IPython which make shell-like
+    usage with Python syntax more convenient.  Keep in mind that pysh is NOT a
+    full-blown shell, so don't try to make it your /etc/passwd entry!
+    
+    In particular, it has no job control, so if you type Ctrl-Z (under Unix),
+    you'll suspend pysh itself, not the process you just started.
+
+    Since pysh is really nothing but a customized IPython, you should
+    familiarize yourself with IPython's features.  This brief help mainly
+    documents areas in which pysh differs from the normal IPython.
+
+    ALIASES
+    -------
+    All of your $PATH has been loaded as IPython aliases, so you should be
+    able to type any normal system command and have it executed.  See %alias? 
+    and %unalias? for details on the alias facilities.
+
+    SPECIAL SYNTAX
+    --------------
+    Any lines which begin with '~', '/' and '.' will be executed as shell
+    commands instead of as Python code. The special escapes below are also
+    recognized.  !cmd is valid in single or multi-line input, all others are
+    only valid in single-line input:
+
+    !cmd      - pass 'cmd' directly to the shell
+    !!cmd     - execute 'cmd' and return output as a list (split on '\\n')
+    $var=cmd  - capture output of cmd into var, as a string
+    $$var=cmd - capture output of cmd into var, as a list (split on '\\n')
+
+    The $/$$ syntaxes make Python variables from system output, which you can
+    later use for further scripting.  The converse is also possible: when
+    executing an alias or calling to the system via !/!!, you can expand any
+    python variable or expression by prepending it with $.  Full details of
+    the allowed syntax can be found in Python's PEP 215.
+
+    A few brief examples will illustrate these:
+
+        fperez[~/test]|3> !ls *s.py
+        scopes.py  strings.py
+
+    ls is an internal alias, so there's no need to use !:
+        fperez[~/test]|4> ls *s.py
+        scopes.py*  strings.py
+
+    !!ls will return the output into a Python variable:
+        fperez[~/test]|5> !!ls *s.py
+                      <5> ['scopes.py', 'strings.py']
+        fperez[~/test]|6> print _5
+        ['scopes.py', 'strings.py']
+
+    $ and $$ allow direct capture to named variables:
+        fperez[~/test]|7> $astr = ls *s.py
+        fperez[~/test]|8> astr
+                      <8> 'scopes.py\\nstrings.py'
+
+        fperez[~/test]|9> $$alist = ls *s.py
+        fperez[~/test]|10> alist
+                      <10> ['scopes.py', 'strings.py']
+
+    alist is now a normal python list you can loop over.  Using $ will expand
+    back the python values when alias calls are made:
+        fperez[~/test]|11> for f in alist:
+                      |..>     print 'file',f,
+                      |..>     wc -l $f
+                      |..>
+        file scopes.py     13 scopes.py
+        file strings.py      4 strings.py
+
+    Note that you may need to protect your variables with braces if you want
+    to append strings to their names.  To copy all files in alist to .bak
+    extensions, you must use:
+        fperez[~/test]|12> for f in alist:
+                      |..>     cp $f ${f}.bak
+
+    If you try using $f.bak, you'll get an AttributeError exception saying
+    that your string object doesn't have a .bak attribute.  This is because
+    the $ expansion mechanism allows you to expand full Python expressions:
+        fperez[~/test]|13> echo "sys.platform is: $sys.platform"
+        sys.platform is: linux2
+
+    IPython's input history handling is still active, which allows you to
+    rerun a single block of multi-line input by simply using exec:    
+        fperez[~/test]|14> $$alist = ls *.eps
+        fperez[~/test]|15> exec _i11
+        file image2.eps    921 image2.eps
+        file image.eps    921 image.eps
+
+    While these are new special-case syntaxes, they are designed to allow very
+    efficient use of the shell with minimal typing.  At an interactive shell
+    prompt, conciseness of expression wins over readability.
+
+    USEFUL FUNCTIONS AND MODULES
+    ----------------------------
+    The os, sys and shutil modules from the Python standard library are
+    automatically loaded.  Some additional functions, useful for shell usage,
+    are listed below.  You can request more help about them with '?'.
+
+    shell   - execute a command in the underlying system shell    
+    system  - like shell(), but return the exit status of the command
+    sout    - capture the output of a command as a string
+    lout    - capture the output of a command as a list (split on '\\n')
+    getoutputerror - capture (output,error) of a shell command
+
+    sout/lout are the functional equivalents of $/$$.  They are provided to
+    allow you to capture system output in the middle of true python code,
+    function definitions, etc (where $ and $$ are invalid).
+
+    DIRECTORY MANAGEMENT
+    --------------------
+    Since each command passed by pysh to the underlying system is executed in
+    a subshell which exits immediately, you can NOT use !cd to navigate the
+    filesystem.
+
+    Pysh provides its own builtin '%cd' magic command to move in the
+    filesystem (the % is not required with automagic on).  It also maintains a
+    list of visited directories (use %dhist to see it) and allows direct
+    switching to any of them.  Type 'cd?' for more details.
+
+    %pushd, %popd and %dirs are provided for directory stack handling.
+
+    PROMPT CUSTOMIZATION
+    --------------------
+    
+    The supplied ipythonrc-pysh profile comes with an example of a very
+    colored and detailed prompt, mainly to serve as an illustration.  The
+    valid escape sequences, besides color names, are:
+
+        \\#  - Prompt number.
+        \\D  - Dots, as many as there are digits in \\# (so they align).
+        \\w  - Current working directory (cwd).
+        \\W  - Basename of current working directory.
+        \\XN - Where N=0..5. N terms of the cwd, with $HOME written as ~.
+        \\YN - Where N=0..5. Like XN, but if ~ is term N+1 it's also shown.
+        \\u  - Username.
+        \\H  - Full hostname.
+        \\h  - Hostname up to first '.'
+        \\$  - Root symbol ($ or #).
+        \\t  - Current time, in H:M:S format.
+        \\v  - IPython release version.
+        \\n  - Newline.
+        \\r  - Carriage return.
+        \\\\ - An explicitly escaped '\\'.
+
+    You can configure your prompt colors using any ANSI color escape.  Each
+    color escape sets the color for any subsequent text, until another escape
+    comes in and changes things.  The valid color escapes are:
+
+        \\C_Black
+        \\C_Blue
+        \\C_Brown
+        \\C_Cyan
+        \\C_DarkGray
+        \\C_Green
+        \\C_LightBlue
+        \\C_LightCyan
+        \\C_LightGray
+        \\C_LightGreen
+        \\C_LightPurple
+        \\C_LightRed
+        \\C_Purple
+        \\C_Red
+        \\C_White
+        \\C_Yellow
+        \\C_Normal - Stop coloring, defaults to your terminal settings.
+    """
+    pass
+
+# Configure a few things.  Much of this is fairly hackish, since IPython
+# doesn't really expose a clean API for it.  Be careful if you start making
+# many modifications here.
+
+
+#  Set the 'cd' command to quiet mode, a more shell-like behavior
+__IPYTHON__.default_option('cd','-q')
+
+# This is redundant, ipy_user_conf.py will determine this
+# Load all of $PATH as aliases
+__IPYTHON__.magic_rehashx()
+
+# Remove %sc,%sx if present as aliases
+__IPYTHON__.magic_unalias('sc')
+__IPYTHON__.magic_unalias('sx')
+
+# We need different criteria for line-splitting, so that aliases such as
+# 'gnome-terminal' are interpreted as a single alias instead of variable
+# 'gnome' minus variable 'terminal'.
+import re
+__IPYTHON__.line_split = re.compile(r'^([\s*,;/])'
+                                    r'([\?\w\.\-\+]+\w*\s*)'
+                                    r'(\(?.*$)')
+
+# Namespace cleanup
+del re

IPython/Extensions/InterpreterPasteInput.py

@@ -1,122 +1,122 b''
-# -*- coding: utf-8 -*-
-"""Modified input prompt for entering text with >>> or ... at the start.
-
-We define a special input line filter to allow typing lines which begin with
-'>>> ' or '... '. These two strings, if present at the start of the input
-line, are stripped. This allows for direct pasting of code from examples such
-as those available in the standard Python tutorial.
-
-Normally pasting such code is one chunk is impossible because of the
-extraneous >>> and ..., requiring one to do a line by line paste with careful
-removal of those characters. This module allows pasting that kind of
-multi-line examples in one pass.
-
-Here is an 'screenshot' of a section of the tutorial pasted into IPython with
-this feature enabled:
-
-In [1]: >>> def fib2(n): # return Fibonacci series up to n
-   ...: ...     '''Return a list containing the Fibonacci series up to n.'''
-   ...: ...     result = []
-   ...: ...     a, b = 0, 1
-   ...: ...     while b < n:
-   ...: ...         result.append(b)    # see below
-   ...: ...         a, b = b, a+b
-   ...: ...     return result
-   ...:
-
-In [2]: fib2(10)
-Out[2]: [1, 1, 2, 3, 5, 8]
-
-The >>> and ... are stripped from the input so that the python interpreter
-only sees the real part of the code.
-
-All other input is processed normally.
-
-Notes
-=====
-
-* You can even paste code that has extra initial spaces, such as is common in
-doctests:
-
-In [3]:     >>> a = ['Mary', 'had', 'a', 'little', 'lamb']
-
-In [4]:     >>> for i in range(len(a)):
-   ...:         ...     print i, a[i]
-   ...:     ...
-0 Mary
-1 had
-2 a
-3 little
-4 lamb
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-from IPython import Release
-__author__  = '%s <%s>' % Release.authors['Fernando']
-__license__ = Release.license
-
-# This file is an example of how to modify IPython's line-processing behavior
-# without touching the internal code. We'll define an alternate pre-processing
-# stage which allows a special form of input (which is invalid Python syntax)
-# for certain quantities, rewrites a line of proper Python in those cases, and
-# then passes it off to IPython's normal processor for further work.
-
-# With this kind of customization, IPython can be adapted for many
-# special-purpose scenarios providing alternate input syntaxes.
-
-# This file can be imported like a regular module.
-
-# IPython has a prefilter() function that analyzes each input line. We redefine
-# it here to first pre-process certain forms of input
-
-# The prototype of any alternate prefilter must be like this one (the name
-# doesn't matter):
-# - line is a string containing the user input line.
-# - continuation is a parameter which tells us if we are processing a first
-# line of user input or the second or higher of a multi-line statement.
-
-import re
-
-from IPython.iplib import InteractiveShell
-
-PROMPT_RE = re.compile(r'(^[ \t]*>>> |^[ \t]*\.\.\. )')
-
-def prefilter_paste(self,line,continuation):
-    """Alternate prefilter for input of pasted code from an interpreter.
-    """
-    if not line:
-        return ''
-    m = PROMPT_RE.match(line)
-    if m:
-        # In the end, always call the default IPython _prefilter() function.
-        # Note that self must be passed explicitly, b/c we're calling the
-        # unbound class method (since this method will overwrite the instance
-        # prefilter())
-        return self._prefilter(line[len(m.group(0)):],continuation)
-    elif line.strip() == '...':
-        return self._prefilter('',continuation)
-    elif line.isspace():
-        # This allows us to recognize multiple input prompts separated by blank
-        # lines and pasted in a single chunk, very common when pasting doctests
-        # or long tutorial passages.
-        return ''
-    else:
-        return self._prefilter(line,continuation)
-
-def activate_prefilter():
-    """Rebind the input-pasting filter to be the new IPython prefilter"""
-    InteractiveShell.prefilter = prefilter_paste
-
-def deactivate_prefilter():
-    """Reset the filter."""
-    InteractiveShell.prefilter = InteractiveShell._prefilter
-
-# Just a heads up at the console
-activate_prefilter()
-print '*** Pasting of code with ">>>" or "..." has been enabled.'
+# -*- coding: utf-8 -*-
+"""Modified input prompt for entering text with >>> or ... at the start.
+
+We define a special input line filter to allow typing lines which begin with
+'>>> ' or '... '. These two strings, if present at the start of the input
+line, are stripped. This allows for direct pasting of code from examples such
+as those available in the standard Python tutorial.
+
+Normally pasting such code is one chunk is impossible because of the
+extraneous >>> and ..., requiring one to do a line by line paste with careful
+removal of those characters. This module allows pasting that kind of
+multi-line examples in one pass.
+
+Here is an 'screenshot' of a section of the tutorial pasted into IPython with
+this feature enabled:
+
+In [1]: >>> def fib2(n): # return Fibonacci series up to n
+   ...: ...     '''Return a list containing the Fibonacci series up to n.'''
+   ...: ...     result = []
+   ...: ...     a, b = 0, 1
+   ...: ...     while b < n:
+   ...: ...         result.append(b)    # see below
+   ...: ...         a, b = b, a+b
+   ...: ...     return result
+   ...:
+
+In [2]: fib2(10)
+Out[2]: [1, 1, 2, 3, 5, 8]
+
+The >>> and ... are stripped from the input so that the python interpreter
+only sees the real part of the code.
+
+All other input is processed normally.
+
+Notes
+=====
+
+* You can even paste code that has extra initial spaces, such as is common in
+doctests:
+
+In [3]:     >>> a = ['Mary', 'had', 'a', 'little', 'lamb']
+
+In [4]:     >>> for i in range(len(a)):
+   ...:         ...     print i, a[i]
+   ...:     ...
+0 Mary
+1 had
+2 a
+3 little
+4 lamb
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+from IPython import Release
+__author__  = '%s <%s>' % Release.authors['Fernando']
+__license__ = Release.license
+
+# This file is an example of how to modify IPython's line-processing behavior
+# without touching the internal code. We'll define an alternate pre-processing
+# stage which allows a special form of input (which is invalid Python syntax)
+# for certain quantities, rewrites a line of proper Python in those cases, and
+# then passes it off to IPython's normal processor for further work.
+
+# With this kind of customization, IPython can be adapted for many
+# special-purpose scenarios providing alternate input syntaxes.
+
+# This file can be imported like a regular module.
+
+# IPython has a prefilter() function that analyzes each input line. We redefine
+# it here to first pre-process certain forms of input
+
+# The prototype of any alternate prefilter must be like this one (the name
+# doesn't matter):
+# - line is a string containing the user input line.
+# - continuation is a parameter which tells us if we are processing a first
+# line of user input or the second or higher of a multi-line statement.
+
+import re
+
+from IPython.iplib import InteractiveShell
+
+PROMPT_RE = re.compile(r'(^[ \t]*>>> |^[ \t]*\.\.\. )')
+
+def prefilter_paste(self,line,continuation):
+    """Alternate prefilter for input of pasted code from an interpreter.
+    """
+    if not line:
+        return ''
+    m = PROMPT_RE.match(line)
+    if m:
+        # In the end, always call the default IPython _prefilter() function.
+        # Note that self must be passed explicitly, b/c we're calling the
+        # unbound class method (since this method will overwrite the instance
+        # prefilter())
+        return self._prefilter(line[len(m.group(0)):],continuation)
+    elif line.strip() == '...':
+        return self._prefilter('',continuation)
+    elif line.isspace():
+        # This allows us to recognize multiple input prompts separated by blank
+        # lines and pasted in a single chunk, very common when pasting doctests
+        # or long tutorial passages.
+        return ''
+    else:
+        return self._prefilter(line,continuation)
+
+def activate_prefilter():
+    """Rebind the input-pasting filter to be the new IPython prefilter"""
+    InteractiveShell.prefilter = prefilter_paste
+
+def deactivate_prefilter():
+    """Reset the filter."""
+    InteractiveShell.prefilter = InteractiveShell._prefilter
+
+# Just a heads up at the console
+activate_prefilter()
+print '*** Pasting of code with ">>>" or "..." has been enabled.'

IPython/Extensions/PhysicalQInput.py

@@ -1,83 +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.'
+# -*- 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

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

@@ -1,13 +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 ='.
-"""
+# -*- 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/igrid_help.html

@@ -1,86 +1,86 b''
-<?xml version='1.0' encoding='iso-8859-1'?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-<link rel="stylesheet" href="igrid_help.css" type="text/css" />
-<title>igrid help</title>
-</head>
-<body>
-<h1>igrid help</h1>
-
-
-<h2>Commands</h2>
-
-
-<h3>pick (P)</h3>
-<p>Pick the whole row (object is available as "_")</p>
-
-<h3>pickattr (Shift-P)</h3>
-<p>Pick the attribute under the cursor</p>
-
-<h3>pickallattrs (Shift-C)</h3>
-<p>Pick' the complete column under the cursor (i.e. the attribute under the
-cursor) from all currently fetched objects. These attributes will be returned
-as a list.</p>
-
-<h3>enter (E)</h3>
-<p>Enter the object under the cursor. (what this mean depends on the object
-itself, i.e. how it implements iteration). This opens a new browser 'level'.</p>
-
-<h3>enterattr (Shift-E)</h3>
-<p>Enter the attribute under the cursor.</p>
-
-<h3>detail (D)</h3>
-<p>Show a detail view of the object under the cursor. This shows the name,
-type, doc string and value of the object attributes (and it might show more
-attributes than in the list view, depending on the object).</p>
-
-<h3>detailattr (Shift-D)</h3>
-<p>Show a detail view of the attribute under the cursor.</p>
-
-<h3>pickrows (M)</h3>
-<p>Pick multiple selected rows (M)</p>
-
-<h3>pickrowsattr (CTRL-M)</h3>
-<p>From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)</p>
-
-<h3>find (CTRL-F)</h3>
-<p>Find text</p>
-
-<h3>find_next (F3)</h3>
-<p>Find next occurrence of the searchtext</p>
-
-<h3>find_previous (Shift-F3)</h3>
-<p>Find previous occurrence of the searchtext </p>
-
-<h3>sortattrasc (V)</h3>
-<p>Sort the objects (in ascending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>sortattrdesc (Shift-V)</h3>
-<p>Sort the objects (in descending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>leave (Backspace, DEL, X)</h3>
-<p>Close current tab (and all the tabs to the right of the current one).</h3>
-
-<h3>quit (ESC,Q)</h3>
-<p>Quit igrid and return to the IPython prompt.</p>
-
-
-<h2>Navigation</h2>
-
-
-<h3>Jump to the last column of the current row (END, CTRL-E, CTRL-Right)</h3>
-
-<h3>Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)</h3>
-
-<h3>Move the cursor one column to the left (&lt;)</h3>
-
-<h3>Move the cursor one column to the right (&gt;)</h3>
-
-<h3>Jump to the first row in the current column (CTRL-Up)</h3>
-
-<h3>Jump to the last row in the current column (CTRL-Down)</h3>
-
-</body>
-</html>
+<?xml version='1.0' encoding='iso-8859-1'?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+<link rel="stylesheet" href="igrid_help.css" type="text/css" />
+<title>igrid help</title>
+</head>
+<body>
+<h1>igrid help</h1>
+
+
+<h2>Commands</h2>
+
+
+<h3>pick (P)</h3>
+<p>Pick the whole row (object is available as "_")</p>
+
+<h3>pickattr (Shift-P)</h3>
+<p>Pick the attribute under the cursor</p>
+
+<h3>pickallattrs (Shift-C)</h3>
+<p>Pick' the complete column under the cursor (i.e. the attribute under the
+cursor) from all currently fetched objects. These attributes will be returned
+as a list.</p>
+
+<h3>enter (E)</h3>
+<p>Enter the object under the cursor. (what this mean depends on the object
+itself, i.e. how it implements iteration). This opens a new browser 'level'.</p>
+
+<h3>enterattr (Shift-E)</h3>
+<p>Enter the attribute under the cursor.</p>
+
+<h3>detail (D)</h3>
+<p>Show a detail view of the object under the cursor. This shows the name,
+type, doc string and value of the object attributes (and it might show more
+attributes than in the list view, depending on the object).</p>
+
+<h3>detailattr (Shift-D)</h3>
+<p>Show a detail view of the attribute under the cursor.</p>
+
+<h3>pickrows (M)</h3>
+<p>Pick multiple selected rows (M)</p>
+
+<h3>pickrowsattr (CTRL-M)</h3>
+<p>From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)</p>
+
+<h3>find (CTRL-F)</h3>
+<p>Find text</p>
+
+<h3>find_next (F3)</h3>
+<p>Find next occurrence of the searchtext</p>
+
+<h3>find_previous (Shift-F3)</h3>
+<p>Find previous occurrence of the searchtext </p>
+
+<h3>sortattrasc (V)</h3>
+<p>Sort the objects (in ascending order) using the attribute under the cursor as the sort key.</p>
+
+<h3>sortattrdesc (Shift-V)</h3>
+<p>Sort the objects (in descending order) using the attribute under the cursor as the sort key.</p>
+
+<h3>leave (Backspace, DEL, X)</h3>
+<p>Close current tab (and all the tabs to the right of the current one).</h3>
+
+<h3>quit (ESC,Q)</h3>
+<p>Quit igrid and return to the IPython prompt.</p>
+
+
+<h2>Navigation</h2>
+
+
+<h3>Jump to the last column of the current row (END, CTRL-E, CTRL-Right)</h3>
+
+<h3>Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)</h3>
+
+<h3>Move the cursor one column to the left (&lt;)</h3>
+
+<h3>Move the cursor one column to the right (&gt;)</h3>
+
+<h3>Jump to the first row in the current column (CTRL-Up)</h3>
+
+<h3>Jump to the last row in the current column (CTRL-Down)</h3>
+
+</body>
+</html>

IPython/Extensions/ipy_leo.py

@@ -1,575 +1,575 b''
-""" ILeo - Leo plugin for IPython
-
-   
-"""
-import IPython.ipapi
-import IPython.genutils
-import IPython.generics
-from IPython.hooks import CommandChainDispatcher
-import re
-import UserDict
-from IPython.ipapi import TryNext 
-import IPython.macro
-
-def init_ipython(ipy):
-    """ This will be run by _ip.load('ipy_leo') 
-    
-    Leo still needs to run update_commander() after this.
-    
-    """
-    global ip
-    ip = ipy
-    ip.set_hook('complete_command', mb_completer, str_key = '%mb')
-    ip.expose_magic('mb',mb_f)
-    ip.expose_magic('lee',lee_f)
-    ip.expose_magic('leoref',leoref_f)
-    expose_ileo_push(push_cl_node,100)
-    # this should be the LAST one that will be executed, and it will never raise TryNext
-    expose_ileo_push(push_ipython_script, 1000)
-    expose_ileo_push(push_plain_python, 100)
-    expose_ileo_push(push_ev_node, 100)
-    global wb
-    wb = LeoWorkbook()
-    ip.user_ns['wb'] = wb 
-    
-    show_welcome()
-
-
-def update_commander(new_leox):
-    """ Set the Leo commander to use
-    
-    This will be run every time Leo does ipython-launch; basically,
-    when the user switches the document he is focusing on, he should do
-    ipython-launch to tell ILeo what document the commands apply to.
-    
-    """
-    
-    global c,g
-    c,g = new_leox.c, new_leox.g
-    print "Set Leo Commander:",c.frame.getTitle()
-    
-    # will probably be overwritten by user, but handy for experimentation early on
-    ip.user_ns['c'] = c
-    ip.user_ns['g'] = g
-    ip.user_ns['_leo'] = new_leox
-    
-    new_leox.push = push_position_from_leo
-    run_leo_startup_node()
-
-from IPython.external.simplegeneric import generic 
-import pprint
-
-def es(s):    
-    g.es(s, tabName = 'IPython')
-    pass
-
-@generic
-def format_for_leo(obj):
-    """ Convert obj to string representiation (for editing in Leo)"""
-    return pprint.pformat(obj)
-
-@format_for_leo.when_type(list)
-def format_list(obj):
-    return "\n".join(str(s) for s in obj)
-  
-
-attribute_re = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*$')
-def valid_attribute(s):
-    return attribute_re.match(s)    
-
-_rootnode = None
-def rootnode():
-    """ Get ileo root node (@ipy-root) 
-    
-    if node has become invalid or has not been set, return None
-    
-    Note that the root is the *first* @ipy-root item found    
-    """
-    global _rootnode
-    if _rootnode is None:
-        return None
-    if c.positionExists(_rootnode.p):
-        return _rootnode
-    _rootnode = None
-    return None  
-
-def all_cells():
-    global _rootnode
-    d = {}
-    r = rootnode() 
-    if r is not None:
-        nodes = r.p.children_iter()
-    else:
-        nodes = c.allNodes_iter()
-
-    for p in nodes:
-        h = p.headString()
-        if h.strip() == '@ipy-root':
-            # update root node (found it for the first time)
-            _rootnode = LeoNode(p)            
-            # the next recursive call will use the children of new root
-            return all_cells()
-        
-        if h.startswith('@a '):
-            d[h.lstrip('@a ').strip()] = p.parent().copy()
-        elif not valid_attribute(h):
-            continue 
-        d[h] = p.copy()
-    return d    
-
-def eval_node(n):
-    body = n.b    
-    if not body.startswith('@cl'):
-        # plain python repr node, just eval it
-        return ip.ev(n.b)
-    # @cl nodes deserve special treatment - first eval the first line (minus cl), then use it to call the rest of body
-    first, rest = body.split('\n',1)
-    tup = first.split(None, 1)
-    # @cl alone SPECIAL USE-> dump var to user_ns
-    if len(tup) == 1:
-        val = ip.ev(rest)
-        ip.user_ns[n.h] = val
-        es("%s = %s" % (n.h, repr(val)[:20]  )) 
-        return val
-
-    cl, hd = tup 
-
-    xformer = ip.ev(hd.strip())
-    es('Transform w/ %s' % repr(xformer))
-    return xformer(rest, n)
-
-class LeoNode(object, UserDict.DictMixin):
-    """ Node in Leo outline
-    
-    Most important attributes (getters/setters available:
-     .v     - evaluate node, can also be alligned 
-     .b, .h - body string, headline string
-     .l     - value as string list
-    
-    Also supports iteration, 
-    
-    setitem / getitem (indexing):  
-     wb.foo['key'] = 12
-     assert wb.foo['key'].v == 12
-    
-    Note the asymmetry on setitem and getitem! Also other
-    dict methods are available. 
-    
-    .ipush() - run push-to-ipython
-
-    Minibuffer command access (tab completion works):
-    
-     mb save-to-file
-    
-    """
-    def __init__(self,p):
-        self.p = p.copy()
-
-    def __str__(self):
-        return "<LeoNode %s>" % str(self.p)
-    
-    __repr__ = __str__
-    
-    def __get_h(self): return self.p.headString()
-    def __set_h(self,val):
-        print "set head",val
-        c.beginUpdate() 
-        try:
-            c.setHeadString(self.p,val)
-        finally:
-            c.endUpdate()
-        
-    h = property( __get_h, __set_h, doc = "Node headline string")  
-
-    def __get_b(self): return self.p.bodyString()
-    def __set_b(self,val):
-        print "set body",val
-        c.beginUpdate()
-        try: 
-            c.setBodyString(self.p, val)
-        finally:
-            c.endUpdate()
-    
-    b = property(__get_b, __set_b, doc = "Nody body string")
-    
-    def __set_val(self, val):        
-        self.b = format_for_leo(val)
-        
-    v = property(lambda self: eval_node(self), __set_val, doc = "Node evaluated value")
-    
-    def __set_l(self,val):
-        self.b = '\n'.join(val )
-    l = property(lambda self : IPython.genutils.SList(self.b.splitlines()), 
-                 __set_l, doc = "Node value as string list")
-    
-    def __iter__(self):
-        """ Iterate through nodes direct children """
-        
-        return (LeoNode(p) for p in self.p.children_iter())
-
-    def __children(self):
-        d = {}
-        for child in self:
-            head = child.h
-            tup = head.split(None,1)
-            if len(tup) > 1 and tup[0] == '@k':
-                d[tup[1]] = child
-                continue
-            
-            if not valid_attribute(head):
-                d[head] = child
-                continue
-        return d
-    def keys(self):
-        d = self.__children()
-        return d.keys()
-    def __getitem__(self, key):
-        """ wb.foo['Some stuff'] Return a child node with headline 'Some stuff'
-        
-        If key is a valid python name (e.g. 'foo'), look for headline '@k foo' as well
-        """  
-        key = str(key)
-        d = self.__children()
-        return d[key]
-    def __setitem__(self, key, val):
-        """ You can do wb.foo['My Stuff'] = 12 to create children 
-        
-        This will create 'My Stuff' as a child of foo (if it does not exist), and 
-        do .v = 12 assignment.
-        
-        Exception:
-        
-        wb.foo['bar'] = 12
-        
-        will create a child with headline '@k bar', because bar is a valid python name
-        and we don't want to crowd the WorkBook namespace with (possibly numerous) entries
-        """
-        key = str(key)
-        d = self.__children()
-        if key in d:
-            d[key].v = val
-            return
-        
-        if not valid_attribute(key):
-            head = key
-        else:
-            head = '@k ' + key
-        p = c.createLastChildNode(self.p, head, '')
-        LeoNode(p).v = val
-        
-    def ipush(self):
-        """ Does push-to-ipython on the node """
-        push_from_leo(self)
-        
-    def go(self):
-        """ Set node as current node (to quickly see it in Outline) """
-        c.beginUpdate()
-        try:
-            c.setCurrentPosition(self.p)
-        finally:
-            c.endUpdate()  
-        
-    def script(self):
-        """ Method to get the 'tangled' contents of the node
-        
-        (parse @others, << section >> references etc.)
-        """
-        return g.getScript(c,self.p,useSelectedText=False,useSentinels=False)
-    
-    def __get_uA(self):
-        p = self.p
-        # Create the uA if necessary.
-        if not hasattr(p.v.t,'unknownAttributes'):
-            p.v.t.unknownAttributes = {}        
-        
-        d = p.v.t.unknownAttributes.setdefault('ipython', {})
-        return d        
-    
-    uA = property(__get_uA, doc = "Access persistent unknownAttributes of node")
-        
-
-class LeoWorkbook:
-    """ class for 'advanced' node access 
-    
-    Has attributes for all "discoverable" nodes. Node is discoverable if it 
-    either
-    
-    - has a valid python name (Foo, bar_12)
-    - is a parent of an anchor node (if it has a child '@a foo', it is visible as foo)
-    
-    """
-    def __getattr__(self, key):
-        if key.startswith('_') or key == 'trait_names' or not valid_attribute(key):
-            raise AttributeError
-        cells = all_cells()
-        p = cells.get(key, None)
-        if p is None:
-            return add_var(key)
-
-        return LeoNode(p)
-
-    def __str__(self):
-        return "<LeoWorkbook>"
-    def __setattr__(self,key, val):
-        raise AttributeError("Direct assignment to workbook denied, try wb.%s.v = %s" % (key,val))
-        
-    __repr__ = __str__
-    
-    def __iter__(self):
-        """ Iterate all (even non-exposed) nodes """
-        cells = all_cells()
-        return (LeoNode(p) for p in c.allNodes_iter())
-    
-    current = property(lambda self: LeoNode(c.currentPosition()), doc = "Currently selected node")
-    
-    def match_h(self, regex):
-        cmp = re.compile(regex)
-        for node in self:
-            if re.match(cmp, node.h, re.IGNORECASE):
-                yield node
-        return
-
[e-mail]_object.when_type(LeoWorkbook)
-def workbook_complete(obj, prev):
-    return all_cells().keys() + [s for s in prev if not s.startswith('_')]
-    
-
-def add_var(varname):
-    c.beginUpdate()
-    r = rootnode()
-    try:
-        if r is None:
-            p2 = g.findNodeAnywhere(c,varname)
-        else:
-            p2 = g.findNodeInChildren(c, r.p, varname)
-        if p2:
-            return LeoNode(p2)
-
-        if r is not None:
-            p2 = r.p.insertAsLastChild()
-        
-        else:
-            p2 =  c.currentPosition().insertAfter()
-        
-        c.setHeadString(p2,varname)
-        return LeoNode(p2)
-    finally:
-        c.endUpdate()
-
-def add_file(self,fname):
-    p2 = c.currentPosition().insertAfter()
-
-push_from_leo = CommandChainDispatcher()
-
-def expose_ileo_push(f, prio = 0):
-    push_from_leo.add(f, prio)
-
-def push_ipython_script(node):
-    """ Execute the node body in IPython, as if it was entered in interactive prompt """
-    c.beginUpdate()
-    try:
-        ohist = ip.IP.output_hist 
-        hstart = len(ip.IP.input_hist)
-        script = node.script()
-        
-        script = g.splitLines(script + '\n')
-        ip.user_ns['_p'] = node
-        ip.runlines(script)
-        ip.user_ns.pop('_p',None)
-        
-        has_output = False
-        for idx in range(hstart,len(ip.IP.input_hist)):
-            val = ohist.get(idx,None)
-            if val is None:
-                continue
-            has_output = True
-            inp = ip.IP.input_hist[idx]
-            if inp.strip():
-                es('In: %s' % (inp[:40], ))
-                
-            es('<%d> %s' % (idx, pprint.pformat(ohist[idx],width = 40)))
-        
-        if not has_output:
-            es('ipy run: %s (%d LL)' %( node.h,len(script)))
-    finally:
-        c.endUpdate()
-
-    
-def eval_body(body):
-    try:
-        val = ip.ev(body)
-    except:
-        # just use stringlist if it's not completely legal python expression
-        val = IPython.genutils.SList(body.splitlines())
-    return val 
-    
-def push_plain_python(node):
-    if not node.h.endswith('P'):
-        raise TryNext
-    script = node.script()
-    lines = script.count('\n')
-    try:
-        exec script in ip.user_ns
-    except:
-        print " -- Exception in script:\n"+script + "\n --"
-        raise
-    es('ipy plain: %s (%d LL)' % (node.h,lines))
-    
-
-def push_cl_node(node):
-    """ If node starts with @cl, eval it
-    
-    The result is put as last child of @ipy-results node, if it exists
-    """
-    if not node.b.startswith('@cl'):
-        raise TryNext
-        
-    p2 = g.findNodeAnywhere(c,'@ipy-results')
-    val = node.v
-    if p2:
-        es("=> @ipy-results")
-        LeoNode(p2).v = val
-    es(val)
-
-def push_ev_node(node):
-    """ If headline starts with @ev, eval it and put result in body """
-    if not node.h.startswith('@ev '):
-        raise TryNext
-    expr = node.h.lstrip('@ev ')
-    es('ipy eval ' + expr)
-    res = ip.ev(expr)
-    node.v = res
-    
-    
-def push_position_from_leo(p):
-    push_from_leo(LeoNode(p))         
-
-@generic
-def edit_object_in_leo(obj, varname):
-    """ Make it @cl node so it can be pushed back directly by alt+I """
-    node = add_var(varname)
-    formatted = format_for_leo(obj)
-    if not formatted.startswith('@cl'):
-        formatted = '@cl\n' + formatted
-    node.b = formatted 
-    node.go()
-    
-@edit_object_in_leo.when_type(IPython.macro.Macro)
-def edit_macro(obj,varname):
-    bod = '_ip.defmacro("""\\\n' + obj.value + '""")'
-    node = add_var('Macro_' + varname)
-    node.b = bod
-    node.go()
-
-def get_history(hstart = 0):
-    res = []
-    ohist = ip.IP.output_hist 
-
-    for idx in range(hstart, len(ip.IP.input_hist)):
-        val = ohist.get(idx,None)
-        has_output = True
-        inp = ip.IP.input_hist_raw[idx]
-        if inp.strip():
-            res.append('In [%d]: %s' % (idx, inp))
-        if val:
-            res.append(pprint.pformat(val))
-            res.append('\n')    
-    return ''.join(res)
-    
-    
-def lee_f(self,s):
-    """ Open file(s)/objects in Leo
-    
-    - %lee hist -> open full session history in leo
-    - Takes an object
-    - Takes an mglob pattern, e.g. '%lee *.cpp' or %leo 'rec:*.cpp'  
-    """
-    import os
-    
-    c.beginUpdate()
-    try:
-        if s == 'hist':
-            wb.ipython_history.b = get_history()
-            wb.ipython_history.go()
-            return
-        
-            
-        
-        # try editing the object directly
-        obj = ip.user_ns.get(s, None)
-        if obj is not None:
-            edit_object_in_leo(obj,s)
-            return
-        
-        # if it's not object, it's a file name / mglob pattern
-        from IPython.external import mglob
-        
-        files = (os.path.abspath(f) for f in mglob.expand(s))
-        for fname in files:
-            p = g.findNodeAnywhere(c,'@auto ' + fname)
-            if not p:
-                p = c.currentPosition().insertAfter()
-            
-            p.setHeadString('@auto ' + fname)
-            if os.path.isfile(fname):
-                c.setBodyString(p,open(fname).read())
-            c.selectPosition(p)
-        print "Editing file(s), press ctrl+shift+w in Leo to write @auto nodes"
-    finally:
-        c.endUpdate()
-
-
-
-def leoref_f(self,s):
-    """ Quick reference for ILeo """
-    import textwrap
-    print textwrap.dedent("""\
-    %leoe file/object - open file / object in leo
-    wb.foo.v  - eval node foo (i.e. headstring is 'foo' or '@ipy foo')
-    wb.foo.v = 12 - assign to body of node foo
-    wb.foo.b - read or write the body of node foo
-    wb.foo.l - body of node foo as string list
-    
-    for el in wb.foo:
-      print el.v
-       
-    """
-    )
-
-
-
-def mb_f(self, arg):
-    """ Execute leo minibuffer commands 
-    
-    Example:
-     mb save-to-file
-    """
-    c.executeMinibufferCommand(arg)
-
-def mb_completer(self,event):
-    """ Custom completer for minibuffer """
-    cmd_param = event.line.split()
-    if event.line.endswith(' '):
-        cmd_param.append('')
-    if len(cmd_param) > 2:
-        return ip.IP.Completer.file_matches(event.symbol)
-    cmds = c.commandsDict.keys()
-    cmds.sort()
-    return cmds
-
-def show_welcome():
-    print "------------------"
-    print "Welcome to Leo-enabled IPython session!"
-    print "Try %leoref for quick reference."
-    import IPython.platutils
-    IPython.platutils.set_term_title('ILeo')
-    IPython.platutils.freeze_term_title()
-
-def run_leo_startup_node():
-    p = g.findNodeAnywhere(c,'@ipy-startup')
-    if p:
-        print "Running @ipy-startup nodes"
-        for n in LeoNode(p):
-            push_from_leo(n)
-            
-
+""" ILeo - Leo plugin for IPython
+
+   
+"""
+import IPython.ipapi
+import IPython.genutils
+import IPython.generics
+from IPython.hooks import CommandChainDispatcher
+import re
+import UserDict
+from IPython.ipapi import TryNext 
+import IPython.macro
+
+def init_ipython(ipy):
+    """ This will be run by _ip.load('ipy_leo') 
+    
+    Leo still needs to run update_commander() after this.
+    
+    """
+    global ip
+    ip = ipy
+    ip.set_hook('complete_command', mb_completer, str_key = '%mb')
+    ip.expose_magic('mb',mb_f)
+    ip.expose_magic('lee',lee_f)
+    ip.expose_magic('leoref',leoref_f)
+    expose_ileo_push(push_cl_node,100)
+    # this should be the LAST one that will be executed, and it will never raise TryNext
+    expose_ileo_push(push_ipython_script, 1000)
+    expose_ileo_push(push_plain_python, 100)
+    expose_ileo_push(push_ev_node, 100)
+    global wb
+    wb = LeoWorkbook()
+    ip.user_ns['wb'] = wb 
+    
+    show_welcome()
+
+
+def update_commander(new_leox):
+    """ Set the Leo commander to use
+    
+    This will be run every time Leo does ipython-launch; basically,
+    when the user switches the document he is focusing on, he should do
+    ipython-launch to tell ILeo what document the commands apply to.
+    
+    """
+    
+    global c,g
+    c,g = new_leox.c, new_leox.g
+    print "Set Leo Commander:",c.frame.getTitle()
+    
+    # will probably be overwritten by user, but handy for experimentation early on
+    ip.user_ns['c'] = c
+    ip.user_ns['g'] = g
+    ip.user_ns['_leo'] = new_leox
+    
+    new_leox.push = push_position_from_leo
+    run_leo_startup_node()
+
+from IPython.external.simplegeneric import generic 
+import pprint
+
+def es(s):    
+    g.es(s, tabName = 'IPython')
+    pass
+
+@generic
+def format_for_leo(obj):
+    """ Convert obj to string representiation (for editing in Leo)"""
+    return pprint.pformat(obj)
+
+@format_for_leo.when_type(list)
+def format_list(obj):
+    return "\n".join(str(s) for s in obj)
+  
+
+attribute_re = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*$')
+def valid_attribute(s):
+    return attribute_re.match(s)    
+
+_rootnode = None
+def rootnode():
+    """ Get ileo root node (@ipy-root) 
+    
+    if node has become invalid or has not been set, return None
+    
+    Note that the root is the *first* @ipy-root item found    
+    """
+    global _rootnode
+    if _rootnode is None:
+        return None
+    if c.positionExists(_rootnode.p):
+        return _rootnode
+    _rootnode = None
+    return None  
+
+def all_cells():
+    global _rootnode
+    d = {}
+    r = rootnode() 
+    if r is not None:
+        nodes = r.p.children_iter()
+    else:
+        nodes = c.allNodes_iter()
+
+    for p in nodes:
+        h = p.headString()
+        if h.strip() == '@ipy-root':
+            # update root node (found it for the first time)
+            _rootnode = LeoNode(p)            
+            # the next recursive call will use the children of new root
+            return all_cells()
+        
+        if h.startswith('@a '):
+            d[h.lstrip('@a ').strip()] = p.parent().copy()
+        elif not valid_attribute(h):
+            continue 
+        d[h] = p.copy()
+    return d    
+
+def eval_node(n):
+    body = n.b    
+    if not body.startswith('@cl'):
+        # plain python repr node, just eval it
+        return ip.ev(n.b)
+    # @cl nodes deserve special treatment - first eval the first line (minus cl), then use it to call the rest of body
+    first, rest = body.split('\n',1)
+    tup = first.split(None, 1)
+    # @cl alone SPECIAL USE-> dump var to user_ns
+    if len(tup) == 1:
+        val = ip.ev(rest)
+        ip.user_ns[n.h] = val
+        es("%s = %s" % (n.h, repr(val)[:20]  )) 
+        return val
+
+    cl, hd = tup 
+
+    xformer = ip.ev(hd.strip())
+    es('Transform w/ %s' % repr(xformer))
+    return xformer(rest, n)
+
+class LeoNode(object, UserDict.DictMixin):
+    """ Node in Leo outline
+    
+    Most important attributes (getters/setters available:
+     .v     - evaluate node, can also be alligned 
+     .b, .h - body string, headline string
+     .l     - value as string list
+    
+    Also supports iteration, 
+    
+    setitem / getitem (indexing):  
+     wb.foo['key'] = 12
+     assert wb.foo['key'].v == 12
+    
+    Note the asymmetry on setitem and getitem! Also other
+    dict methods are available. 
+    
+    .ipush() - run push-to-ipython
+
+    Minibuffer command access (tab completion works):
+    
+     mb save-to-file
+    
+    """
+    def __init__(self,p):
+        self.p = p.copy()
+
+    def __str__(self):
+        return "<LeoNode %s>" % str(self.p)
+    
+    __repr__ = __str__
+    
+    def __get_h(self): return self.p.headString()
+    def __set_h(self,val):
+        print "set head",val
+        c.beginUpdate() 
+        try:
+            c.setHeadString(self.p,val)
+        finally:
+            c.endUpdate()
+        
+    h = property( __get_h, __set_h, doc = "Node headline string")  
+
+    def __get_b(self): return self.p.bodyString()
+    def __set_b(self,val):
+        print "set body",val
+        c.beginUpdate()
+        try: 
+            c.setBodyString(self.p, val)
+        finally:
+            c.endUpdate()
+    
+    b = property(__get_b, __set_b, doc = "Nody body string")
+    
+    def __set_val(self, val):        
+        self.b = format_for_leo(val)
+        
+    v = property(lambda self: eval_node(self), __set_val, doc = "Node evaluated value")
+    
+    def __set_l(self,val):
+        self.b = '\n'.join(val )
+    l = property(lambda self : IPython.genutils.SList(self.b.splitlines()), 
+                 __set_l, doc = "Node value as string list")
+    
+    def __iter__(self):
+        """ Iterate through nodes direct children """
+        
+        return (LeoNode(p) for p in self.p.children_iter())
+
+    def __children(self):
+        d = {}
+        for child in self:
+            head = child.h
+            tup = head.split(None,1)
+            if len(tup) > 1 and tup[0] == '@k':
+                d[tup[1]] = child
+                continue
+            
+            if not valid_attribute(head):
+                d[head] = child
+                continue
+        return d
+    def keys(self):
+        d = self.__children()
+        return d.keys()
+    def __getitem__(self, key):
+        """ wb.foo['Some stuff'] Return a child node with headline 'Some stuff'
+        
+        If key is a valid python name (e.g. 'foo'), look for headline '@k foo' as well
+        """  
+        key = str(key)
+        d = self.__children()
+        return d[key]
+    def __setitem__(self, key, val):
+        """ You can do wb.foo['My Stuff'] = 12 to create children 
+        
+        This will create 'My Stuff' as a child of foo (if it does not exist), and 
+        do .v = 12 assignment.
+        
+        Exception:
+        
+        wb.foo['bar'] = 12
+        
+        will create a child with headline '@k bar', because bar is a valid python name
+        and we don't want to crowd the WorkBook namespace with (possibly numerous) entries
+        """
+        key = str(key)
+        d = self.__children()
+        if key in d:
+            d[key].v = val
+            return
+        
+        if not valid_attribute(key):
+            head = key
+        else:
+            head = '@k ' + key
+        p = c.createLastChildNode(self.p, head, '')
+        LeoNode(p).v = val
+        
+    def ipush(self):
+        """ Does push-to-ipython on the node """
+        push_from_leo(self)
+        
+    def go(self):
+        """ Set node as current node (to quickly see it in Outline) """
+        c.beginUpdate()
+        try:
+            c.setCurrentPosition(self.p)
+        finally:
+            c.endUpdate()  
+        
+    def script(self):
+        """ Method to get the 'tangled' contents of the node
+        
+        (parse @others, << section >> references etc.)
+        """
+        return g.getScript(c,self.p,useSelectedText=False,useSentinels=False)
+    
+    def __get_uA(self):
+        p = self.p
+        # Create the uA if necessary.
+        if not hasattr(p.v.t,'unknownAttributes'):
+            p.v.t.unknownAttributes = {}        
+        
+        d = p.v.t.unknownAttributes.setdefault('ipython', {})
+        return d        
+    
+    uA = property(__get_uA, doc = "Access persistent unknownAttributes of node")
+        
+
+class LeoWorkbook:
+    """ class for 'advanced' node access 
+    
+    Has attributes for all "discoverable" nodes. Node is discoverable if it 
+    either
+    
+    - has a valid python name (Foo, bar_12)
+    - is a parent of an anchor node (if it has a child '@a foo', it is visible as foo)
+    
+    """
+    def __getattr__(self, key):
+        if key.startswith('_') or key == 'trait_names' or not valid_attribute(key):
+            raise AttributeError
+        cells = all_cells()
+        p = cells.get(key, None)
+        if p is None:
+            return add_var(key)
+
+        return LeoNode(p)
+
+    def __str__(self):
+        return "<LeoWorkbook>"
+    def __setattr__(self,key, val):
+        raise AttributeError("Direct assignment to workbook denied, try wb.%s.v = %s" % (key,val))
+        
+    __repr__ = __str__
+    
+    def __iter__(self):
+        """ Iterate all (even non-exposed) nodes """
+        cells = all_cells()
+        return (LeoNode(p) for p in c.allNodes_iter())
+    
+    current = property(lambda self: LeoNode(c.currentPosition()), doc = "Currently selected node")
+    
+    def match_h(self, regex):
+        cmp = re.compile(regex)
+        for node in self:
+            if re.match(cmp, node.h, re.IGNORECASE):
+                yield node
+        return
+
[e-mail]_object.when_type(LeoWorkbook)
+def workbook_complete(obj, prev):
+    return all_cells().keys() + [s for s in prev if not s.startswith('_')]
+    
+
+def add_var(varname):
+    c.beginUpdate()
+    r = rootnode()
+    try:
+        if r is None:
+            p2 = g.findNodeAnywhere(c,varname)
+        else:
+            p2 = g.findNodeInChildren(c, r.p, varname)
+        if p2:
+            return LeoNode(p2)
+
+        if r is not None:
+            p2 = r.p.insertAsLastChild()
+        
+        else:
+            p2 =  c.currentPosition().insertAfter()
+        
+        c.setHeadString(p2,varname)
+        return LeoNode(p2)
+    finally:
+        c.endUpdate()
+
+def add_file(self,fname):
+    p2 = c.currentPosition().insertAfter()
+
+push_from_leo = CommandChainDispatcher()
+
+def expose_ileo_push(f, prio = 0):
+    push_from_leo.add(f, prio)
+
+def push_ipython_script(node):
+    """ Execute the node body in IPython, as if it was entered in interactive prompt """
+    c.beginUpdate()
+    try:
+        ohist = ip.IP.output_hist 
+        hstart = len(ip.IP.input_hist)
+        script = node.script()
+        
+        script = g.splitLines(script + '\n')
+        ip.user_ns['_p'] = node
+        ip.runlines(script)
+        ip.user_ns.pop('_p',None)
+        
+        has_output = False
+        for idx in range(hstart,len(ip.IP.input_hist)):
+            val = ohist.get(idx,None)
+            if val is None:
+                continue
+            has_output = True
+            inp = ip.IP.input_hist[idx]
+            if inp.strip():
+                es('In: %s' % (inp[:40], ))
+                
+            es('<%d> %s' % (idx, pprint.pformat(ohist[idx],width = 40)))
+        
+        if not has_output:
+            es('ipy run: %s (%d LL)' %( node.h,len(script)))
+    finally:
+        c.endUpdate()
+
+    
+def eval_body(body):
+    try:
+        val = ip.ev(body)
+    except:
+        # just use stringlist if it's not completely legal python expression
+        val = IPython.genutils.SList(body.splitlines())
+    return val 
+    
+def push_plain_python(node):
+    if not node.h.endswith('P'):
+        raise TryNext
+    script = node.script()
+    lines = script.count('\n')
+    try:
+        exec script in ip.user_ns
+    except:
+        print " -- Exception in script:\n"+script + "\n --"
+        raise
+    es('ipy plain: %s (%d LL)' % (node.h,lines))
+    
+
+def push_cl_node(node):
+    """ If node starts with @cl, eval it
+    
+    The result is put as last child of @ipy-results node, if it exists
+    """
+    if not node.b.startswith('@cl'):
+        raise TryNext
+        
+    p2 = g.findNodeAnywhere(c,'@ipy-results')
+    val = node.v
+    if p2:
+        es("=> @ipy-results")
+        LeoNode(p2).v = val
+    es(val)
+
+def push_ev_node(node):
+    """ If headline starts with @ev, eval it and put result in body """
+    if not node.h.startswith('@ev '):
+        raise TryNext
+    expr = node.h.lstrip('@ev ')
+    es('ipy eval ' + expr)
+    res = ip.ev(expr)
+    node.v = res
+    
+    
+def push_position_from_leo(p):
+    push_from_leo(LeoNode(p))         
+
+@generic
+def edit_object_in_leo(obj, varname):
+    """ Make it @cl node so it can be pushed back directly by alt+I """
+    node = add_var(varname)
+    formatted = format_for_leo(obj)
+    if not formatted.startswith('@cl'):
+        formatted = '@cl\n' + formatted
+    node.b = formatted 
+    node.go()
+    
+@edit_object_in_leo.when_type(IPython.macro.Macro)
+def edit_macro(obj,varname):
+    bod = '_ip.defmacro("""\\\n' + obj.value + '""")'
+    node = add_var('Macro_' + varname)
+    node.b = bod
+    node.go()
+
+def get_history(hstart = 0):
+    res = []
+    ohist = ip.IP.output_hist 
+
+    for idx in range(hstart, len(ip.IP.input_hist)):
+        val = ohist.get(idx,None)
+        has_output = True
+        inp = ip.IP.input_hist_raw[idx]
+        if inp.strip():
+            res.append('In [%d]: %s' % (idx, inp))
+        if val:
+            res.append(pprint.pformat(val))
+            res.append('\n')    
+    return ''.join(res)
+    
+    
+def lee_f(self,s):
+    """ Open file(s)/objects in Leo
+    
+    - %lee hist -> open full session history in leo
+    - Takes an object
+    - Takes an mglob pattern, e.g. '%lee *.cpp' or %leo 'rec:*.cpp'  
+    """
+    import os
+    
+    c.beginUpdate()
+    try:
+        if s == 'hist':
+            wb.ipython_history.b = get_history()
+            wb.ipython_history.go()
+            return
+        
+            
+        
+        # try editing the object directly
+        obj = ip.user_ns.get(s, None)
+        if obj is not None:
+            edit_object_in_leo(obj,s)
+            return
+        
+        # if it's not object, it's a file name / mglob pattern
+        from IPython.external import mglob
+        
+        files = (os.path.abspath(f) for f in mglob.expand(s))
+        for fname in files:
+            p = g.findNodeAnywhere(c,'@auto ' + fname)
+            if not p:
+                p = c.currentPosition().insertAfter()
+            
+            p.setHeadString('@auto ' + fname)
+            if os.path.isfile(fname):
+                c.setBodyString(p,open(fname).read())
+            c.selectPosition(p)
+        print "Editing file(s), press ctrl+shift+w in Leo to write @auto nodes"
+    finally:
+        c.endUpdate()
+
+
+
+def leoref_f(self,s):
+    """ Quick reference for ILeo """
+    import textwrap
+    print textwrap.dedent("""\
+    %leoe file/object - open file / object in leo
+    wb.foo.v  - eval node foo (i.e. headstring is 'foo' or '@ipy foo')
+    wb.foo.v = 12 - assign to body of node foo
+    wb.foo.b - read or write the body of node foo
+    wb.foo.l - body of node foo as string list
+    
+    for el in wb.foo:
+      print el.v
+       
+    """
+    )
+
+
+
+def mb_f(self, arg):
+    """ Execute leo minibuffer commands 
+    
+    Example:
+     mb save-to-file
+    """
+    c.executeMinibufferCommand(arg)
+
+def mb_completer(self,event):
+    """ Custom completer for minibuffer """
+    cmd_param = event.line.split()
+    if event.line.endswith(' '):
+        cmd_param.append('')
+    if len(cmd_param) > 2:
+        return ip.IP.Completer.file_matches(event.symbol)
+    cmds = c.commandsDict.keys()
+    cmds.sort()
+    return cmds
+
+def show_welcome():
+    print "------------------"
+    print "Welcome to Leo-enabled IPython session!"
+    print "Try %leoref for quick reference."
+    import IPython.platutils
+    IPython.platutils.set_term_title('ILeo')
+    IPython.platutils.freeze_term_title()
+
+def run_leo_startup_node():
+    p = g.findNodeAnywhere(c,'@ipy-startup')
+    if p:
+        print "Running @ipy-startup nodes"
+        for n in LeoNode(p):
+            push_from_leo(n)
+            
+

IPython/Extensions/numeric_formats.py

@@ -1,43 +1,43 b''
-# -*- coding: utf-8 -*-
-"""
-Extension for printing Numeric Arrays in flexible ways.
-"""
-
-from Numeric import ArrayType
-
-def num_display(self,arg):
-    """Display method for printing which treats Numeric arrays specially.
-    """
-
-    # Non-numpy variables are printed using the system default
-    if type(arg) != ArrayType:
-        self._display(arg)
-        return
-    # Otherwise, we do work.
-    format = __IPYTHON__.runtime_rc.numarray_print_format
-    print 'NumPy array, format:',format
-    # Here is where all the printing logic needs to be implemented
-    print arg # nothing yet :)
-
-
-def magic_format(self,parameter_s=''):
-    """Specifies format of numerical output.
-
-    This command is similar to Ocave's format command.
-    """
-
-    valid_formats = ['long','short']
-    
-    if parameter_s in valid_formats:
-        self.runtime_rc.numarray_print_format = parameter_s
-        print 'Numeric output format is now:',parameter_s
-    else:
-        print 'Invalid format:',parameter_s
-        print 'Valid formats:',valid_formats
-
-# setup default format
-__IPYTHON__.runtime_rc.numarray_print_format = 'long'
-
-# Bind our new functions to the interpreter
-__IPYTHON__.__class__.magic_format = magic_format
-__IPYTHON__.hooks.display = num_display
+# -*- coding: utf-8 -*-
+"""
+Extension for printing Numeric Arrays in flexible ways.
+"""
+
+from Numeric import ArrayType
+
+def num_display(self,arg):
+    """Display method for printing which treats Numeric arrays specially.
+    """
+
+    # Non-numpy variables are printed using the system default
+    if type(arg) != ArrayType:
+        self._display(arg)
+        return
+    # Otherwise, we do work.
+    format = __IPYTHON__.runtime_rc.numarray_print_format
+    print 'NumPy array, format:',format
+    # Here is where all the printing logic needs to be implemented
+    print arg # nothing yet :)
+
+
+def magic_format(self,parameter_s=''):
+    """Specifies format of numerical output.
+
+    This command is similar to Ocave's format command.
+    """
+
+    valid_formats = ['long','short']
+    
+    if parameter_s in valid_formats:
+        self.runtime_rc.numarray_print_format = parameter_s
+        print 'Numeric output format is now:',parameter_s
+    else:
+        print 'Invalid format:',parameter_s
+        print 'Valid formats:',valid_formats
+
+# setup default format
+__IPYTHON__.runtime_rc.numarray_print_format = 'long'
+
+# Bind our new functions to the interpreter
+__IPYTHON__.__class__.magic_format = magic_format
+__IPYTHON__.hooks.display = num_display

IPython/FakeModule.py

@@ -1,43 +1,43 b''
-# -*- coding: utf-8 -*-
-"""
-Class which mimics a module.
-
-Needed to allow pickle to correctly resolve namespaces during IPython
-sessions.
-
-$Id: FakeModule.py 2754 2007-09-09 10:16:59Z fperez $"""
-
-#*****************************************************************************
-#       Copyright (C) 2002-2004 Fernando Perez. <[e-mail]>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-import types
-
-class FakeModule(types.ModuleType):
-    """Simple class with attribute access to fake a module.
-
-    This is not meant to replace a module, but to allow inserting a fake
-    module in sys.modules so that systems which rely on run-time module
-    importing (like shelve and pickle) work correctly in interactive IPython
-    sessions.
-
-    Do NOT use this code for anything other than this IPython private hack."""
-
-    def __init__(self,adict=None):
-        
-        # tmp to force __dict__ instance creation, else self.__dict__ fails
-        self.__iptmp = None
-        
-        # It seems pydoc (and perhaps others) needs any module instance to
-        # implement a __nonzero__ method, so we add it if missing:
-        self.__dict__.setdefault('__nonzero__',lambda : True)
-        self.__dict__.setdefault('__file__',__file__)
-
-        # cleanup our temp trick
-        del self.__iptmp
-
-        if adict is not None:
-            self.__dict__.update(adict)
+# -*- coding: utf-8 -*-
+"""
+Class which mimics a module.
+
+Needed to allow pickle to correctly resolve namespaces during IPython
+sessions.
+
+$Id: FakeModule.py 2754 2007-09-09 10:16:59Z fperez $"""
+
+#*****************************************************************************
+#       Copyright (C) 2002-2004 Fernando Perez. <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+import types
+
+class FakeModule(types.ModuleType):
+    """Simple class with attribute access to fake a module.
+
+    This is not meant to replace a module, but to allow inserting a fake
+    module in sys.modules so that systems which rely on run-time module
+    importing (like shelve and pickle) work correctly in interactive IPython
+    sessions.
+
+    Do NOT use this code for anything other than this IPython private hack."""
+
+    def __init__(self,adict=None):
+        
+        # tmp to force __dict__ instance creation, else self.__dict__ fails
+        self.__iptmp = None
+        
+        # It seems pydoc (and perhaps others) needs any module instance to
+        # implement a __nonzero__ method, so we add it if missing:
+        self.__dict__.setdefault('__nonzero__',lambda : True)
+        self.__dict__.setdefault('__file__',__file__)
+
+        # cleanup our temp trick
+        del self.__iptmp
+
+        if adict is not None:
+            self.__dict__.update(adict)

IPython/Gnuplot2.py

@@ -1,666 +1,666 b''
-# -*- coding: utf-8 -*-
-"""Improved replacement for the Gnuplot.Gnuplot class.
-
-This module imports Gnuplot and replaces some of its functionality with
-improved versions. They add better handling of arrays for plotting and more
-convenient PostScript generation, plus some fixes for hardcopy().
-
-It also adds a convenient plot2 method for plotting dictionaries and
-lists/tuples of arrays.
-
-This module is meant to be used as a drop-in replacement to the original
-Gnuplot, so it should be safe to do:
-
-import IPython.Gnuplot2 as Gnuplot
-
-$Id: Gnuplot2.py 1210 2006-03-13 01:19:31Z fperez $"""
-
-import cStringIO
-import os
-import string
-import sys
-import tempfile
-import time
-import types
-
-import Gnuplot as Gnuplot_ori
-import Numeric
-
-from IPython.genutils import popkey,xsys
-
-# needed by hardcopy():
-gp = Gnuplot_ori.gp
-
-# Patch for Gnuplot.py 1.6 compatibility.
-# Thanks to Hayden Callow <[e-mail]>
-try:
-    OptionException = Gnuplot_ori.PlotItems.OptionException
-except AttributeError:
-    OptionException = Gnuplot_ori.Errors.OptionError
-
-# exhibit a similar interface to Gnuplot so it can be somewhat drop-in
-Data      = Gnuplot_ori.Data
-Func      = Gnuplot_ori.Func
-GridData  = Gnuplot_ori.GridData
-PlotItem  = Gnuplot_ori.PlotItem
-PlotItems = Gnuplot_ori.PlotItems
-
-# Modify some of Gnuplot's functions with improved versions (or bugfixed, in
-# hardcopy's case). In order to preserve the docstrings at runtime, I've
-# copied them from the original code.
-
-# After some significant changes in v 1.7 of Gnuplot.py, we need to do a bit
-# of version checking.
-
-if Gnuplot_ori.__version__ <= '1.6':
-    _BaseFileItem = PlotItems.File
-    _BaseTempFileItem = PlotItems.TempFile
-
-    # Fix the File class to add the 'index' option for Gnuplot versions < 1.7
-    class File(_BaseFileItem):
-
-        _option_list = _BaseFileItem._option_list.copy()
-        _option_list.update({
-            'index' : lambda self, index: self.set_option_index(index),
-            })
-
-        # A new initializer is needed b/c we want to add a modified
-        # _option_sequence list which includes 'index' in the right place.
-        def __init__(self,*args,**kw):
-            self._option_sequence = ['binary', 'index', 'using', 'smooth', 'axes',
-                         'title', 'with']
-
-            _BaseFileItem.__init__(self,*args,**kw)
-
-        # Let's fix the constructor docstring
-        __newdoc = \
-            """Additional Keyword arguments added by IPython:
-
-             'index=<int>' -- similar to the `index` keyword in Gnuplot.
-                 This allows only some of the datasets in a file to be
-                 plotted. Datasets within a file are assumed to be separated
-                 by _pairs_ of blank lines, and the first one is numbered as
-                 0 (similar to C/Python usage)."""
-        __init__.__doc__ = PlotItems.File.__init__.__doc__ + __newdoc
-
-        def set_option_index(self, index):
-            if index is None:
-                self.clear_option('index')
-            elif type(index) in [type(''), type(1)]:
-                self._options['index'] = (index, 'index %s' % index)
-            elif type(index) is type(()):
-                self._options['index'] = (index,'index %s' %
-                                          string.join(map(repr, index), ':'))
-            else:
-                raise OptionException('index=%s' % (index,))
-
-    # We need a FileClass with a different name from 'File', which is a
-    # factory function in 1.7, so that our String class can subclass FileClass
-    # in any version.
-    _FileClass = File
-
-elif Gnuplot_ori.__version__ =='1.7':
-    _FileClass = _BaseFileItem = PlotItems._FileItem
-    _BaseTempFileItem = PlotItems._TempFileItem
-    File = PlotItems.File
-
-else:  # changes in the newer version (svn as of March'06)
-     _FileClass = _BaseFileItem = PlotItems._FileItem
-     _BaseTempFileItem = PlotItems._NewFileItem
-     File = PlotItems.File
-
-
-# Now, we can add our generic code which is version independent
-
-# First some useful utilities
-def eps_fix_bbox(fname):
-    """Fix the bounding box of an eps file by running ps2eps on it.
-
-    If its name ends in .eps, the original file is removed.
-
-    This is particularly useful for plots made by Gnuplot with square aspect
-    ratio: there is a bug in Gnuplot which makes it generate a bounding box
-    which is far wider than the actual plot.
-
-    This function assumes that ps2eps is installed in your system."""
-
-    # note: ps2ps and eps2eps do NOT work, ONLY ps2eps works correctly. The
-    # others make output with bitmapped fonts, which looks horrible.
-    print 'Fixing eps file: <%s>' % fname
-    xsys('ps2eps -f -q -l %s' % fname)
-    if fname.endswith('.eps'):
-        os.rename(fname+'.eps',fname)
-
-def is_list1d(x,containers = [types.ListType,types.TupleType]):
-    """Returns true if x appears to be a 1d list/tuple/array.
-
-    The heuristics are: identify Numeric arrays, or lists/tuples whose first
-    element is not itself a list/tuple. This way zipped lists should work like
-    the original Gnuplot. There's no inexpensive way to know if a list doesn't
-    have a composite object after its first element, so that kind of input
-    will produce an error. But it should work well in most cases.
-    """
-    x_type = type(x)
-
-    return x_type == Numeric.ArrayType and len(x.shape)==1 or \
-           (x_type in containers and
-            type(x[0]) not in containers + [Numeric.ArrayType])
-
-def zip_items(items,titles=None):
-    """zip together neighboring 1-d arrays, and zip standalone ones
-    with their index. Leave other plot items alone."""
-
-    class StandaloneItem(Exception): pass
-    
-    def get_titles(titles):
-        """Return the next title and the input titles array.
-
-        The input array may be changed to None when no titles are left to
-        prevent extra unnecessary calls to this function."""
-        
-        try:
-            title = titles[tit_ct[0]]  # tit_ct[0] is in zip_items'scope
-        except IndexError:
-            titles = None # so we don't enter again
-            title = None
-        else:
-            tit_ct[0] += 1
-        return title,titles
-
-    new_items = []
-
-    if titles:
-        # Initialize counter. It was put in a list as a hack to allow the
-        # nested get_titles to modify it without raising a NameError.
-        tit_ct = [0]
-
-    n = 0  # this loop needs to be done by hand
-    while n < len(items):
-        item = items[n]
-        try:
-            if is_list1d(item):
-                if n==len(items)-1: # last in list
-                    raise StandaloneItem
-                else: # check the next item and zip together if needed
-                    next_item = items[n+1]
-                    if next_item is None:
-                        n += 1
-                        raise StandaloneItem
-                    elif is_list1d(next_item):
-                        # this would be best done with an iterator
-                        if titles:
-                            title,titles = get_titles(titles)
-                        else:
-                            title = None
-                        new_items.append(Data(zip(item,next_item),
-                                              title=title))
-                        n += 1  # avoid double-inclusion of next item
-                    else: # can't zip with next, zip with own index list
-                        raise StandaloneItem
-            else:  # not 1-d array
-                new_items.append(item)
-        except StandaloneItem:
-            if titles:
-                title,titles = get_titles(titles)
-            else:
-                title = None
-            new_items.append(Data(zip(range(len(item)),item),title=title))
-        except AttributeError:
-            new_items.append(item)
-        n+=1
-
-    return new_items
-
-# And some classes with enhanced functionality.
-class String(_FileClass):
-    """Make a PlotItem from data in a string with the same format as a File.
-
-    This allows writing data directly inside python scripts using the exact
-    same format and manipulation options which would be used for external
-    files."""
-
-    def __init__(self, data_str, **keyw):
-        """Construct a String object.
-
-        <data_str> is a string formatted exactly like a valid Gnuplot data
-        file would be. All options from the File constructor are valid here.
-
-        Warning: when used for interactive plotting in scripts which exit
-        immediately, you may get an error because the temporary file used to
-        hold the string data was deleted before Gnuplot had a chance to see
-        it. You can work around this problem by putting a raw_input() call at
-        the end of the script.
-
-        This problem does not appear when generating PostScript output, only
-        with Gnuplot windows."""
-
-        self.tmpfile = _BaseTempFileItem()
-        tmpfile = file(self.tmpfile.filename,'w')
-        tmpfile.write(data_str)
-        _BaseFileItem.__init__(self,self.tmpfile,**keyw)
-
-
-class Gnuplot(Gnuplot_ori.Gnuplot):
-    """Improved Gnuplot class.
-
-    Enhancements: better plot,replot and hardcopy methods. New methods for
-    quick range setting.
-    """
-
-    def xrange(self,min='*',max='*'):
-        """Set xrange. If min/max is omitted, it is set to '*' (auto).
-
-        Note that this is different from the regular Gnuplot behavior, where
-        an unspecified limit means no change. Here any unspecified limit is
-        set to autoscaling, allowing these functions to be used for full
-        autoscaling when called with no arguments.
-
-        To preserve one limit's current value while changing the other, an
-        explicit '' argument must be given as the limit to be kept.
-
-        Similar functions exist for [y{2}z{2}rtuv]range."""
-        
-        self('set xrange [%s:%s]' % (min,max))
-             
-    def yrange(self,min='*',max='*'):
-        self('set yrange [%s:%s]' % (min,max))
-             
-    def zrange(self,min='*',max='*'):
-        self('set zrange [%s:%s]' % (min,max))
-             
-    def x2range(self,min='*',max='*'):
-        self('set xrange [%s:%s]' % (min,max))
-             
-    def y2range(self,min='*',max='*'):
-        self('set yrange [%s:%s]' % (min,max))
-             
-    def z2range(self,min='*',max='*'):
-        self('set zrange [%s:%s]' % (min,max))
-             
-    def rrange(self,min='*',max='*'):
-        self('set rrange [%s:%s]' % (min,max))
-             
-    def trange(self,min='*',max='*'):
-        self('set trange [%s:%s]' % (min,max))
-             
-    def urange(self,min='*',max='*'):
-        self('set urange [%s:%s]' % (min,max))
-             
-    def vrange(self,min='*',max='*'):
-        self('set vrange [%s:%s]' % (min,max))
-
-    def set_ps(self,option):
-        """Set an option for the PostScript terminal and reset default term."""
-
-        self('set terminal postscript %s ' % option)
-        self('set terminal %s' % gp.GnuplotOpts.default_term)
-
-    def __plot_ps(self, plot_method,*items, **keyw):
-        """Wrapper for plot/splot/replot, with processing of hardcopy options.
-
-        For internal use only."""
-
-        # Filter out PostScript options which will crash the normal plot/replot
-        psargs = {'filename':None,
-                  'mode':None,
-                  'eps':None,
-                  'enhanced':None,
-                  'color':None,
-                  'solid':None,
-                  'duplexing':None,
-                  'fontname':None,
-                  'fontsize':None,
-                  'debug':0 }
-
-        for k in psargs.keys():
-            if keyw.has_key(k):
-                psargs[k] = keyw[k]
-                del keyw[k]
-
-        # Filter out other options the original plot doesn't know
-        hardcopy = popkey(keyw,'hardcopy',psargs['filename'] is not None)
-        titles = popkey(keyw,'titles',0)
-        
-        # the filename keyword should control hardcopy generation, this is an
-        # override switch only which needs to be explicitly set to zero
-        if hardcopy:
-            if psargs['filename'] is None:
-                raise ValueError, \
-                      'If you request hardcopy, you must give a filename.'
-
-            # set null output so nothing goes to screen. hardcopy() restores output
-            self('set term dumb')
-            # I don't know how to prevent screen output in Windows
-            if os.name == 'posix':
-                self('set output "/dev/null"')
-
-        new_items = zip_items(items,titles)
-        # plot_method is either plot or replot from the original Gnuplot class:
-        plot_method(self,*new_items,**keyw)
-
-        # Do hardcopy if requested
-        if hardcopy:
-            if psargs['filename'].endswith('.eps'):
-                psargs['eps'] = 1
-            self.hardcopy(**psargs)
-
-    def plot(self, *items, **keyw):
-        """Draw a new plot.
-
-        Clear the current plot and create a new 2-d plot containing
-        the specified items.  Each arguments should be of the
-        following types:
-
-        'PlotItem' (e.g., 'Data', 'File', 'Func') -- This is the most
-            flexible way to call plot because the PlotItems can
-            contain suboptions.  Moreover, PlotItems can be saved to
-            variables so that their lifetime is longer than one plot
-            command; thus they can be replotted with minimal overhead.
-
-        'string' (e.g., 'sin(x)') -- The string is interpreted as
-            'Func(string)' (a function that is computed by gnuplot).
-
-        Anything else -- The object, which should be convertible to an
-            array, is passed to the 'Data' constructor, and thus
-            plotted as data.  If the conversion fails, an exception is
-            raised.
-
-
-        This is a modified version of plot(). Compared to the original in
-        Gnuplot.py, this version has several enhancements, listed below.
-
-
-        Modifications to the input arguments
-        ------------------------------------
-
-        (1-d array means Numeric array, list or tuple):
-
-        (i) Any 1-d array which is NOT followed by another 1-d array, is
-        automatically zipped with range(len(array_1d)). Typing g.plot(y) will
-        plot y against its indices.
-
-        (ii) If two 1-d arrays are contiguous in the argument list, they are
-        automatically zipped together. So g.plot(x,y) plots y vs. x, and
-        g.plot(x1,y1,x2,y2) plots y1 vs. x1 and y2 vs. x2.
-
-        (iii) Any 1-d array which is followed by None is automatically zipped
-        with range(len(array_1d)). In this form, typing g.plot(y1,None,y2)
-        will plot both y1 and y2 against their respective indices (and NOT
-        versus one another). The None prevents zipping y1 and y2 together, and
-        since y2 is unpaired it is automatically zipped to its indices by (i)
-
-        (iv) Any other arguments which don't match these cases are left alone and
-        passed to the code below.
-
-        For lists or tuples, the heuristics used to determine whether they are
-        in fact 1-d is fairly simplistic: their first element is checked, and
-        if it is not a list or tuple itself, it is assumed that the whole
-        object is one-dimensional.
-
-        An additional optional keyword 'titles' has been added: it must be a
-        list of strings to be used as labels for the individual plots which
-        are NOT PlotItem objects (since those objects carry their own labels
-        within).
-
-
-        PostScript generation
-        ---------------------
-
-        This version of plot() also handles automatically the production of
-        PostScript output. The main options are (given as keyword arguments):
-
-        - filename: a string, typically ending in .eps. If given, the plot is
-        sent to this file in PostScript format.
-        
-        - hardcopy: this can be set to 0 to override 'filename'. It does not
-        need to be given to produce PostScript, its purpose is to allow
-        switching PostScript output off globally in scripts without having to
-        manually change 'filename' values in multiple calls.
-
-        All other keywords accepted by Gnuplot.hardcopy() are transparently
-        passed, and safely ignored if output is sent to the screen instead of
-        PostScript.
-
-        For example:
-        
-        In [1]: x=frange(0,2*pi,npts=100)
-
-        Generate a plot in file 'sin.eps':
-
-        In [2]: plot(x,sin(x),filename = 'sin.eps')
-
-        Plot to screen instead, without having to change the filename:
-
-        In [3]: plot(x,sin(x),filename = 'sin.eps',hardcopy=0)
-
-        Pass the 'color=0' option to hardcopy for monochrome output:
-
-        In [4]: plot(x,sin(x),filename = 'sin.eps',color=0)
-
-        PostScript generation through plot() is useful mainly for scripting
-        uses where you are not interested in interactive plotting. For
-        interactive use, the hardcopy() function is typically more convenient:
-        
-        In [5]: plot(x,sin(x))
-
-        In [6]: hardcopy('sin.eps')  """
-        
-        self.__plot_ps(Gnuplot_ori.Gnuplot.plot,*items,**keyw)
-        
-    def plot2(self,arg,**kw):
-        """Plot the entries of a dictionary or a list/tuple of arrays.        
-        
-        This simple utility calls plot() with a list of Gnuplot.Data objects
-        constructed either from the values of the input dictionary, or the entries
-        in it if it is a tuple or list.  Each item gets labeled with the key/index
-        in the Gnuplot legend.
-
-        Each item is plotted by zipping it with a list of its indices.
-
-        Any keywords are passed directly to plot()."""
-
-        if hasattr(arg,'keys'):
-            keys = arg.keys()
-            keys.sort()
-        else:
-            keys = range(len(arg))
-
-        pitems = [Data(zip(range(len(arg[k])),arg[k]),title=`k`) for k in keys]
-        self.plot(*pitems,**kw)
-
-    def splot(self, *items, **keyw):
-        """Draw a new three-dimensional plot.
-
-        Clear the current plot and create a new 3-d plot containing
-        the specified items.  Arguments can be of the following types:
-
-        'PlotItem' (e.g., 'Data', 'File', 'Func', 'GridData' ) -- This
-            is the most flexible way to call plot because the
-            PlotItems can contain suboptions.  Moreover, PlotItems can
-            be saved to variables so that their lifetime is longer
-            than one plot command--thus they can be replotted with
-            minimal overhead.
-
-        'string' (e.g., 'sin(x*y)') -- The string is interpreted as a
-            'Func()' (a function that is computed by gnuplot).
-
-        Anything else -- The object is converted to a Data() item, and
-            thus plotted as data.  Note that each data point should
-            normally have at least three values associated with it
-            (i.e., x, y, and z).  If the conversion fails, an
-            exception is raised.
-
-        This is a modified version of splot(). Compared to the original in
-        Gnuplot.py, this version has several enhancements, listed in the
-        plot() documentation.
-        """
-        
-        self.__plot_ps(Gnuplot_ori.Gnuplot.splot,*items,**keyw)
-
-    def replot(self, *items, **keyw):
-        """Replot the data, possibly adding new 'PlotItem's.
-
-        Replot the existing graph, using the items in the current
-        itemlist.  If arguments are specified, they are interpreted as
-        additional items to be plotted alongside the existing items on
-        the same graph.  See 'plot' for details.
-
-        If you want to replot to a postscript file, you MUST give the
-        'filename' keyword argument in each call to replot. The Gnuplot python
-        interface has no way of knowing that your previous call to
-        Gnuplot.plot() was meant for PostScript output."""
-        
-        self.__plot_ps(Gnuplot_ori.Gnuplot.replot,*items,**keyw)
-
-    # The original hardcopy has a bug. See fix at the end. The rest of the code
-    # was lifted verbatim from the original, so that people using IPython get the
-    # benefits without having to manually patch Gnuplot.py
-    def hardcopy(self, filename=None,
-                 mode=None,
-                 eps=None,
-                 enhanced=None,
-                 color=None,
-                 solid=None,
-                 duplexing=None,
-                 fontname=None,
-                 fontsize=None,
-                 debug = 0,
-                 ):
-        """Create a hardcopy of the current plot.
-
-        Create a postscript hardcopy of the current plot to the
-        default printer (if configured) or to the specified filename.
-
-        Note that gnuplot remembers the postscript suboptions across
-        terminal changes.  Therefore if you set, for example, color=1
-        for one hardcopy then the next hardcopy will also be color
-        unless you explicitly choose color=0.  Alternately you can
-        force all of the options to their defaults by setting
-        mode='default'.  I consider this to be a bug in gnuplot.
-
-        Keyword arguments:
-
-          'filename=<string>' -- if a filename is specified, save the
-              output in that file; otherwise print it immediately
-              using the 'default_lpr' configuration option.  If the
-              filename ends in '.eps', EPS mode is automatically
-              selected (like manually specifying eps=1 or mode='eps').
-
-          'mode=<string>' -- set the postscript submode ('landscape',
-              'portrait', 'eps', or 'default').  The default is
-              to leave this option unspecified.
-
-          'eps=<bool>' -- shorthand for 'mode="eps"'; asks gnuplot to
-              generate encapsulated postscript.
-
-          'enhanced=<bool>' -- if set (the default), then generate
-              enhanced postscript, which allows extra features like
-              font-switching, superscripts, and subscripts in axis
-              labels.  (Some old gnuplot versions do not support
-              enhanced postscript; if this is the case set
-              gp.GnuplotOpts.prefer_enhanced_postscript=None.)
-
-          'color=<bool>' -- if set, create a plot with color.  Default
-              is to leave this option unchanged.
-
-          'solid=<bool>' -- if set, force lines to be solid (i.e., not
-              dashed).
-
-          'duplexing=<string>' -- set duplexing option ('defaultplex',
-              'simplex', or 'duplex').  Only request double-sided
-              printing if your printer can handle it.  Actually this
-              option is probably meaningless since hardcopy() can only
-              print a single plot at a time.
-
-          'fontname=<string>' -- set the default font to <string>,
-              which must be a valid postscript font.  The default is
-              to leave this option unspecified.
-
-          'fontsize=<double>' -- set the default font size, in
-              postscript points.
-
-          'debug=<bool>' -- print extra debugging information (useful if
-              your PostScript files are misteriously not being created).
-        """
-
-        if filename is None:
-            assert gp.GnuplotOpts.default_lpr is not None, \
-                   OptionException('default_lpr is not set, so you can only '
-                                   'print to a file.')
-            filename = gp.GnuplotOpts.default_lpr
-            lpr_output = 1
-        else:
-            if filename.endswith('.eps'):
-                eps = 1
-            lpr_output = 0
-
-        # Be careful processing the options.  If the user didn't
-        # request an option explicitly, do not specify it on the 'set
-        # terminal' line (don't even specify the default value for the
-        # option).  This is to avoid confusing older versions of
-        # gnuplot that do not support all of these options.  The
-        # exception is 'enhanced', which is just too useful to have to
-        # specify each time!
-
-        setterm = ['set', 'terminal', 'postscript']
-        if eps:
-            assert mode is None or mode=='eps', \
-                   OptionException('eps option and mode are incompatible')
-            setterm.append('eps')
-        else:
-            if mode is not None:
-                assert mode in ['landscape', 'portrait', 'eps', 'default'], \
-                       OptionException('illegal mode "%s"' % mode)
-                setterm.append(mode)
-        if enhanced is None:
-            enhanced = gp.GnuplotOpts.prefer_enhanced_postscript
-        if enhanced is not None:
-            if enhanced: setterm.append('enhanced')
-            else: setterm.append('noenhanced')
-        if color is not None:
-            if color: setterm.append('color')
-            else: setterm.append('monochrome')
-        if solid is not None:
-            if solid: setterm.append('solid')
-            else: setterm.append('dashed')
-        if duplexing is not None:
-            assert duplexing in ['defaultplex', 'simplex', 'duplex'], \
-                   OptionException('illegal duplexing mode "%s"' % duplexing)
-            setterm.append(duplexing)
-        if fontname is not None:
-            setterm.append('"%s"' % fontname)
-        if fontsize is not None:
-            setterm.append('%s' % fontsize)
-
-        self(string.join(setterm))
-        self.set_string('output', filename)
-        # replot the current figure (to the printer):
-        self.refresh()
-
-        # fperez. Ugly kludge: often for some reason the file is NOT created
-        # and we must reissue the creation commands. I have no idea why!
-        if not lpr_output:
-            #print 'Hardcopy <%s>' % filename  # dbg
-            maxtries = 20
-            delay = 0.1  # delay (in seconds) between print attempts
-            for i in range(maxtries):
-                time.sleep(0.05)  # safety, very small delay
-                if os.path.isfile(filename):
-                    if debug:
-                        print 'Hardcopy to file <%s> success at attempt #%s.' \
-                        % (filename,i+1)
-                    break
-                time.sleep(delay)
-                # try again, issue all commands just in case
-                self(string.join(setterm))
-                self.set_string('output', filename)
-                self.refresh()
-            if not os.path.isfile(filename):
-                print >> sys.stderr,'ERROR: Tried %s times and failed to '\
-                'create hardcopy file `%s`' % (maxtries,filename)
-
-        # reset the terminal to its `default' setting:
-        self('set terminal %s' % gp.GnuplotOpts.default_term)
-        self.set_string('output')
-
-#********************** End of file <Gnuplot2.py> ************************
+# -*- coding: utf-8 -*-
+"""Improved replacement for the Gnuplot.Gnuplot class.
+
+This module imports Gnuplot and replaces some of its functionality with
+improved versions. They add better handling of arrays for plotting and more
+convenient PostScript generation, plus some fixes for hardcopy().
+
+It also adds a convenient plot2 method for plotting dictionaries and
+lists/tuples of arrays.
+
+This module is meant to be used as a drop-in replacement to the original
+Gnuplot, so it should be safe to do:
+
+import IPython.Gnuplot2 as Gnuplot
+
+$Id: Gnuplot2.py 1210 2006-03-13 01:19:31Z fperez $"""
+
+import cStringIO
+import os
+import string
+import sys
+import tempfile
+import time
+import types
+
+import Gnuplot as Gnuplot_ori
+import Numeric
+
+from IPython.genutils import popkey,xsys
+
+# needed by hardcopy():
+gp = Gnuplot_ori.gp
+
+# Patch for Gnuplot.py 1.6 compatibility.
+# Thanks to Hayden Callow <[e-mail]>
+try:
+    OptionException = Gnuplot_ori.PlotItems.OptionException
+except AttributeError:
+    OptionException = Gnuplot_ori.Errors.OptionError
+
+# exhibit a similar interface to Gnuplot so it can be somewhat drop-in
+Data      = Gnuplot_ori.Data
+Func      = Gnuplot_ori.Func
+GridData  = Gnuplot_ori.GridData
+PlotItem  = Gnuplot_ori.PlotItem
+PlotItems = Gnuplot_ori.PlotItems
+
+# Modify some of Gnuplot's functions with improved versions (or bugfixed, in
+# hardcopy's case). In order to preserve the docstrings at runtime, I've
+# copied them from the original code.
+
+# After some significant changes in v 1.7 of Gnuplot.py, we need to do a bit
+# of version checking.
+
+if Gnuplot_ori.__version__ <= '1.6':
+    _BaseFileItem = PlotItems.File
+    _BaseTempFileItem = PlotItems.TempFile
+
+    # Fix the File class to add the 'index' option for Gnuplot versions < 1.7
+    class File(_BaseFileItem):
+
+        _option_list = _BaseFileItem._option_list.copy()
+        _option_list.update({
+            'index' : lambda self, index: self.set_option_index(index),
+            })
+
+        # A new initializer is needed b/c we want to add a modified
+        # _option_sequence list which includes 'index' in the right place.
+        def __init__(self,*args,**kw):
+            self._option_sequence = ['binary', 'index', 'using', 'smooth', 'axes',
+                         'title', 'with']
+
+            _BaseFileItem.__init__(self,*args,**kw)
+
+        # Let's fix the constructor docstring
+        __newdoc = \
+            """Additional Keyword arguments added by IPython:
+
+             'index=<int>' -- similar to the `index` keyword in Gnuplot.
+                 This allows only some of the datasets in a file to be
+                 plotted. Datasets within a file are assumed to be separated
+                 by _pairs_ of blank lines, and the first one is numbered as
+                 0 (similar to C/Python usage)."""
+        __init__.__doc__ = PlotItems.File.__init__.__doc__ + __newdoc
+
+        def set_option_index(self, index):
+            if index is None:
+                self.clear_option('index')
+            elif type(index) in [type(''), type(1)]:
+                self._options['index'] = (index, 'index %s' % index)
+            elif type(index) is type(()):
+                self._options['index'] = (index,'index %s' %
+                                          string.join(map(repr, index), ':'))
+            else:
+                raise OptionException('index=%s' % (index,))
+
+    # We need a FileClass with a different name from 'File', which is a
+    # factory function in 1.7, so that our String class can subclass FileClass
+    # in any version.
+    _FileClass = File
+
+elif Gnuplot_ori.__version__ =='1.7':
+    _FileClass = _BaseFileItem = PlotItems._FileItem
+    _BaseTempFileItem = PlotItems._TempFileItem
+    File = PlotItems.File
+
+else:  # changes in the newer version (svn as of March'06)
+     _FileClass = _BaseFileItem = PlotItems._FileItem
+     _BaseTempFileItem = PlotItems._NewFileItem
+     File = PlotItems.File
+
+
+# Now, we can add our generic code which is version independent
+
+# First some useful utilities
+def eps_fix_bbox(fname):
+    """Fix the bounding box of an eps file by running ps2eps on it.
+
+    If its name ends in .eps, the original file is removed.
+
+    This is particularly useful for plots made by Gnuplot with square aspect
+    ratio: there is a bug in Gnuplot which makes it generate a bounding box
+    which is far wider than the actual plot.
+
+    This function assumes that ps2eps is installed in your system."""
+
+    # note: ps2ps and eps2eps do NOT work, ONLY ps2eps works correctly. The
+    # others make output with bitmapped fonts, which looks horrible.
+    print 'Fixing eps file: <%s>' % fname
+    xsys('ps2eps -f -q -l %s' % fname)
+    if fname.endswith('.eps'):
+        os.rename(fname+'.eps',fname)
+
+def is_list1d(x,containers = [types.ListType,types.TupleType]):
+    """Returns true if x appears to be a 1d list/tuple/array.
+
+    The heuristics are: identify Numeric arrays, or lists/tuples whose first
+    element is not itself a list/tuple. This way zipped lists should work like
+    the original Gnuplot. There's no inexpensive way to know if a list doesn't
+    have a composite object after its first element, so that kind of input
+    will produce an error. But it should work well in most cases.
+    """
+    x_type = type(x)
+
+    return x_type == Numeric.ArrayType and len(x.shape)==1 or \
+           (x_type in containers and
+            type(x[0]) not in containers + [Numeric.ArrayType])
+
+def zip_items(items,titles=None):
+    """zip together neighboring 1-d arrays, and zip standalone ones
+    with their index. Leave other plot items alone."""
+
+    class StandaloneItem(Exception): pass
+    
+    def get_titles(titles):
+        """Return the next title and the input titles array.
+
+        The input array may be changed to None when no titles are left to
+        prevent extra unnecessary calls to this function."""
+        
+        try:
+            title = titles[tit_ct[0]]  # tit_ct[0] is in zip_items'scope
+        except IndexError:
+            titles = None # so we don't enter again
+            title = None
+        else:
+            tit_ct[0] += 1
+        return title,titles
+
+    new_items = []
+
+    if titles:
+        # Initialize counter. It was put in a list as a hack to allow the
+        # nested get_titles to modify it without raising a NameError.
+        tit_ct = [0]
+
+    n = 0  # this loop needs to be done by hand
+    while n < len(items):
+        item = items[n]
+        try:
+            if is_list1d(item):
+                if n==len(items)-1: # last in list
+                    raise StandaloneItem
+                else: # check the next item and zip together if needed
+                    next_item = items[n+1]
+                    if next_item is None:
+                        n += 1
+                        raise StandaloneItem
+                    elif is_list1d(next_item):
+                        # this would be best done with an iterator
+                        if titles:
+                            title,titles = get_titles(titles)
+                        else:
+                            title = None
+                        new_items.append(Data(zip(item,next_item),
+                                              title=title))
+                        n += 1  # avoid double-inclusion of next item
+                    else: # can't zip with next, zip with own index list
+                        raise StandaloneItem
+            else:  # not 1-d array
+                new_items.append(item)
+        except StandaloneItem:
+            if titles:
+                title,titles = get_titles(titles)
+            else:
+                title = None
+            new_items.append(Data(zip(range(len(item)),item),title=title))
+        except AttributeError:
+            new_items.append(item)
+        n+=1
+
+    return new_items
+
+# And some classes with enhanced functionality.
+class String(_FileClass):
+    """Make a PlotItem from data in a string with the same format as a File.
+
+    This allows writing data directly inside python scripts using the exact
+    same format and manipulation options which would be used for external
+    files."""
+
+    def __init__(self, data_str, **keyw):
+        """Construct a String object.
+
+        <data_str> is a string formatted exactly like a valid Gnuplot data
+        file would be. All options from the File constructor are valid here.
+
+        Warning: when used for interactive plotting in scripts which exit
+        immediately, you may get an error because the temporary file used to
+        hold the string data was deleted before Gnuplot had a chance to see
+        it. You can work around this problem by putting a raw_input() call at
+        the end of the script.
+
+        This problem does not appear when generating PostScript output, only
+        with Gnuplot windows."""
+
+        self.tmpfile = _BaseTempFileItem()
+        tmpfile = file(self.tmpfile.filename,'w')
+        tmpfile.write(data_str)
+        _BaseFileItem.__init__(self,self.tmpfile,**keyw)
+
+
+class Gnuplot(Gnuplot_ori.Gnuplot):
+    """Improved Gnuplot class.
+
+    Enhancements: better plot,replot and hardcopy methods. New methods for
+    quick range setting.
+    """
+
+    def xrange(self,min='*',max='*'):
+        """Set xrange. If min/max is omitted, it is set to '*' (auto).
+
+        Note that this is different from the regular Gnuplot behavior, where
+        an unspecified limit means no change. Here any unspecified limit is
+        set to autoscaling, allowing these functions to be used for full
+        autoscaling when called with no arguments.
+
+        To preserve one limit's current value while changing the other, an
+        explicit '' argument must be given as the limit to be kept.
+
+        Similar functions exist for [y{2}z{2}rtuv]range."""
+        
+        self('set xrange [%s:%s]' % (min,max))
+             
+    def yrange(self,min='*',max='*'):
+        self('set yrange [%s:%s]' % (min,max))
+             
+    def zrange(self,min='*',max='*'):
+        self('set zrange [%s:%s]' % (min,max))
+             
+    def x2range(self,min='*',max='*'):
+        self('set xrange [%s:%s]' % (min,max))
+             
+    def y2range(self,min='*',max='*'):
+        self('set yrange [%s:%s]' % (min,max))
+             
+    def z2range(self,min='*',max='*'):
+        self('set zrange [%s:%s]' % (min,max))
+             
+    def rrange(self,min='*',max='*'):
+        self('set rrange [%s:%s]' % (min,max))
+             
+    def trange(self,min='*',max='*'):
+        self('set trange [%s:%s]' % (min,max))
+             
+    def urange(self,min='*',max='*'):
+        self('set urange [%s:%s]' % (min,max))
+             
+    def vrange(self,min='*',max='*'):
+        self('set vrange [%s:%s]' % (min,max))
+
+    def set_ps(self,option):
+        """Set an option for the PostScript terminal and reset default term."""
+
+        self('set terminal postscript %s ' % option)
+        self('set terminal %s' % gp.GnuplotOpts.default_term)
+
+    def __plot_ps(self, plot_method,*items, **keyw):
+        """Wrapper for plot/splot/replot, with processing of hardcopy options.
+
+        For internal use only."""
+
+        # Filter out PostScript options which will crash the normal plot/replot
+        psargs = {'filename':None,
+                  'mode':None,
+                  'eps':None,
+                  'enhanced':None,
+                  'color':None,
+                  'solid':None,
+                  'duplexing':None,
+                  'fontname':None,
+                  'fontsize':None,
+                  'debug':0 }
+
+        for k in psargs.keys():
+            if keyw.has_key(k):
+                psargs[k] = keyw[k]
+                del keyw[k]
+
+        # Filter out other options the original plot doesn't know
+        hardcopy = popkey(keyw,'hardcopy',psargs['filename'] is not None)
+        titles = popkey(keyw,'titles',0)
+        
+        # the filename keyword should control hardcopy generation, this is an
+        # override switch only which needs to be explicitly set to zero
+        if hardcopy:
+            if psargs['filename'] is None:
+                raise ValueError, \
+                      'If you request hardcopy, you must give a filename.'
+
+            # set null output so nothing goes to screen. hardcopy() restores output
+            self('set term dumb')
+            # I don't know how to prevent screen output in Windows
+            if os.name == 'posix':
+                self('set output "/dev/null"')
+
+        new_items = zip_items(items,titles)
+        # plot_method is either plot or replot from the original Gnuplot class:
+        plot_method(self,*new_items,**keyw)
+
+        # Do hardcopy if requested
+        if hardcopy:
+            if psargs['filename'].endswith('.eps'):
+                psargs['eps'] = 1
+            self.hardcopy(**psargs)
+
+    def plot(self, *items, **keyw):
+        """Draw a new plot.
+
+        Clear the current plot and create a new 2-d plot containing
+        the specified items.  Each arguments should be of the
+        following types:
+
+        'PlotItem' (e.g., 'Data', 'File', 'Func') -- This is the most
+            flexible way to call plot because the PlotItems can
+            contain suboptions.  Moreover, PlotItems can be saved to
+            variables so that their lifetime is longer than one plot
+            command; thus they can be replotted with minimal overhead.
+
+        'string' (e.g., 'sin(x)') -- The string is interpreted as
+            'Func(string)' (a function that is computed by gnuplot).
+
+        Anything else -- The object, which should be convertible to an
+            array, is passed to the 'Data' constructor, and thus
+            plotted as data.  If the conversion fails, an exception is
+            raised.
+
+
+        This is a modified version of plot(). Compared to the original in
+        Gnuplot.py, this version has several enhancements, listed below.
+
+
+        Modifications to the input arguments
+        ------------------------------------
+
+        (1-d array means Numeric array, list or tuple):
+
+        (i) Any 1-d array which is NOT followed by another 1-d array, is
+        automatically zipped with range(len(array_1d)). Typing g.plot(y) will
+        plot y against its indices.
+
+        (ii) If two 1-d arrays are contiguous in the argument list, they are
+        automatically zipped together. So g.plot(x,y) plots y vs. x, and
+        g.plot(x1,y1,x2,y2) plots y1 vs. x1 and y2 vs. x2.
+
+        (iii) Any 1-d array which is followed by None is automatically zipped
+        with range(len(array_1d)). In this form, typing g.plot(y1,None,y2)
+        will plot both y1 and y2 against their respective indices (and NOT
+        versus one another). The None prevents zipping y1 and y2 together, and
+        since y2 is unpaired it is automatically zipped to its indices by (i)
+
+        (iv) Any other arguments which don't match these cases are left alone and
+        passed to the code below.
+
+        For lists or tuples, the heuristics used to determine whether they are
+        in fact 1-d is fairly simplistic: their first element is checked, and
+        if it is not a list or tuple itself, it is assumed that the whole
+        object is one-dimensional.
+
+        An additional optional keyword 'titles' has been added: it must be a
+        list of strings to be used as labels for the individual plots which
+        are NOT PlotItem objects (since those objects carry their own labels
+        within).
+
+
+        PostScript generation
+        ---------------------
+
+        This version of plot() also handles automatically the production of
+        PostScript output. The main options are (given as keyword arguments):
+
+        - filename: a string, typically ending in .eps. If given, the plot is
+        sent to this file in PostScript format.
+        
+        - hardcopy: this can be set to 0 to override 'filename'. It does not
+        need to be given to produce PostScript, its purpose is to allow
+        switching PostScript output off globally in scripts without having to
+        manually change 'filename' values in multiple calls.
+
+        All other keywords accepted by Gnuplot.hardcopy() are transparently
+        passed, and safely ignored if output is sent to the screen instead of
+        PostScript.
+
+        For example:
+        
+        In [1]: x=frange(0,2*pi,npts=100)
+
+        Generate a plot in file 'sin.eps':
+
+        In [2]: plot(x,sin(x),filename = 'sin.eps')
+
+        Plot to screen instead, without having to change the filename:
+
+        In [3]: plot(x,sin(x),filename = 'sin.eps',hardcopy=0)
+
+        Pass the 'color=0' option to hardcopy for monochrome output:
+
+        In [4]: plot(x,sin(x),filename = 'sin.eps',color=0)
+
+        PostScript generation through plot() is useful mainly for scripting
+        uses where you are not interested in interactive plotting. For
+        interactive use, the hardcopy() function is typically more convenient:
+        
+        In [5]: plot(x,sin(x))
+
+        In [6]: hardcopy('sin.eps')  """
+        
+        self.__plot_ps(Gnuplot_ori.Gnuplot.plot,*items,**keyw)
+        
+    def plot2(self,arg,**kw):
+        """Plot the entries of a dictionary or a list/tuple of arrays.        
+        
+        This simple utility calls plot() with a list of Gnuplot.Data objects
+        constructed either from the values of the input dictionary, or the entries
+        in it if it is a tuple or list.  Each item gets labeled with the key/index
+        in the Gnuplot legend.
+
+        Each item is plotted by zipping it with a list of its indices.
+
+        Any keywords are passed directly to plot()."""
+
+        if hasattr(arg,'keys'):
+            keys = arg.keys()
+            keys.sort()
+        else:
+            keys = range(len(arg))
+
+        pitems = [Data(zip(range(len(arg[k])),arg[k]),title=`k`) for k in keys]
+        self.plot(*pitems,**kw)
+
+    def splot(self, *items, **keyw):
+        """Draw a new three-dimensional plot.
+
+        Clear the current plot and create a new 3-d plot containing
+        the specified items.  Arguments can be of the following types:
+
+        'PlotItem' (e.g., 'Data', 'File', 'Func', 'GridData' ) -- This
+            is the most flexible way to call plot because the
+            PlotItems can contain suboptions.  Moreover, PlotItems can
+            be saved to variables so that their lifetime is longer
+            than one plot command--thus they can be replotted with
+            minimal overhead.
+
+        'string' (e.g., 'sin(x*y)') -- The string is interpreted as a
+            'Func()' (a function that is computed by gnuplot).
+
+        Anything else -- The object is converted to a Data() item, and
+            thus plotted as data.  Note that each data point should
+            normally have at least three values associated with it
+            (i.e., x, y, and z).  If the conversion fails, an
+            exception is raised.
+
+        This is a modified version of splot(). Compared to the original in
+        Gnuplot.py, this version has several enhancements, listed in the
+        plot() documentation.
+        """
+        
+        self.__plot_ps(Gnuplot_ori.Gnuplot.splot,*items,**keyw)
+
+    def replot(self, *items, **keyw):
+        """Replot the data, possibly adding new 'PlotItem's.
+
+        Replot the existing graph, using the items in the current
+        itemlist.  If arguments are specified, they are interpreted as
+        additional items to be plotted alongside the existing items on
+        the same graph.  See 'plot' for details.
+
+        If you want to replot to a postscript file, you MUST give the
+        'filename' keyword argument in each call to replot. The Gnuplot python
+        interface has no way of knowing that your previous call to
+        Gnuplot.plot() was meant for PostScript output."""
+        
+        self.__plot_ps(Gnuplot_ori.Gnuplot.replot,*items,**keyw)
+
+    # The original hardcopy has a bug. See fix at the end. The rest of the code
+    # was lifted verbatim from the original, so that people using IPython get the
+    # benefits without having to manually patch Gnuplot.py
+    def hardcopy(self, filename=None,
+                 mode=None,
+                 eps=None,
+                 enhanced=None,
+                 color=None,
+                 solid=None,
+                 duplexing=None,
+                 fontname=None,
+                 fontsize=None,
+                 debug = 0,
+                 ):
+        """Create a hardcopy of the current plot.
+
+        Create a postscript hardcopy of the current plot to the
+        default printer (if configured) or to the specified filename.
+
+        Note that gnuplot remembers the postscript suboptions across
+        terminal changes.  Therefore if you set, for example, color=1
+        for one hardcopy then the next hardcopy will also be color
+        unless you explicitly choose color=0.  Alternately you can
+        force all of the options to their defaults by setting
+        mode='default'.  I consider this to be a bug in gnuplot.
+
+        Keyword arguments:
+
+          'filename=<string>' -- if a filename is specified, save the
+              output in that file; otherwise print it immediately
+              using the 'default_lpr' configuration option.  If the
+              filename ends in '.eps', EPS mode is automatically
+              selected (like manually specifying eps=1 or mode='eps').
+
+          'mode=<string>' -- set the postscript submode ('landscape',
+              'portrait', 'eps', or 'default').  The default is
+              to leave this option unspecified.
+
+          'eps=<bool>' -- shorthand for 'mode="eps"'; asks gnuplot to
+              generate encapsulated postscript.
+
+          'enhanced=<bool>' -- if set (the default), then generate
+              enhanced postscript, which allows extra features like
+              font-switching, superscripts, and subscripts in axis
+              labels.  (Some old gnuplot versions do not support
+              enhanced postscript; if this is the case set
+              gp.GnuplotOpts.prefer_enhanced_postscript=None.)
+
+          'color=<bool>' -- if set, create a plot with color.  Default
+              is to leave this option unchanged.
+
+          'solid=<bool>' -- if set, force lines to be solid (i.e., not
+              dashed).
+
+          'duplexing=<string>' -- set duplexing option ('defaultplex',
+              'simplex', or 'duplex').  Only request double-sided
+              printing if your printer can handle it.  Actually this
+              option is probably meaningless since hardcopy() can only
+              print a single plot at a time.
+
+          'fontname=<string>' -- set the default font to <string>,
+              which must be a valid postscript font.  The default is
+              to leave this option unspecified.
+
+          'fontsize=<double>' -- set the default font size, in
+              postscript points.
+
+          'debug=<bool>' -- print extra debugging information (useful if
+              your PostScript files are misteriously not being created).
+        """
+
+        if filename is None:
+            assert gp.GnuplotOpts.default_lpr is not None, \
+                   OptionException('default_lpr is not set, so you can only '
+                                   'print to a file.')
+            filename = gp.GnuplotOpts.default_lpr
+            lpr_output = 1
+        else:
+            if filename.endswith('.eps'):
+                eps = 1
+            lpr_output = 0
+
+        # Be careful processing the options.  If the user didn't
+        # request an option explicitly, do not specify it on the 'set
+        # terminal' line (don't even specify the default value for the
+        # option).  This is to avoid confusing older versions of
+        # gnuplot that do not support all of these options.  The
+        # exception is 'enhanced', which is just too useful to have to
+        # specify each time!
+
+        setterm = ['set', 'terminal', 'postscript']
+        if eps:
+            assert mode is None or mode=='eps', \
+                   OptionException('eps option and mode are incompatible')
+            setterm.append('eps')
+        else:
+            if mode is not None:
+                assert mode in ['landscape', 'portrait', 'eps', 'default'], \
+                       OptionException('illegal mode "%s"' % mode)
+                setterm.append(mode)
+        if enhanced is None:
+            enhanced = gp.GnuplotOpts.prefer_enhanced_postscript
+        if enhanced is not None:
+            if enhanced: setterm.append('enhanced')
+            else: setterm.append('noenhanced')
+        if color is not None:
+            if color: setterm.append('color')
+            else: setterm.append('monochrome')
+        if solid is not None:
+            if solid: setterm.append('solid')
+            else: setterm.append('dashed')
+        if duplexing is not None:
+            assert duplexing in ['defaultplex', 'simplex', 'duplex'], \
+                   OptionException('illegal duplexing mode "%s"' % duplexing)
+            setterm.append(duplexing)
+        if fontname is not None:
+            setterm.append('"%s"' % fontname)
+        if fontsize is not None:
+            setterm.append('%s' % fontsize)
+
+        self(string.join(setterm))
+        self.set_string('output', filename)
+        # replot the current figure (to the printer):
+        self.refresh()
+
+        # fperez. Ugly kludge: often for some reason the file is NOT created
+        # and we must reissue the creation commands. I have no idea why!
+        if not lpr_output:
+            #print 'Hardcopy <%s>' % filename  # dbg
+            maxtries = 20
+            delay = 0.1  # delay (in seconds) between print attempts
+            for i in range(maxtries):
+                time.sleep(0.05)  # safety, very small delay
+                if os.path.isfile(filename):
+                    if debug:
+                        print 'Hardcopy to file <%s> success at attempt #%s.' \
+                        % (filename,i+1)
+                    break
+                time.sleep(delay)
+                # try again, issue all commands just in case
+                self(string.join(setterm))
+                self.set_string('output', filename)
+                self.refresh()
+            if not os.path.isfile(filename):
+                print >> sys.stderr,'ERROR: Tried %s times and failed to '\
+                'create hardcopy file `%s`' % (maxtries,filename)
+
+        # reset the terminal to its `default' setting:
+        self('set terminal %s' % gp.GnuplotOpts.default_term)
+        self.set_string('output')
+
+#********************** End of file <Gnuplot2.py> ************************

IPython/GnuplotInteractive.py

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

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

@@ -1,284 +1,284 b''
-# -*- coding: utf-8 -*-
-"""String interpolation for Python (by Ka-Ping Yee, 14 Feb 2000).
-
-This module lets you quickly and conveniently interpolate values into
-strings (in the flavour of Perl or Tcl, but with less extraneous
-punctuation).  You get a bit more power than in the other languages,
-because this module allows subscripting, slicing, function calls,
-attribute lookup, or arbitrary expressions.  Variables and expressions
-are evaluated in the namespace of the caller.
-
-The itpl() function returns the result of interpolating a string, and
-printpl() prints out an interpolated string.  Here are some examples:
-
-    from Itpl import printpl
-    printpl("Here is a $string.")
-    printpl("Here is a $module.member.")
-    printpl("Here is an $object.member.")
-    printpl("Here is a $functioncall(with, arguments).")
-    printpl("Here is an ${arbitrary + expression}.")
-    printpl("Here is an $array[3] member.")
-    printpl("Here is a $dictionary['member'].")
-
-The filter() function filters a file object so that output through it
-is interpolated.  This lets you produce the illusion that Python knows
-how to do interpolation:
-
-    import Itpl
-    sys.stdout = Itpl.filter()
-    f = "fancy"
-    print "Isn't this $f?"
-    print "Standard output has been replaced with a $sys.stdout object."
-    sys.stdout = Itpl.unfilter()
-    print "Okay, back $to $normal."
-
-Under the hood, the Itpl class represents a string that knows how to
-interpolate values.  An instance of the class parses the string once
-upon initialization; the evaluation and substitution can then be done
-each time the instance is evaluated with str(instance).  For example:
-
-    from Itpl import Itpl
-    s = Itpl("Here is $foo.")
-    foo = 5
-    print str(s)
-    foo = "bar"
-    print str(s)
-
-$Id: Itpl.py 2918 2007-12-31 14:34:47Z vivainio $
-"""                   # ' -> close an open quote for stupid emacs
-
-#*****************************************************************************
-#
-# Copyright (c) 2001 Ka-Ping Yee <[e-mail]>
-#
-#
-# Published under the terms of the MIT license, hereby reproduced:
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-#*****************************************************************************
-
-__author__  = 'Ka-Ping Yee <[e-mail]>'
-__license__ = 'MIT'
-
-import string
-import sys
-from tokenize import tokenprog
-from types import StringType
-
-class ItplError(ValueError):
-    def __init__(self, text, pos):
-        self.text = text
-        self.pos = pos
-    def __str__(self):
-        return "unfinished expression in %s at char %d" % (
-            repr(self.text), self.pos)
-
-def matchorfail(text, pos):
-    match = tokenprog.match(text, pos)
-    if match is None:
-        raise ItplError(text, pos)
-    return match, match.end()
-
-class Itpl:
-    """Class representing a string with interpolation abilities.
-    
-    Upon creation, an instance works out what parts of the format
-    string are literal and what parts need to be evaluated.  The
-    evaluation and substitution happens in the namespace of the
-    caller when str(instance) is called."""
-
-    def __init__(self, format,codec=sys.stdin.encoding,encoding_errors='backslashreplace'):
-        """The single mandatory argument to this constructor is a format
-        string.
-
-        The format string is parsed according to the following rules:
-
-        1.  A dollar sign and a name, possibly followed by any of: 
-              - an open-paren, and anything up to the matching paren 
-              - an open-bracket, and anything up to the matching bracket 
-              - a period and a name 
-            any number of times, is evaluated as a Python expression.
-
-        2.  A dollar sign immediately followed by an open-brace, and
-            anything up to the matching close-brace, is evaluated as
-            a Python expression.
-
-        3.  Outside of the expressions described in the above two rules,
-            two dollar signs in a row give you one literal dollar sign.
-
-        Optional arguments:
-
-        - codec('utf_8'): a string containing the name of a valid Python
-        codec.
-
-        - encoding_errors('backslashreplace'): a string with a valid error handling
-        policy.  See the codecs module documentation for details.
-
-        These are used to encode the format string if a call to str() fails on
-        the expanded result."""
-
-        if not isinstance(format,basestring):
-            raise TypeError, "needs string initializer"
-        self.format = format
-        self.codec = codec
-        self.encoding_errors = encoding_errors
-        
-        namechars = "abcdefghijklmnopqrstuvwxyz" \
-            "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
-        chunks = []
-        pos = 0
-
-        while 1:
-            dollar = string.find(format, "$", pos)
-            if dollar < 0: break
-            nextchar = format[dollar+1]
-
-            if nextchar == "{":
-                chunks.append((0, format[pos:dollar]))
-                pos, level = dollar+2, 1
-                while level:
-                    match, pos = matchorfail(format, pos)
-                    tstart, tend = match.regs[3]
-                    token = format[tstart:tend]
-                    if token == "{": level = level+1
-                    elif token == "}": level = level-1
-                chunks.append((1, format[dollar+2:pos-1]))
-
-            elif nextchar in namechars:
-                chunks.append((0, format[pos:dollar]))
-                match, pos = matchorfail(format, dollar+1)
-                while pos < len(format):
-                    if format[pos] == "." and \
-                        pos+1 < len(format) and format[pos+1] in namechars:
-                        match, pos = matchorfail(format, pos+1)
-                    elif format[pos] in "([":
-                        pos, level = pos+1, 1
-                        while level:
-                            match, pos = matchorfail(format, pos)
-                            tstart, tend = match.regs[3]
-                            token = format[tstart:tend]
-                            if token[0] in "([": level = level+1
-                            elif token[0] in ")]": level = level-1
-                    else: break
-                chunks.append((1, format[dollar+1:pos]))
-
-            else:
-                chunks.append((0, format[pos:dollar+1]))
-                pos = dollar + 1 + (nextchar == "$")
-
-        if pos < len(format): chunks.append((0, format[pos:]))
-        self.chunks = chunks
-
-    def __repr__(self):
-        return "<Itpl %s >" % repr(self.format)
-
-    def _str(self,glob,loc):
-        """Evaluate to a string in the given globals/locals.
-
-        The final output is built by calling str(), but if this fails, the
-        result is encoded with the instance's codec and error handling policy,
-        via a call to out.encode(self.codec,self.encoding_errors)"""
-        result = []
-        app = result.append
-        for live, chunk in self.chunks:
-            if live:
-                val = eval(chunk,glob,loc)
-                try:
-                    app(str(val))
-                except UnicodeEncodeError:
-                    app(unicode(val))
-                
-            else: app(chunk)
-        out = ''.join(result)
-        try:
-            return str(out)
-        except UnicodeError:
-            return out.encode(self.codec,self.encoding_errors)
-
-    def __str__(self):
-        """Evaluate and substitute the appropriate parts of the string."""
-
-        # We need to skip enough frames to get to the actual caller outside of
-        # Itpl.
-        frame = sys._getframe(1)
-        while frame.f_globals["__name__"] == __name__: frame = frame.f_back
-        loc, glob = frame.f_locals, frame.f_globals
-
-        return self._str(glob,loc)
-    
-class ItplNS(Itpl):
-    """Class representing a string with interpolation abilities.
-
-    This inherits from Itpl, but at creation time a namespace is provided
-    where the evaluation will occur.  The interpolation becomes a bit more
-    efficient, as no traceback needs to be extracte.  It also allows the
-    caller to supply a different namespace for the interpolation to occur than
-    its own."""
-    
-    def __init__(self, format,globals,locals=None,
-                 codec='utf_8',encoding_errors='backslashreplace'):
-        """ItplNS(format,globals[,locals]) -> interpolating string instance.
-
-        This constructor, besides a format string, takes a globals dictionary
-        and optionally a locals (which defaults to globals if not provided).
-
-        For further details, see the Itpl constructor."""
-
-        if locals is None:
-            locals = globals
-        self.globals = globals
-        self.locals = locals
-        Itpl.__init__(self,format,codec,encoding_errors)
-        
-    def __str__(self):
-        """Evaluate and substitute the appropriate parts of the string."""
-        return self._str(self.globals,self.locals)
-
-    def __repr__(self):
-        return "<ItplNS %s >" % repr(self.format)
-
-# utilities for fast printing
-def itpl(text): return str(Itpl(text))
-def printpl(text): print itpl(text)
-# versions with namespace
-def itplns(text,globals,locals=None): return str(ItplNS(text,globals,locals))
-def printplns(text,globals,locals=None): print itplns(text,globals,locals)
-
-class ItplFile:
-    """A file object that filters each write() through an interpolator."""
-    def __init__(self, file): self.file = file
-    def __repr__(self): return "<interpolated " + repr(self.file) + ">"
-    def __getattr__(self, attr): return getattr(self.file, attr)
-    def write(self, text): self.file.write(str(Itpl(text)))
-
-def filter(file=sys.stdout):
-    """Return an ItplFile that filters writes to the given file object.
-    
-    'file = filter(file)' replaces 'file' with a filtered object that
-    has a write() method.  When called with no argument, this creates
-    a filter to sys.stdout."""
-    return ItplFile(file)
-
-def unfilter(ifile=None):
-    """Return the original file that corresponds to the given ItplFile.
-    
-    'file = unfilter(file)' undoes the effect of 'file = filter(file)'.
-    'sys.stdout = unfilter()' undoes the effect of 'sys.stdout = filter()'."""
-    return ifile and ifile.file or sys.stdout.file
+# -*- coding: utf-8 -*-
+"""String interpolation for Python (by Ka-Ping Yee, 14 Feb 2000).
+
+This module lets you quickly and conveniently interpolate values into
+strings (in the flavour of Perl or Tcl, but with less extraneous
+punctuation).  You get a bit more power than in the other languages,
+because this module allows subscripting, slicing, function calls,
+attribute lookup, or arbitrary expressions.  Variables and expressions
+are evaluated in the namespace of the caller.
+
+The itpl() function returns the result of interpolating a string, and
+printpl() prints out an interpolated string.  Here are some examples:
+
+    from Itpl import printpl
+    printpl("Here is a $string.")
+    printpl("Here is a $module.member.")
+    printpl("Here is an $object.member.")
+    printpl("Here is a $functioncall(with, arguments).")
+    printpl("Here is an ${arbitrary + expression}.")
+    printpl("Here is an $array[3] member.")
+    printpl("Here is a $dictionary['member'].")
+
+The filter() function filters a file object so that output through it
+is interpolated.  This lets you produce the illusion that Python knows
+how to do interpolation:
+
+    import Itpl
+    sys.stdout = Itpl.filter()
+    f = "fancy"
+    print "Isn't this $f?"
+    print "Standard output has been replaced with a $sys.stdout object."
+    sys.stdout = Itpl.unfilter()
+    print "Okay, back $to $normal."
+
+Under the hood, the Itpl class represents a string that knows how to
+interpolate values.  An instance of the class parses the string once
+upon initialization; the evaluation and substitution can then be done
+each time the instance is evaluated with str(instance).  For example:
+
+    from Itpl import Itpl
+    s = Itpl("Here is $foo.")
+    foo = 5
+    print str(s)
+    foo = "bar"
+    print str(s)
+
+$Id: Itpl.py 2918 2007-12-31 14:34:47Z vivainio $
+"""                   # ' -> close an open quote for stupid emacs
+
+#*****************************************************************************
+#
+# Copyright (c) 2001 Ka-Ping Yee <[e-mail]>
+#
+#
+# Published under the terms of the MIT license, hereby reproduced:
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+#*****************************************************************************
+
+__author__  = 'Ka-Ping Yee <[e-mail]>'
+__license__ = 'MIT'
+
+import string
+import sys
+from tokenize import tokenprog
+from types import StringType
+
+class ItplError(ValueError):
+    def __init__(self, text, pos):
+        self.text = text
+        self.pos = pos
+    def __str__(self):
+        return "unfinished expression in %s at char %d" % (
+            repr(self.text), self.pos)
+
+def matchorfail(text, pos):
+    match = tokenprog.match(text, pos)
+    if match is None:
+        raise ItplError(text, pos)
+    return match, match.end()
+
+class Itpl:
+    """Class representing a string with interpolation abilities.
+    
+    Upon creation, an instance works out what parts of the format
+    string are literal and what parts need to be evaluated.  The
+    evaluation and substitution happens in the namespace of the
+    caller when str(instance) is called."""
+
+    def __init__(self, format,codec=sys.stdin.encoding,encoding_errors='backslashreplace'):
+        """The single mandatory argument to this constructor is a format
+        string.
+
+        The format string is parsed according to the following rules:
+
+        1.  A dollar sign and a name, possibly followed by any of: 
+              - an open-paren, and anything up to the matching paren 
+              - an open-bracket, and anything up to the matching bracket 
+              - a period and a name 
+            any number of times, is evaluated as a Python expression.
+
+        2.  A dollar sign immediately followed by an open-brace, and
+            anything up to the matching close-brace, is evaluated as
+            a Python expression.
+
+        3.  Outside of the expressions described in the above two rules,
+            two dollar signs in a row give you one literal dollar sign.
+
+        Optional arguments:
+
+        - codec('utf_8'): a string containing the name of a valid Python
+        codec.
+
+        - encoding_errors('backslashreplace'): a string with a valid error handling
+        policy.  See the codecs module documentation for details.
+
+        These are used to encode the format string if a call to str() fails on
+        the expanded result."""
+
+        if not isinstance(format,basestring):
+            raise TypeError, "needs string initializer"
+        self.format = format
+        self.codec = codec
+        self.encoding_errors = encoding_errors
+        
+        namechars = "abcdefghijklmnopqrstuvwxyz" \
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
+        chunks = []
+        pos = 0
+
+        while 1:
+            dollar = string.find(format, "$", pos)
+            if dollar < 0: break
+            nextchar = format[dollar+1]
+
+            if nextchar == "{":
+                chunks.append((0, format[pos:dollar]))
+                pos, level = dollar+2, 1
+                while level:
+                    match, pos = matchorfail(format, pos)
+                    tstart, tend = match.regs[3]
+                    token = format[tstart:tend]
+                    if token == "{": level = level+1
+                    elif token == "}": level = level-1
+                chunks.append((1, format[dollar+2:pos-1]))
+
+            elif nextchar in namechars:
+                chunks.append((0, format[pos:dollar]))
+                match, pos = matchorfail(format, dollar+1)
+                while pos < len(format):
+                    if format[pos] == "." and \
+                        pos+1 < len(format) and format[pos+1] in namechars:
+                        match, pos = matchorfail(format, pos+1)
+                    elif format[pos] in "([":
+                        pos, level = pos+1, 1
+                        while level:
+                            match, pos = matchorfail(format, pos)
+                            tstart, tend = match.regs[3]
+                            token = format[tstart:tend]
+                            if token[0] in "([": level = level+1
+                            elif token[0] in ")]": level = level-1
+                    else: break
+                chunks.append((1, format[dollar+1:pos]))
+
+            else:
+                chunks.append((0, format[pos:dollar+1]))
+                pos = dollar + 1 + (nextchar == "$")
+
+        if pos < len(format): chunks.append((0, format[pos:]))
+        self.chunks = chunks
+
+    def __repr__(self):
+        return "<Itpl %s >" % repr(self.format)
+
+    def _str(self,glob,loc):
+        """Evaluate to a string in the given globals/locals.
+
+        The final output is built by calling str(), but if this fails, the
+        result is encoded with the instance's codec and error handling policy,
+        via a call to out.encode(self.codec,self.encoding_errors)"""
+        result = []
+        app = result.append
+        for live, chunk in self.chunks:
+            if live:
+                val = eval(chunk,glob,loc)
+                try:
+                    app(str(val))
+                except UnicodeEncodeError:
+                    app(unicode(val))
+                
+            else: app(chunk)
+        out = ''.join(result)
+        try:
+            return str(out)
+        except UnicodeError:
+            return out.encode(self.codec,self.encoding_errors)
+
+    def __str__(self):
+        """Evaluate and substitute the appropriate parts of the string."""
+
+        # We need to skip enough frames to get to the actual caller outside of
+        # Itpl.
+        frame = sys._getframe(1)
+        while frame.f_globals["__name__"] == __name__: frame = frame.f_back
+        loc, glob = frame.f_locals, frame.f_globals
+
+        return self._str(glob,loc)
+    
+class ItplNS(Itpl):
+    """Class representing a string with interpolation abilities.
+
+    This inherits from Itpl, but at creation time a namespace is provided
+    where the evaluation will occur.  The interpolation becomes a bit more
+    efficient, as no traceback needs to be extracte.  It also allows the
+    caller to supply a different namespace for the interpolation to occur than
+    its own."""
+    
+    def __init__(self, format,globals,locals=None,
+                 codec='utf_8',encoding_errors='backslashreplace'):
+        """ItplNS(format,globals[,locals]) -> interpolating string instance.
+
+        This constructor, besides a format string, takes a globals dictionary
+        and optionally a locals (which defaults to globals if not provided).
+
+        For further details, see the Itpl constructor."""
+
+        if locals is None:
+            locals = globals
+        self.globals = globals
+        self.locals = locals
+        Itpl.__init__(self,format,codec,encoding_errors)
+        
+    def __str__(self):
+        """Evaluate and substitute the appropriate parts of the string."""
+        return self._str(self.globals,self.locals)
+
+    def __repr__(self):
+        return "<ItplNS %s >" % repr(self.format)
+
+# utilities for fast printing
+def itpl(text): return str(Itpl(text))
+def printpl(text): print itpl(text)
+# versions with namespace
+def itplns(text,globals,locals=None): return str(ItplNS(text,globals,locals))
+def printplns(text,globals,locals=None): print itplns(text,globals,locals)
+
+class ItplFile:
+    """A file object that filters each write() through an interpolator."""
+    def __init__(self, file): self.file = file
+    def __repr__(self): return "<interpolated " + repr(self.file) + ">"
+    def __getattr__(self, attr): return getattr(self.file, attr)
+    def write(self, text): self.file.write(str(Itpl(text)))
+
+def filter(file=sys.stdout):
+    """Return an ItplFile that filters writes to the given file object.
+    
+    'file = filter(file)' replaces 'file' with a filtered object that
+    has a write() method.  When called with no argument, this creates
+    a filter to sys.stdout."""
+    return ItplFile(file)
+
+def unfilter(ifile=None):
+    """Return the original file that corresponds to the given ItplFile.
+    
+    'file = unfilter(file)' undoes the effect of 'file = filter(file)'.
+    'sys.stdout = unfilter()' undoes the effect of 'sys.stdout = filter()'."""
+    return ifile and ifile.file or sys.stdout.file

IPython/Logger.py

@@ -1,270 +1,270 b''
-# -*- coding: utf-8 -*-
-"""
-Logger class for IPython's logging facilities.
-
-$Id: Logger.py 2875 2007-11-26 08:37:39Z fperez $
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2001 Janko Hauser <[e-mail]> and
-#       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-#****************************************************************************
-# Modules and globals
-
-from IPython import Release
-__author__  = '%s <%s>\n%s <%s>' % \
-              ( Release.authors['Janko'] + Release.authors['Fernando'] )
-__license__ = Release.license
-
-# Python standard modules
-import glob
-import os
-import time
-
-#****************************************************************************
-# FIXME: This class isn't a mixin anymore, but it still needs attributes from
-# ipython and does input cache management.  Finish cleanup later...
-
-class Logger(object):
-    """A Logfile class with different policies for file creation"""
-
-    def __init__(self,shell,logfname='Logger.log',loghead='',logmode='over'):
-
-        self._i00,self._i,self._ii,self._iii = '','','',''
-
-        # this is the full ipython instance, we need some attributes from it
-        # which won't exist until later. What a mess, clean up later...
-        self.shell = shell
-
-        self.logfname = logfname
-        self.loghead = loghead
-        self.logmode = logmode
-        self.logfile = None
-
-        # Whether to log raw or processed input
-        self.log_raw_input = False
-
-        # whether to also log output
-        self.log_output = False
-
-        # whether to put timestamps before each log entry
-        self.timestamp = False
-
-        # activity control flags
-        self.log_active = False
-
-    # logmode is a validated property
-    def _set_mode(self,mode):
-        if mode not in ['append','backup','global','over','rotate']:
-            raise ValueError,'invalid log mode %s given' % mode
-        self._logmode = mode
-
-    def _get_mode(self):
-        return self._logmode
-
-    logmode = property(_get_mode,_set_mode)
-    
-    def logstart(self,logfname=None,loghead=None,logmode=None,
-                 log_output=False,timestamp=False,log_raw_input=False):
-        """Generate a new log-file with a default header.
-
-        Raises RuntimeError if the log has already been started"""
-
-        if self.logfile is not None:
-            raise RuntimeError('Log file is already active: %s' %
-                               self.logfname)
-        
-        self.log_active = True
-
-        # The parameters can override constructor defaults
-        if logfname is not None: self.logfname = logfname
-        if loghead is not None: self.loghead = loghead
-        if logmode is not None: self.logmode = logmode
-
-        # Parameters not part of the constructor
-        self.timestamp = timestamp
-        self.log_output = log_output
-        self.log_raw_input = log_raw_input
-        
-        # init depending on the log mode requested
-        isfile = os.path.isfile
-        logmode = self.logmode
-
-        if logmode == 'append':
-            self.logfile = open(self.logfname,'a')
-
-        elif logmode == 'backup':
-            if isfile(self.logfname):
-                backup_logname = self.logfname+'~'
-                # Manually remove any old backup, since os.rename may fail
-                # under Windows.
-                if isfile(backup_logname):
-                    os.remove(backup_logname)
-                os.rename(self.logfname,backup_logname)
-            self.logfile = open(self.logfname,'w')
-
-        elif logmode == 'global':
-            self.logfname = os.path.join(self.shell.home_dir,self.logfname)
-            self.logfile = open(self.logfname, 'a')
-
-        elif logmode == 'over':
-            if isfile(self.logfname):
-                os.remove(self.logfname) 
-            self.logfile = open(self.logfname,'w')
-
-        elif logmode == 'rotate':
-            if isfile(self.logfname):
-                if isfile(self.logfname+'.001~'): 
-                    old = glob.glob(self.logfname+'.*~')
-                    old.sort()
-                    old.reverse()
-                    for f in old:
-                        root, ext = os.path.splitext(f)
-                        num = int(ext[1:-1])+1
-                        os.rename(f, root+'.'+`num`.zfill(3)+'~')
-                os.rename(self.logfname, self.logfname+'.001~')
-            self.logfile = open(self.logfname,'w')
-            
-        if logmode != 'append':
-            self.logfile.write(self.loghead)
-
-        self.logfile.flush()
-
-    def switch_log(self,val):
-        """Switch logging on/off. val should be ONLY a boolean."""
-
-        if val not in [False,True,0,1]:
-            raise ValueError, \
-                  'Call switch_log ONLY with a boolean argument, not with:',val
-        
-        label = {0:'OFF',1:'ON',False:'OFF',True:'ON'}
-
-        if self.logfile is None:
-            print """
-Logging hasn't been started yet (use logstart for that).
-
-%logon/%logoff are for temporarily starting and stopping logging for a logfile
-which already exists. But you must first start the logging process with
-%logstart (optionally giving a logfile name)."""
-            
-        else:
-            if self.log_active == val:
-                print 'Logging is already',label[val]
-            else:
-                print 'Switching logging',label[val]
-                self.log_active = not self.log_active
-                self.log_active_out = self.log_active
-
-    def logstate(self):
-        """Print a status message about the logger."""
-        if self.logfile is None:
-            print 'Logging has not been activated.'
-        else:
-            state = self.log_active and 'active' or 'temporarily suspended'
-            print 'Filename       :',self.logfname
-            print 'Mode           :',self.logmode
-            print 'Output logging :',self.log_output
-            print 'Raw input log  :',self.log_raw_input
-            print 'Timestamping   :',self.timestamp
-            print 'State          :',state
-
-    def log(self,line_ori,line_mod,continuation=None):
-        """Write the line to a log and create input cache variables _i*.
-
-        Inputs:
-
-        - line_ori: unmodified input line from the user.  This is not
-        necessarily valid Python.
-
-        - line_mod: possibly modified input, such as the transformations made
-        by input prefilters or input handlers of various kinds.  This should
-        always be valid Python.
-
-        - continuation: if True, indicates this is part of multi-line input."""
-
-        # update the auto _i tables
-        #print '***logging line',line_mod # dbg
-        #print '***cache_count', self.shell.outputcache.prompt_count # dbg
-        try:
-            input_hist = self.shell.user_ns['_ih']
-        except:
-            print 'userns:',self.shell.user_ns.keys()
-            return
-        
-        out_cache = self.shell.outputcache
-
-        # add blank lines if the input cache fell out of sync.
-        if out_cache.do_full_cache and \
-            out_cache.prompt_count +1 > len(input_hist):
-            input_hist.extend(['\n'] * (out_cache.prompt_count - len(input_hist)))
-            
-        if not continuation and line_mod:
-            self._iii = self._ii
-            self._ii = self._i
-            self._i = self._i00
-            # put back the final \n of every input line
-            self._i00 = line_mod+'\n'
-            #print 'Logging input:<%s>' % line_mod  # dbg
-            input_hist.append(self._i00)
-        #print '---[%s]' % (len(input_hist)-1,) # dbg
-
-        # hackish access to top-level namespace to create _i1,_i2... dynamically
-        to_main = {'_i':self._i,'_ii':self._ii,'_iii':self._iii}
-        if self.shell.outputcache.do_full_cache:
-            in_num = self.shell.outputcache.prompt_count
-
-            # but if the opposite is true (a macro can produce multiple inputs
-            # with no output display called), then bring the output counter in
-            # sync:
-            last_num = len(input_hist)-1
-            if in_num != last_num:
-                in_num = self.shell.outputcache.prompt_count = last_num
-            new_i = '_i%s' % in_num
-            if continuation:
-                self._i00 = '%s%s\n' % (self.shell.user_ns[new_i],line_mod)
-                input_hist[in_num] = self._i00
-            to_main[new_i] = self._i00
-        self.shell.user_ns.update(to_main)
-
-        # Write the log line, but decide which one according to the
-        # log_raw_input flag, set when the log is started.
-        if self.log_raw_input:
-            self.log_write(line_ori)
-        else:
-            self.log_write(line_mod)
-
-    def log_write(self,data,kind='input'):
-        """Write data to the log file, if active"""
-
-        #print 'data: %r' % data # dbg
-        if self.log_active and data:
-            write = self.logfile.write
-            if kind=='input':
-                if self.timestamp:
-                    write(time.strftime('# %a, %d %b %Y %H:%M:%S\n',
-                                        time.localtime()))
-                write('%s\n' % data)
-            elif kind=='output' and self.log_output:
-                odata = '\n'.join(['#[Out]# %s' % s
-                                   for s in data.split('\n')])
-                write('%s\n' % odata)
-            self.logfile.flush()
-
-    def logstop(self):
-        """Fully stop logging and close log file.
-
-        In order to start logging again, a new logstart() call needs to be
-        made, possibly (though not necessarily) with a new filename, mode and
-        other options."""
-        
-        self.logfile.close()
-        self.logfile = None
-        self.log_active = False
-
-    # For backwards compatibility, in case anyone was using this.
-    close_log = logstop
+# -*- coding: utf-8 -*-
+"""
+Logger class for IPython's logging facilities.
+
+$Id: Logger.py 2875 2007-11-26 08:37:39Z fperez $
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2001 Janko Hauser <[e-mail]> and
+#       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+#****************************************************************************
+# Modules and globals
+
+from IPython import Release
+__author__  = '%s <%s>\n%s <%s>' % \
+              ( Release.authors['Janko'] + Release.authors['Fernando'] )
+__license__ = Release.license
+
+# Python standard modules
+import glob
+import os
+import time
+
+#****************************************************************************
+# FIXME: This class isn't a mixin anymore, but it still needs attributes from
+# ipython and does input cache management.  Finish cleanup later...
+
+class Logger(object):
+    """A Logfile class with different policies for file creation"""
+
+    def __init__(self,shell,logfname='Logger.log',loghead='',logmode='over'):
+
+        self._i00,self._i,self._ii,self._iii = '','','',''
+
+        # this is the full ipython instance, we need some attributes from it
+        # which won't exist until later. What a mess, clean up later...
+        self.shell = shell
+
+        self.logfname = logfname
+        self.loghead = loghead
+        self.logmode = logmode
+        self.logfile = None
+
+        # Whether to log raw or processed input
+        self.log_raw_input = False
+
+        # whether to also log output
+        self.log_output = False
+
+        # whether to put timestamps before each log entry
+        self.timestamp = False
+
+        # activity control flags
+        self.log_active = False
+
+    # logmode is a validated property
+    def _set_mode(self,mode):
+        if mode not in ['append','backup','global','over','rotate']:
+            raise ValueError,'invalid log mode %s given' % mode
+        self._logmode = mode
+
+    def _get_mode(self):
+        return self._logmode
+
+    logmode = property(_get_mode,_set_mode)
+    
+    def logstart(self,logfname=None,loghead=None,logmode=None,
+                 log_output=False,timestamp=False,log_raw_input=False):
+        """Generate a new log-file with a default header.
+
+        Raises RuntimeError if the log has already been started"""
+
+        if self.logfile is not None:
+            raise RuntimeError('Log file is already active: %s' %
+                               self.logfname)
+        
+        self.log_active = True
+
+        # The parameters can override constructor defaults
+        if logfname is not None: self.logfname = logfname
+        if loghead is not None: self.loghead = loghead
+        if logmode is not None: self.logmode = logmode
+
+        # Parameters not part of the constructor
+        self.timestamp = timestamp
+        self.log_output = log_output
+        self.log_raw_input = log_raw_input
+        
+        # init depending on the log mode requested
+        isfile = os.path.isfile
+        logmode = self.logmode
+
+        if logmode == 'append':
+            self.logfile = open(self.logfname,'a')
+
+        elif logmode == 'backup':
+            if isfile(self.logfname):
+                backup_logname = self.logfname+'~'
+                # Manually remove any old backup, since os.rename may fail
+                # under Windows.
+                if isfile(backup_logname):
+                    os.remove(backup_logname)
+                os.rename(self.logfname,backup_logname)
+            self.logfile = open(self.logfname,'w')
+
+        elif logmode == 'global':
+            self.logfname = os.path.join(self.shell.home_dir,self.logfname)
+            self.logfile = open(self.logfname, 'a')
+
+        elif logmode == 'over':
+            if isfile(self.logfname):
+                os.remove(self.logfname) 
+            self.logfile = open(self.logfname,'w')
+
+        elif logmode == 'rotate':
+            if isfile(self.logfname):
+                if isfile(self.logfname+'.001~'): 
+                    old = glob.glob(self.logfname+'.*~')
+                    old.sort()
+                    old.reverse()
+                    for f in old:
+                        root, ext = os.path.splitext(f)
+                        num = int(ext[1:-1])+1
+                        os.rename(f, root+'.'+`num`.zfill(3)+'~')
+                os.rename(self.logfname, self.logfname+'.001~')
+            self.logfile = open(self.logfname,'w')
+            
+        if logmode != 'append':
+            self.logfile.write(self.loghead)
+
+        self.logfile.flush()
+
+    def switch_log(self,val):
+        """Switch logging on/off. val should be ONLY a boolean."""
+
+        if val not in [False,True,0,1]:
+            raise ValueError, \
+                  'Call switch_log ONLY with a boolean argument, not with:',val
+        
+        label = {0:'OFF',1:'ON',False:'OFF',True:'ON'}
+
+        if self.logfile is None:
+            print """
+Logging hasn't been started yet (use logstart for that).
+
+%logon/%logoff are for temporarily starting and stopping logging for a logfile
+which already exists. But you must first start the logging process with
+%logstart (optionally giving a logfile name)."""
+            
+        else:
+            if self.log_active == val:
+                print 'Logging is already',label[val]
+            else:
+                print 'Switching logging',label[val]
+                self.log_active = not self.log_active
+                self.log_active_out = self.log_active
+
+    def logstate(self):
+        """Print a status message about the logger."""
+        if self.logfile is None:
+            print 'Logging has not been activated.'
+        else:
+            state = self.log_active and 'active' or 'temporarily suspended'
+            print 'Filename       :',self.logfname
+            print 'Mode           :',self.logmode
+            print 'Output logging :',self.log_output
+            print 'Raw input log  :',self.log_raw_input
+            print 'Timestamping   :',self.timestamp
+            print 'State          :',state
+
+    def log(self,line_ori,line_mod,continuation=None):
+        """Write the line to a log and create input cache variables _i*.
+
+        Inputs:
+
+        - line_ori: unmodified input line from the user.  This is not
+        necessarily valid Python.
+
+        - line_mod: possibly modified input, such as the transformations made
+        by input prefilters or input handlers of various kinds.  This should
+        always be valid Python.
+
+        - continuation: if True, indicates this is part of multi-line input."""
+
+        # update the auto _i tables
+        #print '***logging line',line_mod # dbg
+        #print '***cache_count', self.shell.outputcache.prompt_count # dbg
+        try:
+            input_hist = self.shell.user_ns['_ih']
+        except:
+            print 'userns:',self.shell.user_ns.keys()
+            return
+        
+        out_cache = self.shell.outputcache
+
+        # add blank lines if the input cache fell out of sync.
+        if out_cache.do_full_cache and \
+            out_cache.prompt_count +1 > len(input_hist):
+            input_hist.extend(['\n'] * (out_cache.prompt_count - len(input_hist)))
+            
+        if not continuation and line_mod:
+            self._iii = self._ii
+            self._ii = self._i
+            self._i = self._i00
+            # put back the final \n of every input line
+            self._i00 = line_mod+'\n'
+            #print 'Logging input:<%s>' % line_mod  # dbg
+            input_hist.append(self._i00)
+        #print '---[%s]' % (len(input_hist)-1,) # dbg
+
+        # hackish access to top-level namespace to create _i1,_i2... dynamically
+        to_main = {'_i':self._i,'_ii':self._ii,'_iii':self._iii}
+        if self.shell.outputcache.do_full_cache:
+            in_num = self.shell.outputcache.prompt_count
+
+            # but if the opposite is true (a macro can produce multiple inputs
+            # with no output display called), then bring the output counter in
+            # sync:
+            last_num = len(input_hist)-1
+            if in_num != last_num:
+                in_num = self.shell.outputcache.prompt_count = last_num
+            new_i = '_i%s' % in_num
+            if continuation:
+                self._i00 = '%s%s\n' % (self.shell.user_ns[new_i],line_mod)
+                input_hist[in_num] = self._i00
+            to_main[new_i] = self._i00
+        self.shell.user_ns.update(to_main)
+
+        # Write the log line, but decide which one according to the
+        # log_raw_input flag, set when the log is started.
+        if self.log_raw_input:
+            self.log_write(line_ori)
+        else:
+            self.log_write(line_mod)
+
+    def log_write(self,data,kind='input'):
+        """Write data to the log file, if active"""
+
+        #print 'data: %r' % data # dbg
+        if self.log_active and data:
+            write = self.logfile.write
+            if kind=='input':
+                if self.timestamp:
+                    write(time.strftime('# %a, %d %b %Y %H:%M:%S\n',
+                                        time.localtime()))
+                write('%s\n' % data)
+            elif kind=='output' and self.log_output:
+                odata = '\n'.join(['#[Out]# %s' % s
+                                   for s in data.split('\n')])
+                write('%s\n' % odata)
+            self.logfile.flush()
+
+    def logstop(self):
+        """Fully stop logging and close log file.
+
+        In order to start logging again, a new logstart() call needs to be
+        made, possibly (though not necessarily) with a new filename, mode and
+        other options."""
+        
+        self.logfile.close()
+        self.logfile = None
+        self.log_active = False
+
+    # For backwards compatibility, in case anyone was using this.
+    close_log = logstop