iplib.py => core/iplib.py and updated tests and imports.

IPython/Extensions/InterpreterExec.py

@@ -1,253 +1,253
 # -*- 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.
 """
 
 #*****************************************************************************
 #       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.
 #*****************************************************************************
 
 # 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
+from IPython.core.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.utils.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,124 +1,124
 # -*- 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
 
 
 Authors
 -------
 - Fernando Perez <[e-mail]>
 """
 
 #*****************************************************************************
 #       Copyright (C) 2008-2009 The IPython Development Team
 #       Copyright (C) 2001-2007 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.
 #*****************************************************************************
 
 # 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
+from IPython.core.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,84 +1,84
 # -*- 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.
 
 Authors
 -------
 - Fernando Perez <[e-mail]>
 """
 #*****************************************************************************
 #       Copyright (C) 2008-2009 The IPython Development Team
 #       Copyright (C) 2001-2007 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.
 #*****************************************************************************
 
 # 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
+    from IPython.core.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
+from IPython.core.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/Magic.py

@@ -1,3457 +1,3457
 # -*- coding: utf-8 -*-
 """Magic functions for InteractiveShell.
 """
 
 #*****************************************************************************
 #       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
 
 # Python standard modules
 import __builtin__
 import bdb
 import inspect
 import os
 import pdb
 import pydoc
 import sys
 import re
 import tempfile
 import time
 import cPickle as pickle
 import textwrap
 from cStringIO import StringIO
 from getopt import getopt,GetoptError
 from pprint import pprint, pformat
 
 # cProfile was added in Python2.5
 try:
     import cProfile as profile
     import pstats
 except ImportError:
     # profile isn't bundled by default in Debian for license reasons
     try:
         import profile,pstats
     except ImportError:
         profile = pstats = None
 
 # Homebrewed
 import IPython
 from IPython import OInspect, wildcard
 from IPython.core import debugger
 from IPython.core.fakemodule import FakeModule
 from IPython.Itpl import Itpl, itpl, printpl,itplns
 from IPython.PyColorize import Parser
 from IPython.ipstruct import Struct
 from IPython.macro import Macro
 from IPython.utils.genutils import *
 from IPython import platutils
 import IPython.utils.generics
 from IPython.core import ipapi
 from IPython.core.ipapi import UsageError
 from IPython.testing import decorators as testdec
 
 #***************************************************************************
 # Utility functions
 def on_off(tag):
     """Return an ON/OFF string for a 1/0 input. Simple utility function."""
     return ['OFF','ON'][tag]
 
 class Bunch: pass
 
 def compress_dhist(dh):
     head, tail = dh[:-10], dh[-10:]
 
     newhead = []
     done = set()
     for h in head:
         if h in done:
             continue
         newhead.append(h)
         done.add(h)
 
     return newhead + tail        
         
 
 #***************************************************************************
 # Main class implementing Magic functionality
 class Magic:
     """Magic functions for InteractiveShell.
 
     Shell functions which can be reached as %function_name. All magic
     functions should accept a string, which they can parse for their own
     needs. This can make some functions easier to type, eg `%cd ../`
     vs. `%cd("../")`
 
     ALL definitions MUST begin with the prefix magic_. The user won't need it
     at the command line, but it is is needed in the definition. """
 
     # class globals
     auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
                    'Automagic is ON, % prefix NOT needed for magic functions.']
 
     #......................................................................
     # some utility functions
 
     def __init__(self,shell):
         
         self.options_table = {}
         if profile is None:
             self.magic_prun = self.profile_missing_notice
         self.shell = shell
 
         # namespace for holding state we may need
         self._magic_state = Bunch()
 
     def profile_missing_notice(self, *args, **kwargs):
         error("""\
 The profile module could not be found. It has been removed from the standard
 python packages because of its non-free license. To use profiling, install the
 python-profiler package from non-free.""")
 
     def default_option(self,fn,optstr):
         """Make an entry in the options_table for fn, with value optstr"""
 
         if fn not in self.lsmagic():
             error("%s is not a magic function" % fn)
         self.options_table[fn] = optstr
 
     def lsmagic(self):
         """Return a list of currently available magic functions.
 
         Gives a list of the bare names after mangling (['ls','cd', ...], not
         ['magic_ls','magic_cd',...]"""
 
         # FIXME. This needs a cleanup, in the way the magics list is built.
         
         # magics in class definition
         class_magic = lambda fn: fn.startswith('magic_') and \
                       callable(Magic.__dict__[fn])
         # in instance namespace (run-time user additions)
         inst_magic =  lambda fn: fn.startswith('magic_') and \
                      callable(self.__dict__[fn])
         # and bound magics by user (so they can access self):
         inst_bound_magic =  lambda fn: fn.startswith('magic_') and \
                            callable(self.__class__.__dict__[fn])
         magics = filter(class_magic,Magic.__dict__.keys()) + \
                  filter(inst_magic,self.__dict__.keys()) + \
                  filter(inst_bound_magic,self.__class__.__dict__.keys())
         out = []
         for fn in set(magics):
             out.append(fn.replace('magic_','',1))
         out.sort()
         return out
     
     def extract_input_slices(self,slices,raw=False):
         """Return as a string a set of input history slices.
 
         Inputs:
 
           - slices: the set of slices is given as a list of strings (like
           ['1','4:8','9'], since this function is for use by magic functions
           which get their arguments as strings.
 
         Optional inputs:
 
           - raw(False): by default, the processed input is used.  If this is
           true, the raw input history is used instead.
 
         Note that slices can be called with two notations:
 
         N:M -> standard python form, means including items N...(M-1).
 
         N-M -> include items N..M (closed endpoint)."""
 
         if raw:
             hist = self.shell.input_hist_raw
         else:
             hist = self.shell.input_hist
 
         cmds = []
         for chunk in slices:
             if ':' in chunk:
                 ini,fin = map(int,chunk.split(':'))
             elif '-' in chunk:
                 ini,fin = map(int,chunk.split('-'))
                 fin += 1
             else:
                 ini = int(chunk)
                 fin = ini+1
             cmds.append(hist[ini:fin])
         return cmds
         
     def _ofind(self, oname, namespaces=None):
         """Find an object in the available namespaces.
 
         self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
 
         Has special code to detect magic functions.
         """
         
         oname = oname.strip()
 
         alias_ns = None
         if namespaces is None:
             # Namespaces to search in:
             # Put them in a list. The order is important so that we
             # find things in the same order that Python finds them.
             namespaces = [ ('Interactive', self.shell.user_ns),
                            ('IPython internal', self.shell.internal_ns),
                            ('Python builtin', __builtin__.__dict__),
                            ('Alias', self.shell.alias_table),
                            ]
             alias_ns = self.shell.alias_table
 
         # initialize results to 'null'
         found = 0; obj = None;  ospace = None;  ds = None;
         ismagic = 0; isalias = 0; parent = None
 
         # Look for the given name by splitting it in parts.  If the head is
         # found, then we look for all the remaining parts as members, and only
         # declare success if we can find them all.
         oname_parts = oname.split('.')
         oname_head, oname_rest = oname_parts[0],oname_parts[1:]
         for nsname,ns in namespaces:
             try:
                 obj = ns[oname_head]
             except KeyError:
                 continue
             else:
                 #print 'oname_rest:', oname_rest  # dbg
                 for part in oname_rest:
                     try:
                         parent = obj
                         obj = getattr(obj,part)
                     except:
                         # Blanket except b/c some badly implemented objects
                         # allow __getattr__ to raise exceptions other than
                         # AttributeError, which then crashes IPython.
                         break
                 else:
                     # If we finish the for loop (no break), we got all members
                     found = 1
                     ospace = nsname
                     if ns == alias_ns:
                         isalias = 1
                     break  # namespace loop
 
         # Try to see if it's magic
         if not found:
             if oname.startswith(self.shell.ESC_MAGIC):
                 oname = oname[1:]
             obj = getattr(self,'magic_'+oname,None)
             if obj is not None:
                 found = 1
                 ospace = 'IPython internal'
                 ismagic = 1
 
         # Last try: special-case some literals like '', [], {}, etc:
         if not found and oname_head in ["''",'""','[]','{}','()']:
             obj = eval(oname_head)
             found = 1
             ospace = 'Interactive'
             
         return {'found':found, 'obj':obj, 'namespace':ospace,
                 'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
     
     def arg_err(self,func):
         """Print docstring if incorrect arguments were passed"""
         print 'Error in arguments:'
         print OInspect.getdoc(func)
 
     def format_latex(self,strng):
         """Format a string for latex inclusion."""
 
         # Characters that need to be escaped for latex:
         escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
         # Magic command names as headers:
         cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
                                  re.MULTILINE)
         # Magic commands 
         cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
                             re.MULTILINE)
         # Paragraph continue
         par_re = re.compile(r'\\$',re.MULTILINE)
 
         # The "\n" symbol
         newline_re = re.compile(r'\\n')
 
         # Now build the string for output:
         #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
         strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
                                 strng)
         strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
         strng = par_re.sub(r'\\\\',strng)
         strng = escape_re.sub(r'\\\1',strng)
         strng = newline_re.sub(r'\\textbackslash{}n',strng)
         return strng
 
     def format_screen(self,strng):
         """Format a string for screen printing.
 
         This removes some latex-type format codes."""
         # Paragraph continue
         par_re = re.compile(r'\\$',re.MULTILINE)
         strng = par_re.sub('',strng)
         return strng
 
     def parse_options(self,arg_str,opt_str,*long_opts,**kw):
         """Parse options passed to an argument string.
 
         The interface is similar to that of getopt(), but it returns back a
         Struct with the options as keys and the stripped argument string still
         as a string.
 
         arg_str is quoted as a true sys.argv vector by using shlex.split.
         This allows us to easily expand variables, glob files, quote
         arguments, etc.
 
         Options:
           -mode: default 'string'. If given as 'list', the argument string is
           returned as a list (split on whitespace) instead of a string.
 
           -list_all: put all option values in lists. Normally only options
           appearing more than once are put in a list.
 
           -posix (True): whether to split the input line in POSIX mode or not,
           as per the conventions outlined in the shlex module from the
           standard library."""
  
         # inject default options at the beginning of the input line
         caller = sys._getframe(1).f_code.co_name.replace('magic_','')
         arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
         
         mode = kw.get('mode','string')
         if mode not in ['string','list']:
             raise ValueError,'incorrect mode given: %s' % mode
         # Get options
         list_all = kw.get('list_all',0)
         posix = kw.get('posix',True)
 
         # Check if we have more than one argument to warrant extra processing:
         odict = {}  # Dictionary with options
         args = arg_str.split()
         if len(args) >= 1:
             # If the list of inputs only has 0 or 1 thing in it, there's no
             # need to look for options
             argv = arg_split(arg_str,posix)
             # Do regular option processing
             try:
                 opts,args = getopt(argv,opt_str,*long_opts)
             except GetoptError,e:
                 raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str, 
                                         " ".join(long_opts)))
             for o,a in opts:
                 if o.startswith('--'):
                     o = o[2:]
                 else:
                     o = o[1:]
                 try:
                     odict[o].append(a)
                 except AttributeError:
                     odict[o] = [odict[o],a]
                 except KeyError:
                     if list_all:
                         odict[o] = [a]
                     else:
                         odict[o] = a
 
         # Prepare opts,args for return
         opts = Struct(odict)
         if mode == 'string':
             args = ' '.join(args)
 
         return opts,args
     
     #......................................................................
     # And now the actual magic functions
 
     # Functions for IPython shell work (vars,funcs, config, etc)
     def magic_lsmagic(self, parameter_s = ''):
         """List currently available magic functions."""
         mesc = self.shell.ESC_MAGIC
         print 'Available magic functions:\n'+mesc+\
               ('  '+mesc).join(self.lsmagic())
         print '\n' + Magic.auto_status[self.shell.rc.automagic]
         return None
         
     def magic_magic(self, parameter_s = ''):
         """Print information about the magic function system.
         
         Supported formats: -latex, -brief, -rest        
         """
 
         mode = ''
         try:
             if parameter_s.split()[0] == '-latex':
                 mode = 'latex'
             if parameter_s.split()[0] == '-brief':
                 mode = 'brief'
             if parameter_s.split()[0] == '-rest':
                 mode = 'rest'
                 rest_docs = []
         except:
             pass
 
         magic_docs = []
         for fname in self.lsmagic():
             mname = 'magic_' + fname
             for space in (Magic,self,self.__class__):
                 try:
                     fn = space.__dict__[mname]
                 except KeyError:
                     pass
                 else:
                     break
             if mode == 'brief':
                 # only first line
                 if fn.__doc__:                    
                     fndoc = fn.__doc__.split('\n',1)[0]
                 else:
                     fndoc = 'No documentation'
             else:
                 if fn.__doc__:
                     fndoc = fn.__doc__.rstrip()       
                 else:
                     fndoc = 'No documentation'
                 
                 
             if mode == 'rest':
                 rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(self.shell.ESC_MAGIC,
                                                     fname,fndoc))
                 
             else:
                 magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
                                                     fname,fndoc))
                 
         magic_docs = ''.join(magic_docs)
 
         if mode == 'rest':
             return "".join(rest_docs)
         
         if mode == 'latex':
             print self.format_latex(magic_docs)
             return
         else:
             magic_docs = self.format_screen(magic_docs)
         if mode == 'brief':
             return magic_docs
         
         outmsg = """
 IPython's 'magic' functions
 ===========================
 
 The magic function system provides a series of functions which allow you to
 control the behavior of IPython itself, plus a lot of system-type
 features. All these functions are prefixed with a % character, but parameters
 are given without parentheses or quotes.
 
 NOTE: If you have 'automagic' enabled (via the command line option or with the
 %automagic function), you don't need to type in the % explicitly.  By default,
 IPython ships with automagic on, so you should only rarely need the % escape.
 
 Example: typing '%cd mydir' (without the quotes) changes you working directory
 to 'mydir', if it exists.
 
 You can define your own magic functions to extend the system. See the supplied
 ipythonrc and example-magic.py files for details (in your ipython
 configuration directory, typically $HOME/.ipython/).
 
 You can also define your own aliased names for magic functions. In your
 ipythonrc file, placing a line like:
 
   execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
 
 will define %pf as a new name for %profile.
 
 You can also call magics in code using the ipmagic() function, which IPython
 automatically adds to the builtin namespace.  Type 'ipmagic?' for details.
 
 For a list of the available magic functions, use %lsmagic. For a description
 of any of them, type %magic_name?, e.g. '%cd?'.
 
 Currently the magic system has the following functions:\n"""
 
         mesc = self.shell.ESC_MAGIC
         outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
                   "\n\n%s%s\n\n%s" % (outmsg,
                                      magic_docs,mesc,mesc,
                                      ('  '+mesc).join(self.lsmagic()),
                                      Magic.auto_status[self.shell.rc.automagic] ) )
 
         page(outmsg,screen_lines=self.shell.rc.screen_length)
   
 
     def magic_autoindent(self, parameter_s = ''):
         """Toggle autoindent on/off (if available)."""
 
         self.shell.set_autoindent()
         print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
 
 
     def magic_automagic(self, parameter_s = ''):
         """Make magic functions callable without having to type the initial %.
 
         Without argumentsl toggles on/off (when off, you must call it as
         %automagic, of course).  With arguments it sets the value, and you can
         use any of (case insensitive):
 
          - on,1,True: to activate
 
          - off,0,False: to deactivate.
 
         Note that magic functions have lowest priority, so if there's a
         variable whose name collides with that of a magic fn, automagic won't
         work for that function (you get the variable instead). However, if you
         delete the variable (del var), the previously shadowed magic function
         becomes visible to automagic again."""
 
         rc = self.shell.rc
         arg = parameter_s.lower()
         if parameter_s in ('on','1','true'):
             rc.automagic = True
         elif parameter_s in ('off','0','false'):
             rc.automagic = False
         else:
             rc.automagic = not rc.automagic
         print '\n' + Magic.auto_status[rc.automagic]
 
     @testdec.skip_doctest
     def magic_autocall(self, parameter_s = ''):
         """Make functions callable without having to type parentheses.
 
         Usage:
 
            %autocall [mode]
 
         The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the
         value is toggled on and off (remembering the previous state).
 
         In more detail, these values mean:
 
         0 -> fully disabled
 
         1 -> active, but do not apply if there are no arguments on the line.
 
         In this mode, you get:
 
         In [1]: callable
         Out[1]: <built-in function callable>
 
         In [2]: callable 'hello'
         ------> callable('hello')
         Out[2]: False
 
         2 -> Active always.  Even if no arguments are present, the callable
         object is called:
 
         In [2]: float
         ------> float()
         Out[2]: 0.0
 
         Note that even with autocall off, you can still use '/' at the start of
         a line to treat the first argument on the command line as a function
         and add parentheses to it:
 
         In [8]: /str 43
         ------> str(43)
         Out[8]: '43'
 
         # all-random (note for auto-testing)
         """
 
         rc = self.shell.rc
 
         if parameter_s:
             arg = int(parameter_s)
         else:
             arg = 'toggle'
 
         if not arg in (0,1,2,'toggle'):
             error('Valid modes: (0->Off, 1->Smart, 2->Full')
             return
 
         if arg in (0,1,2):
             rc.autocall = arg
         else: # toggle
             if rc.autocall:
                 self._magic_state.autocall_save = rc.autocall
                 rc.autocall = 0
             else:
                 try:
                     rc.autocall = self._magic_state.autocall_save
                 except AttributeError:
                     rc.autocall = self._magic_state.autocall_save = 1
 
         print "Automatic calling is:",['OFF','Smart','Full'][rc.autocall]
 
     def magic_system_verbose(self, parameter_s = ''):
         """Set verbose printing of system calls.
 
         If called without an argument, act as a toggle"""
 
         if parameter_s:
             val = bool(eval(parameter_s))
         else:
             val = None
             
         self.shell.rc_set_toggle('system_verbose',val)
         print "System verbose printing is:",\
               ['OFF','ON'][self.shell.rc.system_verbose]
 
 
     def magic_page(self, parameter_s=''):
         """Pretty print the object and display it through a pager.
         
         %page [options] OBJECT
 
         If no object is given, use _ (last output).
         
         Options:
 
           -r: page str(object), don't pretty-print it."""
 
         # After a function contributed by Olivier Aubert, slightly modified.
 
         # Process options/args
         opts,args = self.parse_options(parameter_s,'r')
         raw = 'r' in opts
 
         oname = args and args or '_'
         info = self._ofind(oname)
         if info['found']:
             txt = (raw and str or pformat)( info['obj'] )
             page(txt)
         else:
             print 'Object `%s` not found' % oname
 
     def magic_profile(self, parameter_s=''):
         """Print your currently active IPyhton profile."""
         if self.shell.rc.profile:
             printpl('Current IPython profile: $self.shell.rc.profile.')
         else:
             print 'No profile active.'
 
     def magic_pinfo(self, parameter_s='', namespaces=None):
         """Provide detailed information about an object.
     
         '%pinfo object' is just a synonym for object? or ?object."""
     
         #print 'pinfo par: <%s>' % parameter_s  # dbg
     
         
         # detail_level: 0 -> obj? , 1 -> obj??
         detail_level = 0
         # We need to detect if we got called as 'pinfo pinfo foo', which can
         # happen if the user types 'pinfo foo?' at the cmd line.
         pinfo,qmark1,oname,qmark2 = \
                re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
         if pinfo or qmark1 or qmark2:
             detail_level = 1
         if "*" in oname:
             self.magic_psearch(oname)
         else:
             self._inspect('pinfo', oname, detail_level=detail_level,
                           namespaces=namespaces)
 
     def magic_pdef(self, parameter_s='', namespaces=None):
         """Print the definition header for any callable object.
 
         If the object is a class, print the constructor information."""
         self._inspect('pdef',parameter_s, namespaces)
 
     def magic_pdoc(self, parameter_s='', namespaces=None):
         """Print the docstring for an object.
 
         If the given object is a class, it will print both the class and the
         constructor docstrings."""
         self._inspect('pdoc',parameter_s, namespaces)
 
     def magic_psource(self, parameter_s='', namespaces=None):
         """Print (or run through pager) the source code for an object."""
         self._inspect('psource',parameter_s, namespaces)
 
     def magic_pfile(self, parameter_s=''):
         """Print (or run through pager) the file where an object is defined.
 
         The file opens at the line where the object definition begins. IPython
         will honor the environment variable PAGER if set, and otherwise will
         do its best to print the file in a convenient form.
 
         If the given argument is not an object currently defined, IPython will
         try to interpret it as a filename (automatically adding a .py extension
         if needed). You can thus use %pfile as a syntax highlighting code
         viewer."""
 
         # first interpret argument as an object name
         out = self._inspect('pfile',parameter_s)
         # if not, try the input as a filename
         if out == 'not found':
             try:
                 filename = get_py_filename(parameter_s)
             except IOError,msg:
                 print msg
                 return
             page(self.shell.inspector.format(file(filename).read()))
 
     def _inspect(self,meth,oname,namespaces=None,**kw):
         """Generic interface to the inspector system.
 
         This function is meant to be called by pdef, pdoc & friends."""
 
         #oname = oname.strip()
         #print '1- oname: <%r>' % oname  # dbg
         try:
             oname = oname.strip().encode('ascii')
             #print '2- oname: <%r>' % oname  # dbg
         except UnicodeEncodeError:
             print 'Python identifiers can only contain ascii characters.'
             return 'not found'
             
         info = Struct(self._ofind(oname, namespaces))
         
         if info.found:
             try:
                 IPython.utils.generics.inspect_object(info.obj)
                 return
             except ipapi.TryNext:
                 pass
             # Get the docstring of the class property if it exists.
             path = oname.split('.')
             root = '.'.join(path[:-1])
             if info.parent is not None:
                 try:
                     target = getattr(info.parent, '__class__') 
                     # The object belongs to a class instance. 
                     try: 
                         target = getattr(target, path[-1])
                         # The class defines the object. 
                         if isinstance(target, property):
                             oname = root + '.__class__.' + path[-1]
                             info = Struct(self._ofind(oname))
                     except AttributeError: pass
                 except AttributeError: pass
                         
             pmethod = getattr(self.shell.inspector,meth)
             formatter = info.ismagic and self.format_screen or None
             if meth == 'pdoc':
                 pmethod(info.obj,oname,formatter)
             elif meth == 'pinfo':
                 pmethod(info.obj,oname,formatter,info,**kw)
             else:
                 pmethod(info.obj,oname)
         else:
             print 'Object `%s` not found.' % oname
             return 'not found'  # so callers can take other action
         
     def magic_psearch(self, parameter_s=''):
         """Search for object in namespaces by wildcard.
 
         %psearch [options] PATTERN [OBJECT TYPE]
 
         Note: ? can be used as a synonym for %psearch, at the beginning or at
         the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the
         rest of the command line must be unchanged (options come first), so
         for example the following forms are equivalent
 
         %psearch -i a* function
         -i a* function?
         ?-i a* function
 
         Arguments:
         
           PATTERN
 
           where PATTERN is a string containing * as a wildcard similar to its
           use in a shell.  The pattern is matched in all namespaces on the
           search path. By default objects starting with a single _ are not
           matched, many IPython generated objects have a single
           underscore. The default is case insensitive matching. Matching is
           also done on the attributes of objects and not only on the objects
           in a module.
 
           [OBJECT TYPE]
 
           Is the name of a python type from the types module. The name is
           given in lowercase without the ending type, ex. StringType is
           written string. By adding a type here only objects matching the
           given type are matched. Using all here makes the pattern match all
           types (this is the default).
 
         Options:
 
           -a: makes the pattern match even objects whose names start with a
           single underscore.  These names are normally ommitted from the
           search.
 
           -i/-c: make the pattern case insensitive/sensitive.  If neither of
           these options is given, the default is read from your ipythonrc
           file.  The option name which sets this value is
           'wildcards_case_sensitive'.  If this option is not specified in your
           ipythonrc file, IPython's internal default is to do a case sensitive
           search.
 
           -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you
           specifiy can be searched in any of the following namespaces:
           'builtin', 'user', 'user_global','internal', 'alias', where
           'builtin' and 'user' are the search defaults.  Note that you should
           not use quotes when specifying namespaces.
 
           'Builtin' contains the python module builtin, 'user' contains all
           user data, 'alias' only contain the shell aliases and no python
           objects, 'internal' contains objects used by IPython.  The
           'user_global' namespace is only used by embedded IPython instances,
           and it contains module-level globals.  You can add namespaces to the
           search with -s or exclude them with -e (these options can be given
           more than once).
     
         Examples:
        
         %psearch a*            -> objects beginning with an a
         %psearch -e builtin a* -> objects NOT in the builtin space starting in a
         %psearch a* function   -> all functions beginning with an a
         %psearch re.e*         -> objects beginning with an e in module re
         %psearch r*.e*         -> objects that start with e in modules starting in r
         %psearch r*.* string   -> all strings in modules beginning with r
 
         Case sensitve search:
        
         %psearch -c a*         list all object beginning with lower case a
 
         Show objects beginning with a single _:
        
         %psearch -a _*         list objects beginning with a single underscore"""
         try:
             parameter_s = parameter_s.encode('ascii')
         except UnicodeEncodeError:
             print 'Python identifiers can only contain ascii characters.'
             return
 
         # default namespaces to be searched
         def_search = ['user','builtin']
 
         # Process options/args
         opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
         opt = opts.get
         shell = self.shell
         psearch = shell.inspector.psearch
 
         # select case options
         if opts.has_key('i'):
             ignore_case = True
         elif opts.has_key('c'):
             ignore_case = False
         else:
             ignore_case = not shell.rc.wildcards_case_sensitive
 
         # Build list of namespaces to search from user options
         def_search.extend(opt('s',[]))
         ns_exclude = ns_exclude=opt('e',[])
         ns_search = [nm for nm in def_search if nm not in ns_exclude]
         
         # Call the actual search
         try:
             psearch(args,shell.ns_table,ns_search,
                     show_all=opt('a'),ignore_case=ignore_case)
         except:
             shell.showtraceback()
 
     def magic_who_ls(self, parameter_s=''):
         """Return a sorted list of all interactive variables.
 
         If arguments are given, only variables of types matching these
         arguments are returned."""
 
         user_ns = self.shell.user_ns
         internal_ns = self.shell.internal_ns
         user_config_ns = self.shell.user_config_ns
         out = []
         typelist = parameter_s.split()
 
         for i in user_ns:
             if not (i.startswith('_') or i.startswith('_i')) \
                    and not (i in internal_ns or i in user_config_ns):
                 if typelist:
                     if type(user_ns[i]).__name__ in typelist:
                         out.append(i)
                 else:
                     out.append(i)
         out.sort()
         return out
         
     def magic_who(self, parameter_s=''):
         """Print all interactive variables, with some minimal formatting.
 
         If any arguments are given, only variables whose type matches one of
         these are printed.  For example:
 
           %who function str
 
         will only list functions and strings, excluding all other types of
         variables.  To find the proper type names, simply use type(var) at a
         command line to see how python prints type names.  For example:
 
           In [1]: type('hello')\\
           Out[1]: <type 'str'>
 
         indicates that the type name for strings is 'str'.
 
         %who always excludes executed names loaded through your configuration
         file and things which are internal to IPython.
 
         This is deliberate, as typically you may load many modules and the
         purpose of %who is to show you only what you've manually defined."""
 
         varlist = self.magic_who_ls(parameter_s)
         if not varlist:
             if parameter_s:
                 print 'No variables match your requested type.'
             else:
                 print 'Interactive namespace is empty.'
             return
 
         # if we have variables, move on...
         count = 0
         for i in varlist:
             print i+'\t',
             count += 1
             if count > 8:
                 count = 0
                 print
         print
 
     def magic_whos(self, parameter_s=''):
         """Like %who, but gives some extra information about each variable.
 
         The same type filtering of %who can be applied here.
 
         For all variables, the type is printed. Additionally it prints:
         
           - For {},[],(): their length.
 
           - For numpy and Numeric arrays, a summary with shape, number of
           elements, typecode and size in memory.
 
           - Everything else: a string representation, snipping their middle if
           too long."""
         
         varnames = self.magic_who_ls(parameter_s)
         if not varnames:
             if parameter_s:
                 print 'No variables match your requested type.'
             else:
                 print 'Interactive namespace is empty.'
             return
 
         # if we have variables, move on...
 
         # for these types, show len() instead of data:
         seq_types = [types.DictType,types.ListType,types.TupleType]
 
         # for numpy/Numeric arrays, display summary info
         try:
             import numpy
         except ImportError:
             ndarray_type = None
         else:
             ndarray_type = numpy.ndarray.__name__
         try:
             import Numeric
         except ImportError:
             array_type = None
         else:
             array_type = Numeric.ArrayType.__name__
 
         # Find all variable names and types so we can figure out column sizes
         def get_vars(i):
             return self.shell.user_ns[i]
         
         # some types are well known and can be shorter
         abbrevs = {'IPython.macro.Macro' : 'Macro'}
         def type_name(v):
             tn = type(v).__name__
             return abbrevs.get(tn,tn)
             
         varlist = map(get_vars,varnames)
 
         typelist = []
         for vv in varlist:
             tt = type_name(vv)
 
             if tt=='instance':
                 typelist.append( abbrevs.get(str(vv.__class__),
                                              str(vv.__class__)))
             else:
                 typelist.append(tt)
 
         # column labels and # of spaces as separator
         varlabel = 'Variable'
         typelabel = 'Type'
         datalabel = 'Data/Info'
         colsep = 3
         # variable format strings
         vformat    = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
         vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
         aformat    = "%s: %s elems, type `%s`, %s bytes"
         # find the size of the columns to format the output nicely
         varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
         typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
         # table header
         print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
               ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
         # and the table itself
         kb = 1024
         Mb = 1048576  # kb**2
         for vname,var,vtype in zip(varnames,varlist,typelist):
             print itpl(vformat),
             if vtype in seq_types:
                 print len(var)
             elif vtype in [array_type,ndarray_type]:
                 vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
                 if vtype==ndarray_type:
                     # numpy
                     vsize  = var.size
                     vbytes = vsize*var.itemsize
                     vdtype = var.dtype
                 else:
                     # Numeric
                     vsize  = Numeric.size(var)
                     vbytes = vsize*var.itemsize()
                     vdtype = var.typecode()
                     
                 if vbytes < 100000:
                     print aformat % (vshape,vsize,vdtype,vbytes)
                 else:
                     print aformat % (vshape,vsize,vdtype,vbytes),
                     if vbytes < Mb:
                         print '(%s kb)' % (vbytes/kb,)
                     else:
                         print '(%s Mb)' % (vbytes/Mb,)
             else:
                 try:
                     vstr = str(var)
                 except UnicodeEncodeError:
                     vstr = unicode(var).encode(sys.getdefaultencoding(),
                                                'backslashreplace')
                 vstr = vstr.replace('\n','\\n')
                 if len(vstr) < 50:
                     print vstr
                 else:
                     printpl(vfmt_short)
                 
     def magic_reset(self, parameter_s=''):
         """Resets the namespace by removing all names defined by the user.
 
         Input/Output history are left around in case you need them.
 
         Parameters
         ----------
           -y : force reset without asking for confirmation.
 
         Examples
         --------
         In [6]: a = 1
 
         In [7]: a
         Out[7]: 1
 
         In [8]: 'a' in _ip.user_ns
         Out[8]: True
 
         In [9]: %reset -f
 
         In [10]: 'a' in _ip.user_ns
         Out[10]: False
         """
 
         if parameter_s == '-f':
             ans = True
         else:
             ans = self.shell.ask_yes_no(
                 "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
         if not ans:
             print 'Nothing done.'
             return
         user_ns = self.shell.user_ns
         for i in self.magic_who_ls():
             del(user_ns[i])
             
         # Also flush the private list of module references kept for script
         # execution protection
         self.shell.clear_main_mod_cache()
 
     def magic_logstart(self,parameter_s=''):
         """Start logging anywhere in a session.
 
         %logstart [-o|-r|-t] [log_name [log_mode]]
 
         If no name is given, it defaults to a file named 'ipython_log.py' in your
         current directory, in 'rotate' mode (see below).
 
         '%logstart name' saves to file 'name' in 'backup' mode.  It saves your
         history up to that point and then continues logging.
 
         %logstart takes a second optional parameter: logging mode. This can be one
         of (note that the modes are given unquoted):\\
           append: well, that says it.\\
           backup: rename (if exists) to name~ and start name.\\
           global: single logfile in your home dir, appended to.\\
           over  : overwrite existing log.\\
           rotate: create rotating logs name.1~, name.2~, etc.
 
         Options:
 
           -o: log also IPython's output.  In this mode, all commands which
           generate an Out[NN] prompt are recorded to the logfile, right after
           their corresponding input line.  The output lines are always
           prepended with a '#[Out]# ' marker, so that the log remains valid
           Python code.
 
           Since this marker is always the same, filtering only the output from
           a log is very easy, using for example a simple awk call:
 
             awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
 
           -r: log 'raw' input.  Normally, IPython's logs contain the processed
           input, so that user lines are logged in their final form, converted
           into valid Python.  For example, %Exit is logged as
           '_ip.magic("Exit").  If the -r flag is given, all input is logged
           exactly as typed, with no transformations applied.
 
           -t: put timestamps before each input line logged (these are put in
           comments)."""
         
         opts,par = self.parse_options(parameter_s,'ort')
         log_output = 'o' in opts
         log_raw_input = 'r' in opts
         timestamp = 't' in opts
 
         rc = self.shell.rc
         logger = self.shell.logger
 
         # if no args are given, the defaults set in the logger constructor by
         # ipytohn remain valid
         if par:
             try:
                 logfname,logmode = par.split()
             except:
                 logfname = par
                 logmode = 'backup'
         else:
             logfname = logger.logfname
             logmode = logger.logmode
         # put logfname into rc struct as if it had been called on the command
         # line, so it ends up saved in the log header Save it in case we need
         # to restore it...
         old_logfile = rc.opts.get('logfile','')  
         if logfname:
             logfname = os.path.expanduser(logfname)
         rc.opts.logfile = logfname
         loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
         try:
             started  = logger.logstart(logfname,loghead,logmode,
                                        log_output,timestamp,log_raw_input)
         except:
             rc.opts.logfile = old_logfile
             warn("Couldn't start log: %s" % sys.exc_info()[1])
         else:
             # log input history up to this point, optionally interleaving
             # output if requested
 
             if timestamp:
                 # disable timestamping for the previous history, since we've
                 # lost those already (no time machine here).
                 logger.timestamp = False
 
             if log_raw_input:
                 input_hist = self.shell.input_hist_raw
             else:
                 input_hist = self.shell.input_hist
                 
             if log_output:
                 log_write = logger.log_write
                 output_hist = self.shell.output_hist
                 for n in range(1,len(input_hist)-1):
                     log_write(input_hist[n].rstrip())
                     if n in output_hist:
                         log_write(repr(output_hist[n]),'output')
             else:
                 logger.log_write(input_hist[1:])
             if timestamp:
                 # re-enable timestamping
                 logger.timestamp = True
                 
             print ('Activating auto-logging. '
                    'Current session state plus future input saved.')
             logger.logstate()
 
     def magic_logstop(self,parameter_s=''):
         """Fully stop logging and close log file.
 
         In order to start logging again, a new %logstart call needs to be made,
         possibly (though not necessarily) with a new filename, mode and other
         options."""
         self.logger.logstop()
 
     def magic_logoff(self,parameter_s=''):
         """Temporarily stop logging.
 
         You must have previously started logging."""
         self.shell.logger.switch_log(0)
         
     def magic_logon(self,parameter_s=''):
         """Restart logging.
 
         This function is for restarting logging which you've temporarily
         stopped with %logoff. For starting logging for the first time, you
         must use the %logstart function, which allows you to specify an
         optional log filename."""
         
         self.shell.logger.switch_log(1)
     
     def magic_logstate(self,parameter_s=''):
         """Print the status of the logging system."""
 
         self.shell.logger.logstate()
         
     def magic_pdb(self, parameter_s=''):
         """Control the automatic calling of the pdb interactive debugger.
 
         Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
         argument it works as a toggle.
 
         When an exception is triggered, IPython can optionally call the
         interactive pdb debugger after the traceback printout. %pdb toggles
         this feature on and off.
 
         The initial state of this feature is set in your ipythonrc
         configuration file (the variable is called 'pdb').
 
         If you want to just activate the debugger AFTER an exception has fired,
         without having to type '%pdb on' and rerunning your code, you can use
         the %debug magic."""
 
         par = parameter_s.strip().lower()
 
         if par:
             try:
                 new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
             except KeyError:
                 print ('Incorrect argument. Use on/1, off/0, '
                        'or nothing for a toggle.')
                 return
         else:
             # toggle
             new_pdb = not self.shell.call_pdb
 
         # set on the shell
         self.shell.call_pdb = new_pdb
         print 'Automatic pdb calling has been turned',on_off(new_pdb)
 
     def magic_debug(self, parameter_s=''):
         """Activate the interactive debugger in post-mortem mode.
 
         If an exception has just occurred, this lets you inspect its stack
         frames interactively.  Note that this will always work only on the last
         traceback that occurred, so you must call this quickly after an
         exception that you wish to inspect has fired, because if another one
         occurs, it clobbers the previous one.
 
         If you want IPython to automatically do this on every exception, see
         the %pdb magic for more details.
         """
         
         self.shell.debugger(force=True)
 
     @testdec.skip_doctest
     def magic_prun(self, parameter_s ='',user_mode=1,
                    opts=None,arg_lst=None,prog_ns=None):
 
         """Run a statement through the python code profiler.
 
         Usage:
           %prun [options] statement
 
         The given statement (which doesn't require quote marks) is run via the
         python profiler in a manner similar to the profile.run() function.
         Namespaces are internally managed to work correctly; profile.run
         cannot be used in IPython because it makes certain assumptions about
         namespaces which do not hold under IPython.
 
         Options:
 
         -l <limit>: you can place restrictions on what or how much of the
         profile gets printed. The limit value can be:
 
           * A string: only information for function names containing this string
           is printed.
 
           * An integer: only these many lines are printed.
 
           * A float (between 0 and 1): this fraction of the report is printed
           (for example, use a limit of 0.4 to see the topmost 40% only).
 
         You can combine several limits with repeated use of the option. For
         example, '-l __init__ -l 5' will print only the topmost 5 lines of
         information about class constructors.
 
         -r: return the pstats.Stats object generated by the profiling. This
         object has all the information about the profile in it, and you can
         later use it for further analysis or in other functions.
 
        -s <key>: sort profile by given key. You can provide more than one key
         by using the option several times: '-s key1 -s key2 -s key3...'. The
         default sorting key is 'time'.
 
         The following is copied verbatim from the profile documentation
         referenced below:
 
         When more than one key is provided, additional keys are used as
         secondary criteria when the there is equality in all keys selected
         before them.
         
         Abbreviations can be used for any key names, as long as the
         abbreviation is unambiguous.  The following are the keys currently
         defined:
 
                 Valid Arg       Meaning
                   "calls"      call count
                   "cumulative" cumulative time
                   "file"       file name
                   "module"     file name
                   "pcalls"     primitive call count
                   "line"       line number
                   "name"       function name
                   "nfl"        name/file/line
                   "stdname"    standard name
                   "time"       internal time
 
         Note that all sorts on statistics are in descending order (placing
         most time consuming items first), where as name, file, and line number
         searches are in ascending order (i.e., alphabetical). The subtle
         distinction between "nfl" and "stdname" is that the standard name is a
         sort of the name as printed, which means that the embedded line
         numbers get compared in an odd way.  For example, lines 3, 20, and 40
         would (if the file names were the same) appear in the string order
         "20" "3" and "40".  In contrast, "nfl" does a numeric compare of the
         line numbers.  In fact, sort_stats("nfl") is the same as
         sort_stats("name", "file", "line").
 
         -T <filename>: save profile results as shown on screen to a text
         file. The profile is still shown on screen.
 
         -D <filename>: save (via dump_stats) profile statistics to given
         filename. This data is in a format understod by the pstats module, and
         is generated by a call to the dump_stats() method of profile
         objects. The profile is still shown on screen.
 
         If you want to run complete programs under the profiler's control, use
         '%run -p [prof_opts] filename.py [args to program]' where prof_opts
         contains profiler specific options as described here.
         
         You can read the complete documentation for the profile module with::
         
           In [1]: import profile; profile.help()
         """
 
         opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
         # protect user quote marks
         parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
         
         if user_mode:  # regular user call
             opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
                                               list_all=1)
             namespace = self.shell.user_ns
         else:  # called to run a program by %run -p
             try:
                 filename = get_py_filename(arg_lst[0])
             except IOError,msg:
                 error(msg)
                 return
 
             arg_str = 'execfile(filename,prog_ns)'
             namespace = locals()
 
         opts.merge(opts_def)
         
         prof = profile.Profile()
         try:
             prof = prof.runctx(arg_str,namespace,namespace)
             sys_exit = ''
         except SystemExit:
             sys_exit = """*** SystemExit exception caught in code being profiled."""
 
         stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
 
         lims = opts.l
         if lims:
             lims = []  # rebuild lims with ints/floats/strings
             for lim in opts.l:
                 try:
                     lims.append(int(lim))
                 except ValueError:
                     try:
                         lims.append(float(lim))
                     except ValueError:
                         lims.append(lim)
                     
         # Trap output.
         stdout_trap = StringIO()
 
         if hasattr(stats,'stream'):
             # In newer versions of python, the stats object has a 'stream'
             # attribute to write into.
             stats.stream = stdout_trap
             stats.print_stats(*lims)
         else:
             # For older versions, we manually redirect stdout during printing
             sys_stdout = sys.stdout
             try:
                 sys.stdout = stdout_trap
                 stats.print_stats(*lims)
             finally:
                 sys.stdout = sys_stdout
                 
         output = stdout_trap.getvalue()
         output = output.rstrip()
 
         page(output,screen_lines=self.shell.rc.screen_length)
         print sys_exit,
 
         dump_file = opts.D[0]
         text_file = opts.T[0]
         if dump_file:
             prof.dump_stats(dump_file)
             print '\n*** Profile stats marshalled to file',\
                   `dump_file`+'.',sys_exit
         if text_file:
             pfile = file(text_file,'w')
             pfile.write(output)
             pfile.close()
             print '\n*** Profile printout saved to text file',\
                   `text_file`+'.',sys_exit
 
         if opts.has_key('r'):
             return stats
         else:
             return None
 
     @testdec.skip_doctest
     def magic_run(self, parameter_s ='',runner=None,
                   file_finder=get_py_filename):
         """Run the named file inside IPython as a program.
 
         Usage:\\
           %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
         
         Parameters after the filename are passed as command-line arguments to
         the program (put in sys.argv). Then, control returns to IPython's
         prompt.
 
         This is similar to running at a system prompt:\\
           $ python file args\\
         but with the advantage of giving you IPython's tracebacks, and of
         loading all variables into your interactive namespace for further use
         (unless -p is used, see below).
 
         The file is executed in a namespace initially consisting only of
         __name__=='__main__' and sys.argv constructed as indicated. It thus
         sees its environment as if it were being run as a stand-alone program
         (except for sharing global objects such as previously imported
         modules). But after execution, the IPython interactive namespace gets
         updated with all variables defined in the program (except for __name__
         and sys.argv). This allows for very convenient loading of code for
         interactive work, while giving each program a 'clean sheet' to run in.
 
         Options:
         
         -n: __name__ is NOT set to '__main__', but to the running file's name
         without extension (as python does under import).  This allows running
         scripts and reloading the definitions in them without calling code
         protected by an ' if __name__ == "__main__" ' clause.
 
         -i: run the file in IPython's namespace instead of an empty one. This
         is useful if you are experimenting with code written in a text editor
         which depends on variables defined interactively.
 
         -e: ignore sys.exit() calls or SystemExit exceptions in the script
         being run.  This is particularly useful if IPython is being used to
         run unittests, which always exit with a sys.exit() call.  In such
         cases you are interested in the output of the test results, not in
         seeing a traceback of the unittest module.
 
         -t: print timing information at the end of the run.  IPython will give
         you an estimated CPU time consumption for your script, which under
         Unix uses the resource module to avoid the wraparound problems of
         time.clock().  Under Unix, an estimate of time spent on system tasks
         is also given (for Windows platforms this is reported as 0.0).
 
         If -t is given, an additional -N<N> option can be given, where <N>
         must be an integer indicating how many times you want the script to
         run.  The final timing report will include total and per run results.
 
         For example (testing the script uniq_stable.py):
 
             In [1]: run -t uniq_stable
 
             IPython CPU timings (estimated):\\
               User  :    0.19597 s.\\
               System:        0.0 s.\\
 
             In [2]: run -t -N5 uniq_stable
 
             IPython CPU timings (estimated):\\
             Total runs performed: 5\\
               Times :      Total       Per run\\
               User  :   0.910862 s,  0.1821724 s.\\
               System:        0.0 s,        0.0 s.
 
         -d: run your program under the control of pdb, the Python debugger.
         This allows you to execute your program step by step, watch variables,
         etc.  Internally, what IPython does is similar to calling:
         
           pdb.run('execfile("YOURFILENAME")')
 
         with a breakpoint set on line 1 of your file.  You can change the line
         number for this automatic breakpoint to be <N> by using the -bN option
         (where N must be an integer).  For example:
 
           %run -d -b40 myscript
 
         will set the first breakpoint at line 40 in myscript.py.  Note that
         the first breakpoint must be set on a line which actually does
         something (not a comment or docstring) for it to stop execution.
 
         When the pdb debugger starts, you will see a (Pdb) prompt.  You must
         first enter 'c' (without qoutes) to start execution up to the first
         breakpoint.
 
         Entering 'help' gives information about the use of the debugger.  You
         can easily see pdb's full documentation with "import pdb;pdb.help()"
         at a prompt.
 
         -p: run program under the control of the Python profiler module (which
         prints a detailed report of execution times, function calls, etc).
 
         You can pass other options after -p which affect the behavior of the
         profiler itself. See the docs for %prun for details.
 
         In this mode, the program's variables do NOT propagate back to the
         IPython interactive namespace (because they remain in the namespace
         where the profiler executes them).
 
         Internally this triggers a call to %prun, see its documentation for
         details on the options available specifically for profiling.
 
         There is one special usage for which the text above doesn't apply:
         if the filename ends with .ipy, the file is run as ipython script,
         just as if the commands were written on IPython prompt.
         """
 
         # get arguments and set sys.argv for program to be run.
         opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
                                           mode='list',list_all=1)
 
         try:
             filename = file_finder(arg_lst[0])
         except IndexError:
             warn('you must provide at least a filename.')
             print '\n%run:\n',OInspect.getdoc(self.magic_run)
             return
         except IOError,msg:
             error(msg)
             return
 
         if filename.lower().endswith('.ipy'):
             self.api.runlines(open(filename).read())
             return
         
         # Control the response to exit() calls made by the script being run
         exit_ignore = opts.has_key('e')
         
         # Make sure that the running script gets a proper sys.argv as if it
         # were run from a system shell.
         save_argv = sys.argv # save it for later restoring
         sys.argv = [filename]+ arg_lst[1:]  # put in the proper filename
 
         if opts.has_key('i'):
             # Run in user's interactive namespace
             prog_ns = self.shell.user_ns
             __name__save = self.shell.user_ns['__name__']
             prog_ns['__name__'] = '__main__'
             main_mod = self.shell.new_main_mod(prog_ns)
         else:
             # Run in a fresh, empty namespace
             if opts.has_key('n'):
                 name = os.path.splitext(os.path.basename(filename))[0]
             else:
                 name = '__main__'
 
             main_mod = self.shell.new_main_mod()
             prog_ns = main_mod.__dict__
             prog_ns['__name__'] = name
 
         # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
         # set the __file__ global in the script's namespace
         prog_ns['__file__'] = filename
 
         # pickle fix.  See iplib for an explanation.  But we need to make sure
         # that, if we overwrite __main__, we replace it at the end
         main_mod_name = prog_ns['__name__']
 
         if main_mod_name == '__main__':
             restore_main = sys.modules['__main__']
         else:
             restore_main = False
 
         # This needs to be undone at the end to prevent holding references to
         # every single object ever created.
         sys.modules[main_mod_name] = main_mod
         
         stats = None
         try:
             self.shell.savehist()
 
             if opts.has_key('p'):
                 stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
             else:
                 if opts.has_key('d'):
                     deb = debugger.Pdb(self.shell.rc.colors)
                     # reset Breakpoint state, which is moronically kept
                     # in a class
                     bdb.Breakpoint.next = 1
                     bdb.Breakpoint.bplist = {}
                     bdb.Breakpoint.bpbynumber = [None]
                     # Set an initial breakpoint to stop execution
                     maxtries = 10
                     bp = int(opts.get('b',[1])[0])
                     checkline = deb.checkline(filename,bp)
                     if not checkline:
                         for bp in range(bp+1,bp+maxtries+1):
                             if deb.checkline(filename,bp):
                                 break
                         else:
                             msg = ("\nI failed to find a valid line to set "
                                    "a breakpoint\n"
                                    "after trying up to line: %s.\n"
                                    "Please set a valid breakpoint manually "
                                    "with the -b option." % bp)
                             error(msg)
                             return
                     # if we find a good linenumber, set the breakpoint
                     deb.do_break('%s:%s' % (filename,bp))
                     # Start file run
                     print "NOTE: Enter 'c' at the",
                     print "%s prompt to start your script." % deb.prompt
                     try:
                         deb.run('execfile("%s")' % filename,prog_ns)
                         
                     except:
                         etype, value, tb = sys.exc_info()
                         # Skip three frames in the traceback: the %run one,
                         # one inside bdb.py, and the command-line typed by the
                         # user (run by exec in pdb itself).
                         self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
                 else:
                     if runner is None:
                         runner = self.shell.safe_execfile
                     if opts.has_key('t'):
                         # timed execution
                         try:
                             nruns = int(opts['N'][0])
                             if nruns < 1:
                                 error('Number of runs must be >=1')
                                 return
                         except (KeyError):
                             nruns = 1
                         if nruns == 1:
                             t0 = clock2()
                             runner(filename,prog_ns,prog_ns,
                                    exit_ignore=exit_ignore)
                             t1 = clock2()
                             t_usr = t1[0]-t0[0]
                             t_sys = t1[1]-t0[1]
                             print "\nIPython CPU timings (estimated):"
                             print "  User  : %10s s." % t_usr
                             print "  System: %10s s." % t_sys
                         else:
                             runs = range(nruns)
                             t0 = clock2()
                             for nr in runs:
                                 runner(filename,prog_ns,prog_ns,
                                        exit_ignore=exit_ignore)
                             t1 = clock2()
                             t_usr = t1[0]-t0[0]
                             t_sys = t1[1]-t0[1]
                             print "\nIPython CPU timings (estimated):"
                             print "Total runs performed:",nruns
                             print "  Times : %10s    %10s" % ('Total','Per run')
                             print "  User  : %10s s, %10s s." % (t_usr,t_usr/nruns)
                             print "  System: %10s s, %10s s." % (t_sys,t_sys/nruns)
                             
                     else:
                         # regular execution
                         runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
 
                 if opts.has_key('i'):
                     self.shell.user_ns['__name__'] = __name__save
                 else:
                     # The shell MUST hold a reference to prog_ns so after %run
                     # exits, the python deletion mechanism doesn't zero it out
                     # (leaving dangling references).
                     self.shell.cache_main_mod(prog_ns,filename)
                     # update IPython interactive namespace
                     del prog_ns['__name__']
                     self.shell.user_ns.update(prog_ns)
         finally:
             # It's a bit of a mystery why, but __builtins__ can change from
             # being a module to becoming a dict missing some key data after
             # %run.  As best I can see, this is NOT something IPython is doing
             # at all, and similar problems have been reported before:
             # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
             # Since this seems to be done by the interpreter itself, the best
             # we can do is to at least restore __builtins__ for the user on
             # exit.
             self.shell.user_ns['__builtins__'] = __builtin__
             
             # Ensure key global structures are restored
             sys.argv = save_argv
             if restore_main:
                 sys.modules['__main__'] = restore_main
             else:
                 # Remove from sys.modules the reference to main_mod we'd
                 # added.  Otherwise it will trap references to objects
                 # contained therein.
                 del sys.modules[main_mod_name]
 
             self.shell.reloadhist()
                 
         return stats
 
     def magic_runlog(self, parameter_s =''):
         """Run files as logs.
 
         Usage:\\
           %runlog file1 file2 ...
 
         Run the named files (treating them as log files) in sequence inside
         the interpreter, and return to the prompt.  This is much slower than
         %run because each line is executed in a try/except block, but it
         allows running files with syntax errors in them.
 
         Normally IPython will guess when a file is one of its own logfiles, so
         you can typically use %run even for logs. This shorthand allows you to
         force any file to be treated as a log file."""
 
         for f in parameter_s.split():
             self.shell.safe_execfile(f,self.shell.user_ns,
                                      self.shell.user_ns,islog=1)
 
     @testdec.skip_doctest
     def magic_timeit(self, parameter_s =''):
         """Time execution of a Python statement or expression
 
         Usage:\\
           %timeit [-n<N> -r<R> [-t|-c]] statement
 
         Time execution of a Python statement or expression using the timeit
         module.
 
         Options:
         -n<N>: execute the given statement <N> times in a loop. If this value
         is not given, a fitting value is chosen. 
         
         -r<R>: repeat the loop iteration <R> times and take the best result.
         Default: 3
         
         -t: use time.time to measure the time, which is the default on Unix.
         This function measures wall time.
         
         -c: use time.clock to measure the time, which is the default on
         Windows and measures wall time. On Unix, resource.getrusage is used
         instead and returns the CPU user time.
 
         -p<P>: use a precision of <P> digits to display the timing result.
         Default: 3
 
         
         Examples:
 
           In [1]: %timeit pass
           10000000 loops, best of 3: 53.3 ns per loop
 
           In [2]: u = None
 
           In [3]: %timeit u is None
           10000000 loops, best of 3: 184 ns per loop
 
           In [4]: %timeit -r 4 u == None
           1000000 loops, best of 4: 242 ns per loop
 
           In [5]: import time
 
           In [6]: %timeit -n1 time.sleep(2)
           1 loops, best of 3: 2 s per loop
           
 
         The times reported by %timeit will be slightly higher than those
         reported by the timeit.py script when variables are accessed. This is
         due to the fact that %timeit executes the statement in the namespace
         of the shell, compared with timeit.py, which uses a single setup
         statement to import function or create variables. Generally, the bias
         does not matter as long as results from timeit.py are not mixed with
         those from %timeit."""
 
         import timeit
         import math
 
         # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
         # certain terminals.  Until we figure out a robust way of
         # auto-detecting if the terminal can deal with it, use plain 'us' for
         # microseconds.  I am really NOT happy about disabling the proper
         # 'micro' prefix, but crashing is worse... If anyone knows what the
         # right solution for this is, I'm all ears...
         #
         # Note: using
         #
         # s = u'\xb5'
         # s.encode(sys.getdefaultencoding())
         #
         # is not sufficient, as I've seen terminals where that fails but
         # print s
         #
         # succeeds
         #
         # See bug: https://bugs.launchpad.net/ipython/+bug/348466
         
         #units = [u"s", u"ms",u'\xb5',"ns"]
         units = [u"s", u"ms",u'us',"ns"]
         
         scaling = [1, 1e3, 1e6, 1e9]
 
         opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
                                         posix=False)
         if stmt == "":
             return
         timefunc = timeit.default_timer
         number = int(getattr(opts, "n", 0))
         repeat = int(getattr(opts, "r", timeit.default_repeat))
         precision = int(getattr(opts, "p", 3))
         if hasattr(opts, "t"):
             timefunc = time.time
         if hasattr(opts, "c"):
             timefunc = clock
 
         timer = timeit.Timer(timer=timefunc)
         # this code has tight coupling to the inner workings of timeit.Timer,
         # but is there a better way to achieve that the code stmt has access
         # to the shell namespace?
 
         src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
                                  'setup': "pass"}
         # Track compilation time so it can be reported if too long
         # Minimum time above which compilation time will be reported
         tc_min = 0.1
         
         t0 = clock()
         code = compile(src, "<magic-timeit>", "exec")
         tc = clock()-t0
         
         ns = {}
         exec code in self.shell.user_ns, ns
         timer.inner = ns["inner"]
         
         if number == 0:
             # determine number so that 0.2 <= total time < 2.0
             number = 1
             for i in range(1, 10):
                 if timer.timeit(number) >= 0.2:
                     break
                 number *= 10
         
         best = min(timer.repeat(repeat, number)) / number
 
         if best > 0.0:
             order = min(-int(math.floor(math.log10(best)) // 3), 3)
         else:
             order = 3
         print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
                                                           precision,
                                                           best * scaling[order],
                                                           units[order])
         if tc > tc_min:
             print "Compiler time: %.2f s" % tc
 
     @testdec.skip_doctest
     def magic_time(self,parameter_s = ''):
         """Time execution of a Python statement or expression.
 
         The CPU and wall clock times are printed, and the value of the
         expression (if any) is returned.  Note that under Win32, system time
         is always reported as 0, since it can not be measured.
 
         This function provides very basic timing functionality.  In Python
         2.3, the timeit module offers more control and sophistication, so this
         could be rewritten to use it (patches welcome).
         
         Some examples:
 
           In [1]: time 2**128
           CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
           Wall time: 0.00
           Out[1]: 340282366920938463463374607431768211456L
 
           In [2]: n = 1000000
 
           In [3]: time sum(range(n))
           CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
           Wall time: 1.37
           Out[3]: 499999500000L
 
           In [4]: time print 'hello world'
           hello world
           CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
           Wall time: 0.00
 
           Note that the time needed by Python to compile the given expression
           will be reported if it is more than 0.1s.  In this example, the
           actual exponentiation is done by Python at compilation time, so while
           the expression can take a noticeable amount of time to compute, that
           time is purely due to the compilation:
 
           In [5]: time 3**9999;
           CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
           Wall time: 0.00 s
 
           In [6]: time 3**999999;
           CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
           Wall time: 0.00 s
           Compiler : 0.78 s
           """
         
         # fail immediately if the given expression can't be compiled
         
         expr = self.shell.prefilter(parameter_s,False)
 
         # Minimum time above which compilation time will be reported
         tc_min = 0.1
         
         try:
             mode = 'eval'
             t0 = clock()
             code = compile(expr,'<timed eval>',mode)
             tc = clock()-t0
         except SyntaxError:
             mode = 'exec'
             t0 = clock()
             code = compile(expr,'<timed exec>',mode)
             tc = clock()-t0
         # skew measurement as little as possible
         glob = self.shell.user_ns
         clk = clock2
         wtime = time.time
         # time execution
         wall_st = wtime()
         if mode=='eval':
             st = clk()
             out = eval(code,glob)
             end = clk()
         else:
             st = clk()
             exec code in glob
             end = clk()
             out = None
         wall_end = wtime()
         # Compute actual times and report
         wall_time = wall_end-wall_st
         cpu_user = end[0]-st[0]
         cpu_sys = end[1]-st[1]
         cpu_tot = cpu_user+cpu_sys
         print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
               (cpu_user,cpu_sys,cpu_tot)
         print "Wall time: %.2f s" % wall_time
         if tc > tc_min:
             print "Compiler : %.2f s" % tc
         return out
 
     @testdec.skip_doctest
     def magic_macro(self,parameter_s = ''):
         """Define a set of input lines as a macro for future re-execution.
 
         Usage:\\
           %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
 
         Options:
         
           -r: use 'raw' input.  By default, the 'processed' history is used,
           so that magics are loaded in their transformed version to valid
           Python.  If this option is given, the raw input as typed as the
           command line is used instead.
 
         This will define a global variable called `name` which is a string
         made of joining the slices and lines you specify (n1,n2,... numbers
         above) from your input history into a single string. This variable
         acts like an automatic function which re-executes those lines as if
         you had typed them. You just type 'name' at the prompt and the code
         executes.
 
         The notation for indicating number ranges is: n1-n2 means 'use line
         numbers n1,...n2' (the endpoint is included).  That is, '5-7' means
         using the lines numbered 5,6 and 7.
 
         Note: as a 'hidden' feature, you can also use traditional python slice
         notation, where N:M means numbers N through M-1.
 
         For example, if your history contains (%hist prints it):
         
           44: x=1
           45: y=3
           46: z=x+y
           47: print x
           48: a=5
           49: print 'x',x,'y',y
 
         you can create a macro with lines 44 through 47 (included) and line 49
         called my_macro with:
 
           In [55]: %macro my_macro 44-47 49
 
         Now, typing `my_macro` (without quotes) will re-execute all this code
         in one pass.
 
         You don't need to give the line-numbers in order, and any given line
         number can appear multiple times. You can assemble macros with any
         lines from your input history in any order.
 
         The macro is a simple object which holds its value in an attribute,
         but IPython's display system checks for macros and executes them as
         code instead of printing them when you type their name.
 
         You can view a macro's contents by explicitly printing it with:
         
           'print macro_name'.
 
         For one-off cases which DON'T contain magic function calls in them you
         can obtain similar results by explicitly executing slices from your
         input history with:
 
           In [60]: exec In[44:48]+In[49]"""
 
         opts,args = self.parse_options(parameter_s,'r',mode='list')
         if not args:
             macs = [k for k,v in self.shell.user_ns.items() if isinstance(v, Macro)]
             macs.sort()
             return macs
         if len(args) == 1:
             raise UsageError(
                 "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
         name,ranges = args[0], args[1:]
         
         #print 'rng',ranges  # dbg
         lines = self.extract_input_slices(ranges,opts.has_key('r'))
         macro = Macro(lines)
         self.shell.user_ns.update({name:macro})
         print 'Macro `%s` created. To execute, type its name (without quotes).' % name
         print 'Macro contents:'
         print macro,
 
     def magic_save(self,parameter_s = ''):
         """Save a set of lines to a given filename.
 
         Usage:\\
           %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
 
         Options:
         
           -r: use 'raw' input.  By default, the 'processed' history is used,
           so that magics are loaded in their transformed version to valid
           Python.  If this option is given, the raw input as typed as the
           command line is used instead.
 
         This function uses the same syntax as %macro for line extraction, but
         instead of creating a macro it saves the resulting string to the
         filename you specify.
 
         It adds a '.py' extension to the file if you don't do so yourself, and
         it asks for confirmation before overwriting existing files."""
 
         opts,args = self.parse_options(parameter_s,'r',mode='list')
         fname,ranges = args[0], args[1:]
         if not fname.endswith('.py'):
             fname += '.py'
         if os.path.isfile(fname):
             ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
             if ans.lower() not in ['y','yes']:
                 print 'Operation cancelled.'
                 return
         cmds = ''.join(self.extract_input_slices(ranges,opts.has_key('r')))
         f = file(fname,'w')
         f.write(cmds)
         f.close()
         print 'The following commands were written to file `%s`:' % fname
         print cmds
 
     def _edit_macro(self,mname,macro):
         """open an editor with the macro data in a file"""
         filename = self.shell.mktempfile(macro.value)
         self.shell.hooks.editor(filename)
 
         # and make a new macro object, to replace the old one
         mfile = open(filename)
         mvalue = mfile.read()
         mfile.close()
         self.shell.user_ns[mname] = Macro(mvalue)
 
     def magic_ed(self,parameter_s=''):
         """Alias to %edit."""
         return self.magic_edit(parameter_s)
 
     @testdec.skip_doctest
     def magic_edit(self,parameter_s='',last_call=['','']):
         """Bring up an editor and execute the resulting code.
 
         Usage:
           %edit [options] [args]
 
         %edit runs IPython's editor hook.  The default version of this hook is
         set to call the __IPYTHON__.rc.editor command.  This is read from your
         environment variable $EDITOR.  If this isn't found, it will default to
         vi under Linux/Unix and to notepad under Windows.  See the end of this
         docstring for how to change the editor hook.
 
         You can also set the value of this editor via the command line option
         '-editor' or in your ipythonrc file. This is useful if you wish to use
         specifically for IPython an editor different from your typical default
         (and for Windows users who typically don't set environment variables).
 
         This command allows you to conveniently edit multi-line code right in
         your IPython session.
         
         If called without arguments, %edit opens up an empty editor with a
         temporary file and will execute the contents of this file when you
         close it (don't forget to save it!).
 
 
         Options:
 
         -n <number>: open the editor at a specified line number.  By default,
         the IPython editor hook uses the unix syntax 'editor +N filename', but
         you can configure this by providing your own modified hook if your
         favorite editor supports line-number specifications with a different
         syntax.
         
         -p: this will call the editor with the same data as the previous time
         it was used, regardless of how long ago (in your current session) it
         was.
 
         -r: use 'raw' input.  This option only applies to input taken from the
         user's history.  By default, the 'processed' history is used, so that
         magics are loaded in their transformed version to valid Python.  If
         this option is given, the raw input as typed as the command line is
         used instead.  When you exit the editor, it will be executed by
         IPython's own processor.
         
         -x: do not execute the edited code immediately upon exit. This is
         mainly useful if you are editing programs which need to be called with
         command line arguments, which you can then do using %run.
 
 
         Arguments:
 
         If arguments are given, the following possibilites exist:
 
         - The arguments are numbers or pairs of colon-separated numbers (like
         1 4:8 9). These are interpreted as lines of previous input to be
         loaded into the editor. The syntax is the same of the %macro command.
 
         - If the argument doesn't start with a number, it is evaluated as a
         variable and its contents loaded into the editor. You can thus edit
         any string which contains python code (including the result of
         previous edits).
 
         - If the argument is the name of an object (other than a string),
         IPython will try to locate the file where it was defined and open the
         editor at the point where it is defined. You can use `%edit function`
         to load an editor exactly at the point where 'function' is defined,
         edit it and have the file be executed automatically.
 
         If the object is a macro (see %macro for details), this opens up your
         specified editor with a temporary file containing the macro's data.
         Upon exit, the macro is reloaded with the contents of the file.
 
         Note: opening at an exact line is only supported under Unix, and some
         editors (like kedit and gedit up to Gnome 2.8) do not understand the
         '+NUMBER' parameter necessary for this feature. Good editors like
         (X)Emacs, vi, jed, pico and joe all do.
 
         - If the argument is not found as a variable, IPython will look for a
         file with that name (adding .py if necessary) and load it into the
         editor. It will execute its contents with execfile() when you exit,
         loading any code in the file into your interactive namespace.
 
         After executing your code, %edit will return as output the code you
         typed in the editor (except when it was an existing file). This way
         you can reload the code in further invocations of %edit as a variable,
         via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
         the output.
 
         Note that %edit is also available through the alias %ed.
 
         This is an example of creating a simple function inside the editor and
         then modifying it. First, start up the editor:
 
         In [1]: ed
         Editing... done. Executing edited code...
         Out[1]: 'def foo():n    print "foo() was defined in an editing session"n'
 
         We can then call the function foo():
         
         In [2]: foo()
         foo() was defined in an editing session
 
         Now we edit foo.  IPython automatically loads the editor with the
         (temporary) file where foo() was previously defined:
         
         In [3]: ed foo
         Editing... done. Executing edited code...
 
         And if we call foo() again we get the modified version:
         
         In [4]: foo()
         foo() has now been changed!
 
         Here is an example of how to edit a code snippet successive
         times. First we call the editor:
 
         In [5]: ed
         Editing... done. Executing edited code...
         hello
         Out[5]: "print 'hello'n"
 
         Now we call it again with the previous output (stored in _):
 
         In [6]: ed _
         Editing... done. Executing edited code...
         hello world
         Out[6]: "print 'hello world'n"
 
         Now we call it with the output #8 (stored in _8, also as Out[8]):
 
         In [7]: ed _8
         Editing... done. Executing edited code...
         hello again
         Out[7]: "print 'hello again'n"
 
 
         Changing the default editor hook:
 
         If you wish to write your own editor hook, you can put it in a
         configuration file which you load at startup time.  The default hook
         is defined in the IPython.core.hooks module, and you can use that as a
         starting example for further modifications.  That file also has
         general instructions on how to set a new hook for use once you've
         defined it."""
         
         # FIXME: This function has become a convoluted mess.  It needs a
         # ground-up rewrite with clean, simple logic.
 
         def make_filename(arg):
             "Make a filename from the given args"
             try:
                 filename = get_py_filename(arg)
             except IOError:
                 if args.endswith('.py'):
                     filename = arg
                 else:
                     filename = None
             return filename
 
         # custom exceptions
         class DataIsObject(Exception): pass
 
         opts,args = self.parse_options(parameter_s,'prxn:')
         # Set a few locals from the options for convenience:
         opts_p = opts.has_key('p')
         opts_r = opts.has_key('r')
         
         # Default line number value
         lineno = opts.get('n',None)
 
         if opts_p:
             args = '_%s' % last_call[0]
             if not self.shell.user_ns.has_key(args):
                 args = last_call[1]
             
         # use last_call to remember the state of the previous call, but don't
         # let it be clobbered by successive '-p' calls.
         try:
             last_call[0] = self.shell.outputcache.prompt_count
             if not opts_p:
                 last_call[1] = parameter_s
         except:
             pass
 
         # by default this is done with temp files, except when the given
         # arg is a filename
         use_temp = 1
 
         if re.match(r'\d',args):
             # Mode where user specifies ranges of lines, like in %macro.
             # This means that you can't edit files whose names begin with
             # numbers this way. Tough.
             ranges = args.split()
             data = ''.join(self.extract_input_slices(ranges,opts_r))
         elif args.endswith('.py'):
             filename = make_filename(args)
             data = ''
             use_temp = 0
         elif args:
             try:
                 # Load the parameter given as a variable. If not a string,
                 # process it as an object instead (below)
 
                 #print '*** args',args,'type',type(args)  # dbg
                 data = eval(args,self.shell.user_ns)
                 if not type(data) in StringTypes:
                     raise DataIsObject
 
             except (NameError,SyntaxError):
                 # given argument is not a variable, try as a filename
                 filename = make_filename(args)
                 if filename is None:
                     warn("Argument given (%s) can't be found as a variable "
                          "or as a filename." % args)
                     return
 
                 data = ''
                 use_temp = 0
             except DataIsObject:
 
                 # macros have a special edit function
                 if isinstance(data,Macro):
                     self._edit_macro(args,data)
                     return
                                 
                 # For objects, try to edit the file where they are defined
                 try:
                     filename = inspect.getabsfile(data)
                     if 'fakemodule' in filename.lower() and inspect.isclass(data):                     
                         # class created by %edit? Try to find source
                         # by looking for method definitions instead, the
                         # __module__ in those classes is FakeModule.
                         attrs = [getattr(data, aname) for aname in dir(data)]
                         for attr in attrs:
                             if not inspect.ismethod(attr):
                                 continue
                             filename = inspect.getabsfile(attr)
                             if filename and 'fakemodule' not in filename.lower():
                                 # change the attribute to be the edit target instead
                                 data = attr 
                                 break
                     
                     datafile = 1
                 except TypeError:
                     filename = make_filename(args)
                     datafile = 1
                     warn('Could not find file where `%s` is defined.\n'
                          'Opening a file named `%s`' % (args,filename))
                 # Now, make sure we can actually read the source (if it was in
                 # a temp file it's gone by now).
                 if datafile:
                     try:
                         if lineno is None:
                             lineno = inspect.getsourcelines(data)[1]
                     except IOError:
                         filename = make_filename(args)
                         if filename is None:
                             warn('The file `%s` where `%s` was defined cannot '
                                  'be read.' % (filename,data))
                             return
                 use_temp = 0
         else:
             data = ''
 
         if use_temp:
             filename = self.shell.mktempfile(data)
             print 'IPython will make a temporary file named:',filename
 
         # do actual editing here
         print 'Editing...',
         sys.stdout.flush()
         try:
             self.shell.hooks.editor(filename,lineno)
         except ipapi.TryNext:
             warn('Could not open editor')
             return
         
         # XXX TODO: should this be generalized for all string vars?
         # For now, this is special-cased to blocks created by cpaste
         if args.strip() == 'pasted_block':
             self.shell.user_ns['pasted_block'] = file_read(filename)
         
         if opts.has_key('x'):  # -x prevents actual execution
             print
         else:
             print 'done. Executing edited code...'
             if opts_r:
                 self.shell.runlines(file_read(filename))
             else:
                 self.shell.safe_execfile(filename,self.shell.user_ns,
                                          self.shell.user_ns)
         
                                                      
         if use_temp:
             try:
                 return open(filename).read()
             except IOError,msg:
                 if msg.filename == filename:
                     warn('File not found. Did you forget to save?')
                     return
                 else:
                     self.shell.showtraceback()
 
     def magic_xmode(self,parameter_s = ''):
         """Switch modes for the exception handlers.
 
         Valid modes: Plain, Context and Verbose.
 
         If called without arguments, acts as a toggle."""
 
         def xmode_switch_err(name):
             warn('Error changing %s exception modes.\n%s' %
                  (name,sys.exc_info()[1]))
 
         shell = self.shell
         new_mode = parameter_s.strip().capitalize()
         try:
             shell.InteractiveTB.set_mode(mode=new_mode)
             print 'Exception reporting mode:',shell.InteractiveTB.mode
         except:
             xmode_switch_err('user')
 
         # threaded shells use a special handler in sys.excepthook
         if shell.isthreaded:
             try:
                 shell.sys_excepthook.set_mode(mode=new_mode)
             except:
                 xmode_switch_err('threaded')
             
     def magic_colors(self,parameter_s = ''):
         """Switch color scheme for prompts, info system and exception handlers.
 
         Currently implemented schemes: NoColor, Linux, LightBG.
 
         Color scheme names are not case-sensitive."""
 
         def color_switch_err(name):
             warn('Error changing %s color schemes.\n%s' %
                  (name,sys.exc_info()[1]))
             
         
         new_scheme = parameter_s.strip()
         if not new_scheme:
             raise UsageError(
                 "%colors: you must specify a color scheme. See '%colors?'")
             return
         # local shortcut
         shell = self.shell
 
         import IPython.rlineimpl as readline
 
         if not readline.have_readline and sys.platform == "win32":
             msg = """\
 Proper color support under MS Windows requires the pyreadline library.
 You can find it at:
 http://ipython.scipy.org/moin/PyReadline/Intro
 Gary's readline needs the ctypes module, from:
 http://starship.python.net/crew/theller/ctypes
 (Note that ctypes is already part of Python versions 2.5 and newer).
 
 Defaulting color scheme to 'NoColor'"""
             new_scheme = 'NoColor'
             warn(msg)
         
         # readline option is 0
         if not shell.has_readline:
             new_scheme = 'NoColor'
             
         # Set prompt colors
         try:
             shell.outputcache.set_colors(new_scheme)
         except:
             color_switch_err('prompt')
         else:
             shell.rc.colors = \
                        shell.outputcache.color_table.active_scheme_name
         # Set exception colors
         try:
             shell.InteractiveTB.set_colors(scheme = new_scheme)
             shell.SyntaxTB.set_colors(scheme = new_scheme)
         except:
             color_switch_err('exception')
 
         # threaded shells use a verbose traceback in sys.excepthook
         if shell.isthreaded:
             try:
                 shell.sys_excepthook.set_colors(scheme=new_scheme)
             except:
                 color_switch_err('system exception handler')
         
         # Set info (for 'object?') colors
         if shell.rc.color_info:
             try:
                 shell.inspector.set_active_scheme(new_scheme)
             except:
                 color_switch_err('object inspector')
         else:
             shell.inspector.set_active_scheme('NoColor')
                 
     def magic_color_info(self,parameter_s = ''):
         """Toggle color_info.
 
         The color_info configuration parameter controls whether colors are
         used for displaying object details (by things like %psource, %pfile or
         the '?' system). This function toggles this value with each call.
 
         Note that unless you have a fairly recent pager (less works better
         than more) in your system, using colored object information displays
         will not work properly. Test it and see."""
         
         self.shell.rc.color_info = 1 - self.shell.rc.color_info
         self.magic_colors(self.shell.rc.colors)
         print 'Object introspection functions have now coloring:',
         print ['OFF','ON'][self.shell.rc.color_info]
 
     def magic_Pprint(self, parameter_s=''):
         """Toggle pretty printing on/off."""
         
         self.shell.rc.pprint = 1 - self.shell.rc.pprint
         print 'Pretty printing has been turned', \
               ['OFF','ON'][self.shell.rc.pprint]
         
     def magic_exit(self, parameter_s=''):
         """Exit IPython, confirming if configured to do so.
 
         You can configure whether IPython asks for confirmation upon exit by
         setting the confirm_exit flag in the ipythonrc file."""
 
         self.shell.exit()
 
     def magic_quit(self, parameter_s=''):
         """Exit IPython, confirming if configured to do so (like %exit)"""
 
         self.shell.exit()
         
     def magic_Exit(self, parameter_s=''):
         """Exit IPython without confirmation."""
 
         self.shell.ask_exit()
 
     #......................................................................
     # Functions to implement unix shell-type things
 
     @testdec.skip_doctest
     def magic_alias(self, parameter_s = ''):
         """Define an alias for a system command.
 
         '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
 
         Then, typing 'alias_name params' will execute the system command 'cmd
         params' (from your underlying operating system).
 
         Aliases have lower precedence than magic functions and Python normal
         variables, so if 'foo' is both a Python variable and an alias, the
         alias can not be executed until 'del foo' removes the Python variable.
 
         You can use the %l specifier in an alias definition to represent the
         whole line when the alias is called.  For example:
 
           In [2]: alias all echo "Input in brackets: <%l>"
           In [3]: all hello world
           Input in brackets: <hello world>
 
         You can also define aliases with parameters using %s specifiers (one
         per parameter):
         
           In [1]: alias parts echo first %s second %s
           In [2]: %parts A B
           first A second B
           In [3]: %parts A
           Incorrect number of arguments: 2 expected.
           parts is an alias to: 'echo first %s second %s'
 
         Note that %l and %s are mutually exclusive.  You can only use one or
         the other in your aliases.
 
         Aliases expand Python variables just like system calls using ! or !! 
         do: all expressions prefixed with '$' get expanded.  For details of
         the semantic rules, see PEP-215:
         http://www.python.org/peps/pep-0215.html.  This is the library used by
         IPython for variable expansion.  If you want to access a true shell
         variable, an extra $ is necessary to prevent its expansion by IPython:
 
         In [6]: alias show echo
         In [7]: PATH='A Python string'
         In [8]: show $PATH
         A Python string
         In [9]: show $$PATH
         /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
 
         You can use the alias facility to acess all of $PATH.  See the %rehash
         and %rehashx functions, which automatically create aliases for the
         contents of your $PATH.
 
         If called with no parameters, %alias prints the current alias table."""
 
         par = parameter_s.strip()
         if not par:
             stored = self.db.get('stored_aliases', {} )
             atab = self.shell.alias_table
             aliases = atab.keys()
             aliases.sort()
             res = []
             showlast = []
             for alias in aliases:
                 special = False
                 try:
                     tgt = atab[alias][1]
                 except (TypeError, AttributeError):
                     # unsubscriptable? probably a callable
                     tgt = atab[alias]
                     special = True
                 # 'interesting' aliases
                 if (alias in stored or
                     special or 
                     alias.lower() != os.path.splitext(tgt)[0].lower() or
                     ' ' in tgt):
                     showlast.append((alias, tgt))
                 else:
                     res.append((alias, tgt ))                
             
             # show most interesting aliases last
             res.extend(showlast)
             print "Total number of aliases:",len(aliases)
             return res
         try:
             alias,cmd = par.split(None,1)
         except:
             print OInspect.getdoc(self.magic_alias)
         else:
             nargs = cmd.count('%s')
             if nargs>0 and cmd.find('%l')>=0:
                 error('The %s and %l specifiers are mutually exclusive '
                       'in alias definitions.')
             else:  # all looks OK
                 self.shell.alias_table[alias] = (nargs,cmd)
                 self.shell.alias_table_validate(verbose=0)
     # end magic_alias
 
     def magic_unalias(self, parameter_s = ''):
         """Remove an alias"""
 
         aname = parameter_s.strip()
         if aname in self.shell.alias_table:
             del self.shell.alias_table[aname]
         stored = self.db.get('stored_aliases', {} )
         if aname in stored:
             print "Removing %stored alias",aname
             del stored[aname]
             self.db['stored_aliases'] = stored
             
 
     def magic_rehashx(self, parameter_s = ''):
         """Update the alias table with all executable files in $PATH.
 
         This version explicitly checks that every entry in $PATH is a file
         with execute access (os.X_OK), so it is much slower than %rehash.
 
         Under Windows, it checks executability as a match agains a
         '|'-separated string of extensions, stored in the IPython config
         variable win_exec_ext.  This defaults to 'exe|com|bat'.
         
         This function also resets the root module cache of module completer,
         used on slow filesystems.
         """
         
         
         ip = self.api
 
         # for the benefit of module completer in ipy_completers.py
         del ip.db['rootmodules']
         
         path = [os.path.abspath(os.path.expanduser(p)) for p in 
             os.environ.get('PATH','').split(os.pathsep)]
         path = filter(os.path.isdir,path)
         
         alias_table = self.shell.alias_table
         syscmdlist = []
         if os.name == 'posix':
             isexec = lambda fname:os.path.isfile(fname) and \
                      os.access(fname,os.X_OK)
         else:
 
             try:
                 winext = os.environ['pathext'].replace(';','|').replace('.','')
             except KeyError:
                 winext = 'exe|com|bat|py'
             if 'py' not in winext:
                 winext += '|py'
             execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
             isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
         savedir = os.getcwd()
         try:
             # write the whole loop for posix/Windows so we don't have an if in
             # the innermost part
             if os.name == 'posix':
                 for pdir in path:
                     os.chdir(pdir)
                     for ff in os.listdir(pdir):
                         if isexec(ff) and ff not in self.shell.no_alias:
                             # each entry in the alias table must be (N,name),
                             # where N is the number of positional arguments of the
                             # alias.                            
                             # Dots will be removed from alias names, since ipython
                             # assumes names with dots to be python code
                             alias_table[ff.replace('.','')] = (0,ff)
                             syscmdlist.append(ff)
             else:
                 for pdir in path:
                     os.chdir(pdir)
                     for ff in os.listdir(pdir):
                         base, ext = os.path.splitext(ff)
                         if isexec(ff) and base.lower() not in self.shell.no_alias:
                             if ext.lower() == '.exe':
                                 ff = base
                             alias_table[base.lower().replace('.','')] = (0,ff)
                             syscmdlist.append(ff)
             # Make sure the alias table doesn't contain keywords or builtins
             self.shell.alias_table_validate()
             # Call again init_auto_alias() so we get 'rm -i' and other
             # modified aliases since %rehashx will probably clobber them
             
             # no, we don't want them. if %rehashx clobbers them, good,
             # we'll probably get better versions
             # self.shell.init_auto_alias()
             db = ip.db
             db['syscmdlist'] = syscmdlist
         finally:
             os.chdir(savedir)
         
     def magic_pwd(self, parameter_s = ''):
         """Return the current working directory path."""
         return os.getcwd()
 
     def magic_cd(self, parameter_s=''):
         """Change the current working directory.
 
         This command automatically maintains an internal list of directories
         you visit during your IPython session, in the variable _dh. The
         command %dhist shows this history nicely formatted. You can also
         do 'cd -<tab>' to see directory history conveniently.
 
         Usage:
 
           cd 'dir': changes to directory 'dir'.
 
           cd -: changes to the last visited directory.
 
           cd -<n>: changes to the n-th directory in the directory history.
 
           cd --foo: change to directory that matches 'foo' in history
             
           cd -b <bookmark_name>: jump to a bookmark set by %bookmark
              (note: cd <bookmark_name> is enough if there is no
               directory <bookmark_name>, but a bookmark with the name exists.)
               'cd -b <tab>' allows you to tab-complete bookmark names. 
 
         Options:
 
         -q: quiet.  Do not print the working directory after the cd command is
         executed.  By default IPython's cd command does print this directory,
         since the default prompts do not display path information.
         
         Note that !cd doesn't work for this purpose because the shell where
         !command runs is immediately discarded after executing 'command'."""
 
         parameter_s = parameter_s.strip()
         #bkms = self.shell.persist.get("bookmarks",{})
 
         oldcwd = os.getcwd()
         numcd = re.match(r'(-)(\d+)$',parameter_s)
         # jump in directory history by number
         if numcd:
             nn = int(numcd.group(2))
             try:
                 ps = self.shell.user_ns['_dh'][nn]
             except IndexError:
                 print 'The requested directory does not exist in history.'
                 return
             else:
                 opts = {}
         elif parameter_s.startswith('--'):
             ps = None
             fallback = None
             pat = parameter_s[2:]
             dh = self.shell.user_ns['_dh']
             # first search only by basename (last component)
             for ent in reversed(dh):
                 if pat in os.path.basename(ent) and os.path.isdir(ent):
                     ps = ent
                     break
             
                 if fallback is None and pat in ent and os.path.isdir(ent):
                     fallback = ent
                 
             # if we have no last part match, pick the first full path match
             if ps is None:
                 ps = fallback
             
             if ps is None:
                 print "No matching entry in directory history"
                 return
             else:
                 opts = {}
                 
             
         else:
             #turn all non-space-escaping backslashes to slashes, 
             # for c:\windows\directory\names\
             parameter_s = re.sub(r'\\(?! )','/', parameter_s)            
             opts,ps = self.parse_options(parameter_s,'qb',mode='string')
         # jump to previous
         if ps == '-':
             try:
                 ps = self.shell.user_ns['_dh'][-2]
             except IndexError:
                 raise UsageError('%cd -: No previous directory to change to.')
         # jump to bookmark if needed
         else:
             if not os.path.isdir(ps) or opts.has_key('b'):
                 bkms = self.db.get('bookmarks', {})
             
                 if bkms.has_key(ps):
                     target = bkms[ps]
                     print '(bookmark:%s) -> %s' % (ps,target)
                     ps = target
                 else:
                     if opts.has_key('b'):
                         raise UsageError("Bookmark '%s' not found.  "
                               "Use '%%bookmark -l' to see your bookmarks." % ps)
             
         # at this point ps should point to the target dir
         if ps:
             try:                
                 os.chdir(os.path.expanduser(ps))
                 if self.shell.rc.term_title:
                     #print 'set term title:',self.shell.rc.term_title  # dbg
                     platutils.set_term_title('IPy ' + abbrev_cwd())
             except OSError:
                 print sys.exc_info()[1]
             else:
                 cwd = os.getcwd()
                 dhist = self.shell.user_ns['_dh']
                 if oldcwd != cwd:
                     dhist.append(cwd)
                     self.db['dhist'] = compress_dhist(dhist)[-100:]
                 
         else:
             os.chdir(self.shell.home_dir)
             if self.shell.rc.term_title:
                 platutils.set_term_title("IPy ~")
             cwd = os.getcwd()
             dhist = self.shell.user_ns['_dh']
             
             if oldcwd != cwd:
                 dhist.append(cwd)
                 self.db['dhist'] = compress_dhist(dhist)[-100:]
         if not 'q' in opts and self.shell.user_ns['_dh']:
             print self.shell.user_ns['_dh'][-1]
 
 
     def magic_env(self, parameter_s=''):
         """List environment variables."""
         
         return os.environ.data
 
     def magic_pushd(self, parameter_s=''):
         """Place the current dir on stack and change directory.
         
         Usage:\\
           %pushd ['dirname']
         """
         
         dir_s = self.shell.dir_stack
         tgt = os.path.expanduser(parameter_s)
         cwd = os.getcwd().replace(self.home_dir,'~')
         if tgt:
             self.magic_cd(parameter_s)
         dir_s.insert(0,cwd)
         return self.magic_dirs()
 
     def magic_popd(self, parameter_s=''):
         """Change to directory popped off the top of the stack.
         """
         if not self.shell.dir_stack:
             raise UsageError("%popd on empty stack")
         top = self.shell.dir_stack.pop(0)
         self.magic_cd(top)
         print "popd ->",top
 
     def magic_dirs(self, parameter_s=''):
         """Return the current directory stack."""
 
         return self.shell.dir_stack
 
     def magic_dhist(self, parameter_s=''):
         """Print your history of visited directories.
 
         %dhist       -> print full history\\
         %dhist n     -> print last n entries only\\
         %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
 
         This history is automatically maintained by the %cd command, and
         always available as the global list variable _dh. You can use %cd -<n>
         to go to directory number <n>.
         
         Note that most of time, you should view directory history by entering
         cd -<TAB>.
         
         """
 
         dh = self.shell.user_ns['_dh']
         if parameter_s:
             try:
                 args = map(int,parameter_s.split())
             except:
                 self.arg_err(Magic.magic_dhist)
                 return
             if len(args) == 1:
                 ini,fin = max(len(dh)-(args[0]),0),len(dh)
             elif len(args) == 2:
                 ini,fin = args
             else:
                 self.arg_err(Magic.magic_dhist)
                 return
         else:
             ini,fin = 0,len(dh)
         nlprint(dh,
                 header = 'Directory history (kept in _dh)',
                 start=ini,stop=fin)
 
     @testdec.skip_doctest
     def magic_sc(self, parameter_s=''):
         """Shell capture - execute a shell command and capture its output.
 
         DEPRECATED. Suboptimal, retained for backwards compatibility.
         
         You should use the form 'var = !command' instead. Example:
          
          "%sc -l myfiles = ls ~" should now be written as
             
          "myfiles = !ls ~"
          
         myfiles.s, myfiles.l and myfiles.n still apply as documented
         below.
 
         --
         %sc [options] varname=command
 
         IPython will run the given command using commands.getoutput(), and
         will then update the user's interactive namespace with a variable
         called varname, containing the value of the call.  Your command can
         contain shell wildcards, pipes, etc.
 
         The '=' sign in the syntax is mandatory, and the variable name you
         supply must follow Python's standard conventions for valid names.
         
         (A special format without variable name exists for internal use)
 
         Options:
 
           -l: list output.  Split the output on newlines into a list before
           assigning it to the given variable.  By default the output is stored
           as a single string.
 
           -v: verbose.  Print the contents of the variable.
 
         In most cases you should not need to split as a list, because the
         returned value is a special type of string which can automatically
         provide its contents either as a list (split on newlines) or as a
         space-separated string.  These are convenient, respectively, either
         for sequential processing or to be passed to a shell command.
 
         For example:
 
         # all-random
         
             # Capture into variable a
             In [1]: sc a=ls *py
 
             # a is a string with embedded newlines
             In [2]: a
             Out[2]: 'setup.py\\nwin32_manual_post_install.py'
 
             # which can be seen as a list:
             In [3]: a.l
             Out[3]: ['setup.py', 'win32_manual_post_install.py']
 
             # or as a whitespace-separated string:
             In [4]: a.s
             Out[4]: 'setup.py win32_manual_post_install.py'
 
             # a.s is useful to pass as a single command line:
             In [5]: !wc -l $a.s
               146 setup.py
               130 win32_manual_post_install.py
               276 total
 
             # while the list form is useful to loop over:
             In [6]: for f in a.l:
               ...:      !wc -l $f
               ...:
             146 setup.py
             130 win32_manual_post_install.py
 
         Similiarly, the lists returned by the -l option are also special, in
         the sense that you can equally invoke the .s attribute on them to
         automatically get a whitespace-separated string from their contents:
 
             In [7]: sc -l b=ls *py
 
             In [8]: b
             Out[8]: ['setup.py', 'win32_manual_post_install.py']
 
             In [9]: b.s
             Out[9]: 'setup.py win32_manual_post_install.py'
 
         In summary, both the lists and strings used for ouptut capture have
         the following special attributes:
 
             .l (or .list) : value as list.
             .n (or .nlstr): value as newline-separated string.
             .s (or .spstr): value as space-separated string.
         """
 
         opts,args = self.parse_options(parameter_s,'lv')
         # Try to get a variable name and command to run
         try:
             # the variable name must be obtained from the parse_options
             # output, which uses shlex.split to strip options out.
             var,_ = args.split('=',1)
             var = var.strip()
             # But the the command has to be extracted from the original input
             # parameter_s, not on what parse_options returns, to avoid the
             # quote stripping which shlex.split performs on it.
             _,cmd = parameter_s.split('=',1)
         except ValueError:
             var,cmd = '',''
         # If all looks ok, proceed
         out,err = self.shell.getoutputerror(cmd)
         if err:
             print >> Term.cerr,err
         if opts.has_key('l'):
             out = SList(out.split('\n'))
         else:
             out = LSString(out)
         if opts.has_key('v'):
             print '%s ==\n%s' % (var,pformat(out))
         if var:
             self.shell.user_ns.update({var:out})
         else:
             return out
 
     def magic_sx(self, parameter_s=''):
         """Shell execute - run a shell command and capture its output.
 
         %sx command
 
         IPython will run the given command using commands.getoutput(), and
         return the result formatted as a list (split on '\\n').  Since the
         output is _returned_, it will be stored in ipython's regular output
         cache Out[N] and in the '_N' automatic variables.
 
         Notes:
 
         1) If an input line begins with '!!', then %sx is automatically
         invoked.  That is, while:
           !ls
         causes ipython to simply issue system('ls'), typing
           !!ls
         is a shorthand equivalent to:
           %sx ls
         
         2) %sx differs from %sc in that %sx automatically splits into a list,
         like '%sc -l'.  The reason for this is to make it as easy as possible
         to process line-oriented shell output via further python commands.
         %sc is meant to provide much finer control, but requires more
         typing.
 
         3) Just like %sc -l, this is a list with special attributes:
 
           .l (or .list) : value as list.
           .n (or .nlstr): value as newline-separated string.
           .s (or .spstr): value as whitespace-separated string.
 
         This is very useful when trying to use such lists as arguments to
         system commands."""
 
         if parameter_s:
             out,err = self.shell.getoutputerror(parameter_s)
             if err:
                 print >> Term.cerr,err
             return SList(out.split('\n'))
 
     def magic_bg(self, parameter_s=''):
         """Run a job in the background, in a separate thread.
 
         For example,
 
           %bg myfunc(x,y,z=1)
 
         will execute 'myfunc(x,y,z=1)' in a background thread.  As soon as the
         execution starts, a message will be printed indicating the job
         number.  If your job number is 5, you can use
 
           myvar = jobs.result(5)  or  myvar = jobs[5].result
 
         to assign this result to variable 'myvar'.
 
         IPython has a job manager, accessible via the 'jobs' object.  You can
         type jobs? to get more information about it, and use jobs.<TAB> to see
         its attributes.  All attributes not starting with an underscore are
         meant for public use.
 
         In particular, look at the jobs.new() method, which is used to create
         new jobs.  This magic %bg function is just a convenience wrapper
         around jobs.new(), for expression-based jobs.  If you want to create a
         new job with an explicit function object and arguments, you must call
         jobs.new() directly.
 
         The jobs.new docstring also describes in detail several important
         caveats associated with a thread-based model for background job
         execution.  Type jobs.new? for details.
 
         You can check the status of all jobs with jobs.status().
 
         The jobs variable is set by IPython into the Python builtin namespace.
         If you ever declare a variable named 'jobs', you will shadow this
         name.  You can either delete your global jobs variable to regain
         access to the job manager, or make a new name and assign it manually
         to the manager (stored in IPython's namespace).  For example, to
         assign the job manager to the Jobs name, use:
 
           Jobs = __builtins__.jobs"""
         
         self.shell.jobs.new(parameter_s,self.shell.user_ns)
         
     def magic_r(self, parameter_s=''):
         """Repeat previous input.
 
         Note: Consider using the more powerfull %rep instead!
         
         If given an argument, repeats the previous command which starts with
         the same string, otherwise it just repeats the previous input.
 
         Shell escaped commands (with ! as first character) are not recognized
         by this system, only pure python code and magic commands.
         """
 
         start = parameter_s.strip()
         esc_magic = self.shell.ESC_MAGIC
         # Identify magic commands even if automagic is on (which means
         # the in-memory version is different from that typed by the user).
         if self.shell.rc.automagic:
             start_magic = esc_magic+start
         else:
             start_magic = start
         # Look through the input history in reverse
         for n in range(len(self.shell.input_hist)-2,0,-1):
             input = self.shell.input_hist[n]
             # skip plain 'r' lines so we don't recurse to infinity
             if input != '_ip.magic("r")\n' and \
                    (input.startswith(start) or input.startswith(start_magic)):
                 #print 'match',`input`  # dbg
                 print 'Executing:',input,
                 self.shell.runlines(input)
                 return
         print 'No previous input matching `%s` found.' % start
 
     
     def magic_bookmark(self, parameter_s=''):
         """Manage IPython's bookmark system.
 
         %bookmark <name>       - set bookmark to current dir
         %bookmark <name> <dir> - set bookmark to <dir>
         %bookmark -l           - list all bookmarks
         %bookmark -d <name>    - remove bookmark
         %bookmark -r           - remove all bookmarks
 
         You can later on access a bookmarked folder with:
           %cd -b <name>
         or simply '%cd <name>' if there is no directory called <name> AND
         there is such a bookmark defined.
 
         Your bookmarks persist through IPython sessions, but they are
         associated with each profile."""
 
         opts,args = self.parse_options(parameter_s,'drl',mode='list')
         if len(args) > 2:
             raise UsageError("%bookmark: too many arguments")
 
         bkms = self.db.get('bookmarks',{})
             
         if opts.has_key('d'):
             try:
                 todel = args[0]
             except IndexError:
                 raise UsageError(
                     "%bookmark -d: must provide a bookmark to delete")
             else:
                 try:
                     del bkms[todel]
                 except KeyError:
                     raise UsageError(
                         "%%bookmark -d: Can't delete bookmark '%s'" % todel)
 
         elif opts.has_key('r'):
             bkms = {}
         elif opts.has_key('l'):
             bks = bkms.keys()
             bks.sort()
             if bks:
                 size = max(map(len,bks))
             else:
                 size = 0
             fmt = '%-'+str(size)+'s -> %s'
             print 'Current bookmarks:'
             for bk in bks:
                 print fmt % (bk,bkms[bk])
         else:
             if not args:
                 raise UsageError("%bookmark: You must specify the bookmark name")
             elif len(args)==1:
                 bkms[args[0]] = os.getcwd()
             elif len(args)==2:
                 bkms[args[0]] = args[1]
         self.db['bookmarks'] = bkms
 
     def magic_pycat(self, parameter_s=''):
         """Show a syntax-highlighted file through a pager.
 
         This magic is similar to the cat utility, but it will assume the file
         to be Python source and will show it with syntax highlighting. """
         
         try:
             filename = get_py_filename(parameter_s)
             cont = file_read(filename)
         except IOError:
             try:
                 cont = eval(parameter_s,self.user_ns)
             except NameError:
                 cont = None
         if cont is None:
             print "Error: no such file or variable"
             return
             
         page(self.shell.pycolorize(cont),
              screen_lines=self.shell.rc.screen_length)
 
     def magic_cpaste(self, parameter_s=''):
         """Allows you to paste & execute a pre-formatted code block from clipboard.
         
         You must terminate the block with '--' (two minus-signs) alone on the
         line. You can also provide your own sentinel with '%paste -s %%' ('%%' 
         is the new sentinel for this operation)
         
         The block is dedented prior to execution to enable execution of method
         definitions. '>' and '+' characters at the beginning of a line are
         ignored, to allow pasting directly from e-mails, diff files and
         doctests (the '...' continuation prompt is also stripped).  The
         executed block is also assigned to variable named 'pasted_block' for
         later editing with '%edit pasted_block'.
         
         You can also pass a variable name as an argument, e.g. '%cpaste foo'.
         This assigns the pasted block to variable 'foo' as string, without 
         dedenting or executing it (preceding >>> and + is still stripped)
         
         '%cpaste -r' re-executes the block previously entered by cpaste.
         
         Do not be alarmed by garbled output on Windows (it's a readline bug). 
         Just press enter and type -- (and press enter again) and the block 
         will be what was just pasted.
         
         IPython statements (magics, shell escapes) are not supported (yet).
         """
         opts,args = self.parse_options(parameter_s,'rs:',mode='string')
         par = args.strip()
         if opts.has_key('r'):
             b = self.user_ns.get('pasted_block', None)
             if b is None:
                 raise UsageError('No previous pasted block available')
             print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
             exec b in self.user_ns
             return
         
         sentinel = opts.get('s','--')
 
         # Regular expressions that declare text we strip from the input:
         strip_re =  [r'^\s*In \[\d+\]:', # IPython input prompt
                      r'^\s*(\s?>)+', # Python input prompt
                      r'^\s*\.{3,}', # Continuation prompts
                      r'^\++',
                      ]
 
         strip_from_start = map(re.compile,strip_re)
         
-        from IPython import iplib
+        from IPython.core import iplib
         lines = []
         print "Pasting code; enter '%s' alone on the line to stop." % sentinel
         while 1:
             l = iplib.raw_input_original(':')
             if l ==sentinel:
                 break
             
             for pat in strip_from_start: 
                 l = pat.sub('',l)
             lines.append(l)
                          
         block = "\n".join(lines) + '\n'
         #print "block:\n",block
         if not par:
             b = textwrap.dedent(block)
             self.user_ns['pasted_block'] = b
             exec b in self.user_ns
         else:
             self.user_ns[par] = SList(block.splitlines())
             print "Block assigned to '%s'" % par
             
     def magic_quickref(self,arg):
         """ Show a quick reference sheet """
         import IPython.usage
         qr = IPython.usage.quick_reference + self.magic_magic('-brief')
         
         page(qr)
         
     def magic_upgrade(self,arg):
         """ Upgrade your IPython installation
         
         This will copy the config files that don't yet exist in your 
         ipython dir from the system config dir. Use this after upgrading 
         IPython if you don't wish to delete your .ipython dir.
 
         Call with -nolegacy to get rid of ipythonrc* files (recommended for
         new users)
 
         """
         ip = self.getapi()
         ipinstallation = path(IPython.__file__).dirname()
         upgrade_script = '%s "%s"' % (sys.executable,ipinstallation / 'upgrade_dir.py')
         src_config = ipinstallation / 'UserConfig'
         userdir = path(ip.options.ipythondir)
         cmd = '%s "%s" "%s"' % (upgrade_script, src_config, userdir)
         print ">",cmd
         shell(cmd)
         if arg == '-nolegacy':
             legacy = userdir.files('ipythonrc*')
             print "Nuking legacy files:",legacy
             
             [p.remove() for p in legacy]
             suffix = (sys.platform == 'win32' and '.ini' or '')
             (userdir / ('ipythonrc' + suffix)).write_text('# Empty, see ipy_user_conf.py\n')
 
 
     def magic_doctest_mode(self,parameter_s=''):
         """Toggle doctest mode on and off.
 
         This mode allows you to toggle the prompt behavior between normal
         IPython prompts and ones that are as similar to the default IPython
         interpreter as possible.
 
         It also supports the pasting of code snippets that have leading '>>>'
         and '...' prompts in them.  This means that you can paste doctests from
         files or docstrings (even if they have leading whitespace), and the
         code will execute correctly.  You can then use '%history -tn' to see
         the translated history without line numbers; this will give you the
         input after removal of all the leading prompts and whitespace, which
         can be pasted back into an editor.
 
         With these features, you can switch into this mode easily whenever you
         need to do testing and changes to doctests, without having to leave
         your existing IPython session.
         """
 
         # XXX - Fix this to have cleaner activate/deactivate calls.
         from IPython.Extensions import InterpreterPasteInput as ipaste
         from IPython.ipstruct import Struct
 
         # Shorthands
         shell = self.shell
         oc = shell.outputcache
         rc = shell.rc
         meta = shell.meta
         # dstore is a data store kept in the instance metadata bag to track any
         # changes we make, so we can undo them later.
         dstore = meta.setdefault('doctest_mode',Struct())
         save_dstore = dstore.setdefault
 
         # save a few values we'll need to recover later
         mode = save_dstore('mode',False)
         save_dstore('rc_pprint',rc.pprint)
         save_dstore('xmode',shell.InteractiveTB.mode)
         save_dstore('rc_separate_out',rc.separate_out)
         save_dstore('rc_separate_out2',rc.separate_out2)
         save_dstore('rc_prompts_pad_left',rc.prompts_pad_left)
         save_dstore('rc_separate_in',rc.separate_in)
 
         if mode == False:
             # turn on
             ipaste.activate_prefilter()
 
             oc.prompt1.p_template = '>>> '
             oc.prompt2.p_template = '... '
             oc.prompt_out.p_template = ''
 
             # Prompt separators like plain python
             oc.input_sep = oc.prompt1.sep = ''
             oc.output_sep = ''
             oc.output_sep2 = ''
 
             oc.prompt1.pad_left = oc.prompt2.pad_left = \
                                   oc.prompt_out.pad_left = False
 
             rc.pprint = False
 
             shell.magic_xmode('Plain')
 
         else:
             # turn off
             ipaste.deactivate_prefilter()
 
             oc.prompt1.p_template = rc.prompt_in1
             oc.prompt2.p_template = rc.prompt_in2
             oc.prompt_out.p_template = rc.prompt_out
 
             oc.input_sep = oc.prompt1.sep = dstore.rc_separate_in
 
             oc.output_sep = dstore.rc_separate_out
             oc.output_sep2 = dstore.rc_separate_out2
 
             oc.prompt1.pad_left = oc.prompt2.pad_left = \
                          oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
 
             rc.pprint = dstore.rc_pprint
 
             shell.magic_xmode(dstore.xmode)
 
         # Store new mode and inform
         dstore.mode = bool(1-int(mode))
         print 'Doctest mode is:',
         print ['OFF','ON'][dstore.mode]
 
 # end Magic

IPython/Shell.py

@@ -1,1247 +1,1247
 # -*- coding: utf-8 -*-
 """IPython Shell classes.
 
 All the matplotlib support code was co-developed with John Hunter,
 matplotlib's author.
 """
 
 #*****************************************************************************
 #       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.
 #*****************************************************************************
 
 # Code begins
 # Stdlib imports
 import __builtin__
 import __main__
 import Queue
 import inspect
 import os
 import sys
 import thread
 import threading
 import time
 
 from signal import signal, SIGINT
 
 try:
     import ctypes
     HAS_CTYPES = True
 except ImportError:
     HAS_CTYPES = False
 
 # IPython imports
 import IPython
 from IPython import ultraTB
 from IPython.core import ipapi
 from IPython.Magic import Magic
 from IPython.utils.genutils import Term,warn,error,flag_calls, ask_yes_no
-from IPython.iplib import InteractiveShell
+from IPython.core.iplib import InteractiveShell
 from IPython.ipmaker import make_IPython
 from IPython.ipstruct import Struct
 from IPython.testing import decorators as testdec
 
 # Globals
 # global flag to pass around information about Ctrl-C without exceptions
 KBINT = False
 
 # global flag to turn on/off Tk support.
 USE_TK = False
 
 # ID for the main thread, used for cross-thread exceptions
 MAIN_THREAD_ID = thread.get_ident()
 
 # Tag when runcode() is active, for exception handling
 CODE_RUN = None
 
 # Default timeout for waiting for multithreaded shells (in seconds)
 GUI_TIMEOUT = 10
 
 #-----------------------------------------------------------------------------
 # This class is trivial now, but I want to have it in to publish a clean
 # interface. Later when the internals are reorganized, code that uses this
 # shouldn't have to change.
 
 class IPShell:
     """Create an IPython instance."""
     
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,
                  debug=1,shell_class=InteractiveShell):
         self.IP = make_IPython(argv,user_ns=user_ns,
                                user_global_ns=user_global_ns,
                                debug=debug,shell_class=shell_class)
 
     def mainloop(self,sys_exit=0,banner=None):
         self.IP.mainloop(banner)
         if sys_exit:
             sys.exit()
 
 #-----------------------------------------------------------------------------
 def kill_embedded(self,parameter_s=''):
     """%kill_embedded : deactivate for good the current embedded IPython.
 
     This function (after asking for confirmation) sets an internal flag so that
     an embedded IPython will never activate again.  This is useful to
     permanently disable a shell that is being called inside a loop: once you've
     figured out what you needed from it, you may then kill it and the program
     will then continue to run without the interactive shell interfering again.
     """
     
     kill = ask_yes_no("Are you sure you want to kill this embedded instance "
                      "(y/n)? [y/N] ",'n')
     if kill:
         self.shell.embedded_active = False
         print "This embedded IPython will not reactivate anymore once you exit."
     
 class IPShellEmbed:
     """Allow embedding an IPython shell into a running program.
 
     Instances of this class are callable, with the __call__ method being an
     alias to the embed() method of an InteractiveShell instance.
 
     Usage (see also the example-embed.py file for a running example):
 
     ipshell = IPShellEmbed([argv,banner,exit_msg,rc_override])
 
     - argv: list containing valid command-line options for IPython, as they
     would appear in sys.argv[1:].
 
     For example, the following command-line options:
 
       $ ipython -prompt_in1 'Input <\\#>' -colors LightBG
 
     would be passed in the argv list as:
 
       ['-prompt_in1','Input <\\#>','-colors','LightBG']
 
     - banner: string which gets printed every time the interpreter starts.
 
     - exit_msg: string which gets printed every time the interpreter exits.
 
     - rc_override: a dict or Struct of configuration options such as those
     used by IPython. These options are read from your ~/.ipython/ipythonrc
     file when the Shell object is created. Passing an explicit rc_override
     dict with any options you want allows you to override those values at
     creation time without having to modify the file. This way you can create
     embeddable instances configured in any way you want without editing any
     global files (thus keeping your interactive IPython configuration
     unchanged).
 
     Then the ipshell instance can be called anywhere inside your code:
     
     ipshell(header='') -> Opens up an IPython shell.
 
     - header: string printed by the IPython shell upon startup. This can let
     you know where in your code you are when dropping into the shell. Note
     that 'banner' gets prepended to all calls, so header is used for
     location-specific information.
 
     For more details, see the __call__ method below.
 
     When the IPython shell is exited with Ctrl-D, normal program execution
     resumes.
 
     This functionality was inspired by a posting on comp.lang.python by cmkl
     <[e-mail]> on Dec. 06/01 concerning similar uses of pyrepl, and
     by the IDL stop/continue commands."""
 
     def __init__(self,argv=None,banner='',exit_msg=None,rc_override=None,
                  user_ns=None):
         """Note that argv here is a string, NOT a list."""
         self.set_banner(banner)
         self.set_exit_msg(exit_msg)
         self.set_dummy_mode(0)
 
         # sys.displayhook is a global, we need to save the user's original
         # Don't rely on __displayhook__, as the user may have changed that.
         self.sys_displayhook_ori = sys.displayhook
 
         # save readline completer status
         try:
             #print 'Save completer',sys.ipcompleter  # dbg
             self.sys_ipcompleter_ori = sys.ipcompleter
         except:
             pass # not nested with IPython
         
         self.IP = make_IPython(argv,rc_override=rc_override,
                                embedded=True,
                                user_ns=user_ns)
 
         ip = ipapi.IPApi(self.IP)
         ip.expose_magic("kill_embedded",kill_embedded)
 
         # copy our own displayhook also
         self.sys_displayhook_embed = sys.displayhook
         # and leave the system's display hook clean
         sys.displayhook = self.sys_displayhook_ori
         # don't use the ipython crash handler so that user exceptions aren't
         # trapped
         sys.excepthook = ultraTB.FormattedTB(color_scheme = self.IP.rc.colors,
                                              mode = self.IP.rc.xmode,
                                              call_pdb = self.IP.rc.pdb)
         self.restore_system_completer()
 
     def restore_system_completer(self):
         """Restores the readline completer which was in place.
 
         This allows embedded IPython within IPython not to disrupt the
         parent's completion.
         """
         
         try:
             self.IP.readline.set_completer(self.sys_ipcompleter_ori)
             sys.ipcompleter = self.sys_ipcompleter_ori
         except:
             pass
 
     def __call__(self,header='',local_ns=None,global_ns=None,dummy=None):
         """Activate the interactive interpreter.
 
         __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
         the interpreter shell with the given local and global namespaces, and
         optionally print a header string at startup.
 
         The shell can be globally activated/deactivated using the
         set/get_dummy_mode methods. This allows you to turn off a shell used
         for debugging globally.
 
         However, *each* time you call the shell you can override the current
         state of dummy_mode with the optional keyword parameter 'dummy'. For
         example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
         can still have a specific call work by making it as IPShell(dummy=0).
 
         The optional keyword parameter dummy controls whether the call
         actually does anything.  """
 
         # If the user has turned it off, go away
         if not self.IP.embedded_active:
             return
 
         # Normal exits from interactive mode set this flag, so the shell can't
         # re-enter (it checks this variable at the start of interactive mode).
         self.IP.exit_now = False
 
         # Allow the dummy parameter to override the global __dummy_mode
         if dummy or (dummy != 0 and self.__dummy_mode):
             return
 
         # Set global subsystems (display,completions) to our values
         sys.displayhook = self.sys_displayhook_embed
         if self.IP.has_readline:
             self.IP.set_completer()
 
         if self.banner and header:
             format = '%s\n%s\n'
         else:
             format = '%s%s\n'
         banner =  format % (self.banner,header)
 
         # Call the embedding code with a stack depth of 1 so it can skip over
         # our call and get the original caller's namespaces.
         self.IP.embed_mainloop(banner,local_ns,global_ns,stack_depth=1)
 
         if self.exit_msg:
             print self.exit_msg
             
         # Restore global systems (display, completion)
         sys.displayhook = self.sys_displayhook_ori
         self.restore_system_completer()
     
     def set_dummy_mode(self,dummy):
         """Sets the embeddable shell's dummy mode parameter.
 
         set_dummy_mode(dummy): dummy = 0 or 1.
 
         This parameter is persistent and makes calls to the embeddable shell
         silently return without performing any action. This allows you to
         globally activate or deactivate a shell you're using with a single call.
 
         If you need to manually"""
 
         if dummy not in [0,1,False,True]:
             raise ValueError,'dummy parameter must be boolean'
         self.__dummy_mode = dummy
 
     def get_dummy_mode(self):
         """Return the current value of the dummy mode parameter.
         """
         return self.__dummy_mode
     
     def set_banner(self,banner):
         """Sets the global banner.
 
         This banner gets prepended to every header printed when the shell
         instance is called."""
 
         self.banner = banner
 
     def set_exit_msg(self,exit_msg):
         """Sets the global exit_msg.
 
         This exit message gets printed upon exiting every time the embedded
         shell is called. It is None by default. """
 
         self.exit_msg = exit_msg
 
 #-----------------------------------------------------------------------------
 if HAS_CTYPES:
     #  Add async exception support.  Trick taken from:
     # http://sebulba.wikispaces.com/recipe+thread2
     def _async_raise(tid, exctype):
         """raises the exception, performs cleanup if needed"""
         if not inspect.isclass(exctype):
             raise TypeError("Only types can be raised (not instances)")
         # Explicit cast to c_long is necessary for 64-bit support:
         # See https://bugs.launchpad.net/ipython/+bug/237073
         res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid),
                                                          ctypes.py_object(exctype))
         if res == 0:
             raise ValueError("invalid thread id")
         elif res != 1:
             # If it returns a number greater than one, you're in trouble, 
             # and you should call it again with exc=NULL to revert the effect
             ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
             raise SystemError("PyThreadState_SetAsyncExc failed")
 
     def sigint_handler(signum,stack_frame):
         """Sigint handler for threaded apps.
 
         This is a horrible hack to pass information about SIGINT _without_
         using exceptions, since I haven't been able to properly manage
         cross-thread exceptions in GTK/WX.  In fact, I don't think it can be
         done (or at least that's my understanding from a c.l.py thread where
         this was discussed)."""
 
         global KBINT
 
         if CODE_RUN:
             _async_raise(MAIN_THREAD_ID,KeyboardInterrupt)
         else:
             KBINT = True
             print '\nKeyboardInterrupt - Press <Enter> to continue.',
             Term.cout.flush()
 
 else:
     def sigint_handler(signum,stack_frame):
         """Sigint handler for threaded apps.
 
         This is a horrible hack to pass information about SIGINT _without_
         using exceptions, since I haven't been able to properly manage
         cross-thread exceptions in GTK/WX.  In fact, I don't think it can be
         done (or at least that's my understanding from a c.l.py thread where
         this was discussed)."""
 
         global KBINT
 
         print '\nKeyboardInterrupt - Press <Enter> to continue.',
         Term.cout.flush()
         # Set global flag so that runsource can know that Ctrl-C was hit
         KBINT = True
 
 
 class MTInteractiveShell(InteractiveShell):
     """Simple multi-threaded shell."""
 
     # Threading strategy taken from:
     # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
     # McErlean and John Finlay.  Modified with corrections by Antoon Pardon,
     # from the pygtk mailing list, to avoid lockups with system calls.
 
     # class attribute to indicate whether the class supports threads or not.
     # Subclasses with thread support should override this as needed.
     isthreaded = True
 
     def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
                  user_ns=None,user_global_ns=None,banner2='',
                  gui_timeout=GUI_TIMEOUT,**kw):
         """Similar to the normal InteractiveShell, but with threading control"""
         
         InteractiveShell.__init__(self,name,usage,rc,user_ns,
                                   user_global_ns,banner2)
 
         # Timeout we wait for GUI thread
         self.gui_timeout = gui_timeout
 
         # A queue to hold the code to be executed. 
         self.code_queue = Queue.Queue()
 
         # Stuff to do at closing time
         self._kill = None
         on_kill = kw.get('on_kill', [])
         # Check that all things to kill are callable:
         for t in on_kill:
             if not callable(t):
                 raise TypeError,'on_kill must be a list of callables'
         self.on_kill = on_kill
         # thread identity of the "worker thread" (that may execute code directly)
         self.worker_ident = None
         
     def runsource(self, source, filename="<input>", symbol="single"):
         """Compile and run some source in the interpreter.
 
         Modified version of code.py's runsource(), to handle threading issues.
         See the original for full docstring details."""
                 
         global KBINT
         
         # If Ctrl-C was typed, we reset the flag and return right away
         if KBINT:
             KBINT = False
             return False
 
         if self._kill:
             # can't queue new code if we are being killed
             return True
         
         try:
             code = self.compile(source, filename, symbol)
         except (OverflowError, SyntaxError, ValueError):
             # Case 1
             self.showsyntaxerror(filename)
             return False
 
         if code is None:
             # Case 2
             return True
 
         # shortcut - if we are in worker thread, or the worker thread is not
         # running, execute directly (to allow recursion and prevent deadlock if
         # code is run early in IPython construction)
         
         if (self.worker_ident is None
             or self.worker_ident == thread.get_ident() ):
             InteractiveShell.runcode(self,code)
             return False
 
         # Case 3
         # Store code in queue, so the execution thread can handle it.
 
         completed_ev, received_ev = threading.Event(), threading.Event() 
         
         self.code_queue.put((code,completed_ev, received_ev))
         # first make sure the message was received, with timeout
         received_ev.wait(self.gui_timeout)
         if not received_ev.isSet():
             # the mainloop is dead, start executing code directly
             print "Warning: Timeout for mainloop thread exceeded"
             print "switching to nonthreaded mode (until mainloop wakes up again)"
             self.worker_ident = None
         else:
             completed_ev.wait()
         return False
 
     def runcode(self):
         """Execute a code object.
 
         Multithreaded wrapper around IPython's runcode()."""
         
         global CODE_RUN
         
         # we are in worker thread, stash out the id for runsource() 
         self.worker_ident = thread.get_ident()
 
         if self._kill:
             print >>Term.cout, 'Closing threads...',
             Term.cout.flush()
             for tokill in self.on_kill:
                 tokill()
             print >>Term.cout, 'Done.'
             # allow kill() to return
             self._kill.set()
             return True
 
         # Install sigint handler.  We do it every time to ensure that if user
         # code modifies it, we restore our own handling.
         try:
             signal(SIGINT,sigint_handler)
         except SystemError:
             # This happens under Windows, which seems to have all sorts
             # of problems with signal handling.  Oh well...
             pass
 
         # Flush queue of pending code by calling the run methood of the parent
         # class with all items which may be in the queue.
         code_to_run = None
         while 1:
             try:
                 code_to_run, completed_ev, received_ev = self.code_queue.get_nowait()                
             except Queue.Empty:
                 break
             received_ev.set()
             
             # Exceptions need to be raised differently depending on which
             # thread is active.  This convoluted try/except is only there to
             # protect against asynchronous exceptions, to ensure that a KBINT
             # at the wrong time doesn't deadlock everything.  The global
             # CODE_TO_RUN is set to true/false as close as possible to the
             # runcode() call, so that the KBINT handler is correctly informed.
             try:
                 try:
                    CODE_RUN = True
                    InteractiveShell.runcode(self,code_to_run)
                 except KeyboardInterrupt:
                    print "Keyboard interrupted in mainloop"
                    while not self.code_queue.empty():
                       code, ev1,ev2 = self.code_queue.get_nowait()
                       ev1.set()
                       ev2.set()                      
                    break
             finally:
                 CODE_RUN = False
                 # allow runsource() return from wait
                 completed_ev.set()
                 
         
         # This MUST return true for gtk threading to work
         return True
 
     def kill(self):
         """Kill the thread, returning when it has been shut down."""
         self._kill = threading.Event()
         self._kill.wait()
 
 class MatplotlibShellBase:
     """Mixin class to provide the necessary modifications to regular IPython
     shell classes for matplotlib support.
 
     Given Python's MRO, this should be used as the FIRST class in the
     inheritance hierarchy, so that it overrides the relevant methods."""
     
     def _matplotlib_config(self,name,user_ns,user_global_ns=None):
         """Return items needed to setup the user's shell with matplotlib"""
 
         # Initialize matplotlib to interactive mode always
         import matplotlib
         from matplotlib import backends
         matplotlib.interactive(True)
 
         def use(arg):
             """IPython wrapper for matplotlib's backend switcher.
 
             In interactive use, we can not allow switching to a different
             interactive backend, since thread conflicts will most likely crash
             the python interpreter.  This routine does a safety check first,
             and refuses to perform a dangerous switch.  It still allows
             switching to non-interactive backends."""
 
             if arg in backends.interactive_bk and arg != self.mpl_backend:
                 m=('invalid matplotlib backend switch.\n'
                    'This script attempted to switch to the interactive '
                    'backend: `%s`\n'
                    'Your current choice of interactive backend is: `%s`\n\n'
                    'Switching interactive matplotlib backends at runtime\n'
                    'would crash the python interpreter, '
                    'and IPython has blocked it.\n\n'
                    'You need to either change your choice of matplotlib backend\n'
                    'by editing your .matplotlibrc file, or run this script as a \n'
                    'standalone file from the command line, not using IPython.\n' %
                    (arg,self.mpl_backend) )
                 raise RuntimeError, m
             else:
                 self.mpl_use(arg)
                 self.mpl_use._called = True
         
         self.matplotlib = matplotlib
         self.mpl_backend = matplotlib.rcParams['backend']
 
         # we also need to block switching of interactive backends by use()
         self.mpl_use = matplotlib.use
         self.mpl_use._called = False
         # overwrite the original matplotlib.use with our wrapper
         matplotlib.use = use
 
         # This must be imported last in the matplotlib series, after
         # backend/interactivity choices have been made
         import matplotlib.pylab as pylab
         self.pylab = pylab
 
         self.pylab.show._needmain = False
         # We need to detect at runtime whether show() is called by the user.
         # For this, we wrap it into a decorator which adds a 'called' flag.
         self.pylab.draw_if_interactive = flag_calls(self.pylab.draw_if_interactive)
 
         # Build a user namespace initialized with matplotlib/matlab features.
         user_ns, user_global_ns = ipapi.make_user_namespaces(user_ns,
             user_global_ns)
 
         # Import numpy as np/pyplot as plt are conventions we're trying to
         # somewhat standardize on.  Making them available to users by default
         # will greatly help this. 
         exec ("import numpy\n"
               "import numpy as np\n"
               "import matplotlib\n"
               "import matplotlib.pylab as pylab\n"
               "try:\n"
               "    import matplotlib.pyplot as plt\n"
               "except ImportError:\n"
               "    pass\n"
               ) in user_ns
         
         # Build matplotlib info banner
         b="""
   Welcome to pylab, a matplotlib-based Python environment.
   For more information, type 'help(pylab)'.
 """
         return user_ns,user_global_ns,b
 
     def mplot_exec(self,fname,*where,**kw):
         """Execute a matplotlib script.
 
         This is a call to execfile(), but wrapped in safeties to properly
         handle interactive rendering and backend switching."""
 
         #print '*** Matplotlib runner ***' # dbg
         # turn off rendering until end of script
         isInteractive = self.matplotlib.rcParams['interactive']
         self.matplotlib.interactive(False)
         self.safe_execfile(fname,*where,**kw)
         self.matplotlib.interactive(isInteractive)
         # make rendering call now, if the user tried to do it
         if self.pylab.draw_if_interactive.called:
             self.pylab.draw()
             self.pylab.draw_if_interactive.called = False
                 
         # if a backend switch was performed, reverse it now
         if self.mpl_use._called:
             self.matplotlib.rcParams['backend'] = self.mpl_backend
 
     @testdec.skip_doctest
     def magic_run(self,parameter_s=''):
         Magic.magic_run(self,parameter_s,runner=self.mplot_exec)
 
     # Fix the docstring so users see the original as well
     magic_run.__doc__ = "%s\n%s" % (Magic.magic_run.__doc__,
                                     "\n        *** Modified %run for Matplotlib,"
                                     " with proper interactive handling ***")
 
 # Now we provide 2 versions of a matplotlib-aware IPython base shells, single
 # and multithreaded.  Note that these are meant for internal use, the IPShell*
 # classes below are the ones meant for public consumption.
 
 class MatplotlibShell(MatplotlibShellBase,InteractiveShell):
     """Single-threaded shell with matplotlib support."""
 
     def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
                  user_ns=None,user_global_ns=None,**kw):
         user_ns,user_global_ns,b2 = self._matplotlib_config(name,user_ns,user_global_ns)
         InteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
                                   banner2=b2,**kw)
 
 class MatplotlibMTShell(MatplotlibShellBase,MTInteractiveShell):
     """Multi-threaded shell with matplotlib support."""
 
     def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
                  user_ns=None,user_global_ns=None, **kw):
         user_ns,user_global_ns,b2 = self._matplotlib_config(name,user_ns,user_global_ns)
         MTInteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns,
                                     banner2=b2,**kw)
 
 #-----------------------------------------------------------------------------
 # Utility functions for the different GUI enabled IPShell* classes.
 
 def get_tk():
     """Tries to import Tkinter and returns a withdrawn Tkinter root
     window.  If Tkinter is already imported or not available, this
     returns None.  This function calls `hijack_tk` underneath.
     """
     if not USE_TK or sys.modules.has_key('Tkinter'):
         return None
     else:
         try:
             import Tkinter
         except ImportError:
             return None
         else:
             hijack_tk()
             r = Tkinter.Tk()
             r.withdraw()
             return r
 
 def hijack_tk():
     """Modifies Tkinter's mainloop with a dummy so when a module calls
     mainloop, it does not block.
 
     """
     def misc_mainloop(self, n=0):
         pass
     def tkinter_mainloop(n=0):
         pass
     
     import Tkinter
     Tkinter.Misc.mainloop = misc_mainloop
     Tkinter.mainloop = tkinter_mainloop
 
 def update_tk(tk):
     """Updates the Tkinter event loop.  This is typically called from
     the respective WX or GTK mainloops.
     """    
     if tk:
         tk.update()
 
 def hijack_wx():
     """Modifies wxPython's MainLoop with a dummy so user code does not
     block IPython.  The hijacked mainloop function is returned.
     """    
     def dummy_mainloop(*args, **kw):
         pass
 
     try:
         import wx
     except ImportError:
         # For very old versions of WX
         import wxPython as wx
         
     ver = wx.__version__
     orig_mainloop = None
     if ver[:3] >= '2.5':
         import wx
         if hasattr(wx, '_core_'): core = getattr(wx, '_core_')
         elif hasattr(wx, '_core'): core = getattr(wx, '_core')
         else: raise AttributeError('Could not find wx core module')
         orig_mainloop = core.PyApp_MainLoop
         core.PyApp_MainLoop = dummy_mainloop
     elif ver[:3] == '2.4':
         orig_mainloop = wx.wxc.wxPyApp_MainLoop
         wx.wxc.wxPyApp_MainLoop = dummy_mainloop
     else:
         warn("Unable to find either wxPython version 2.4 or >= 2.5.")
     return orig_mainloop
 
 def hijack_gtk():
     """Modifies pyGTK's mainloop with a dummy so user code does not
     block IPython.  This function returns the original `gtk.mainloop`
     function that has been hijacked.
     """    
     def dummy_mainloop(*args, **kw):
         pass
     import gtk
     if gtk.pygtk_version >= (2,4,0): orig_mainloop = gtk.main
     else:                            orig_mainloop = gtk.mainloop
     gtk.mainloop = dummy_mainloop
     gtk.main = dummy_mainloop
     return orig_mainloop
 
 def hijack_qt():
     """Modifies PyQt's mainloop with a dummy so user code does not 
     block IPython.  This function returns the original 
     `qt.qApp.exec_loop` function that has been hijacked.
     """    
     def dummy_mainloop(*args, **kw):
         pass
     import qt
     orig_mainloop = qt.qApp.exec_loop
     qt.qApp.exec_loop = dummy_mainloop
     qt.QApplication.exec_loop = dummy_mainloop
     return orig_mainloop
 
 def hijack_qt4():
     """Modifies PyQt4's mainloop with a dummy so user code does not
     block IPython.  This function returns the original 
     `QtGui.qApp.exec_` function that has been hijacked.
     """    
     def dummy_mainloop(*args, **kw):
         pass
     from PyQt4 import QtGui, QtCore
     orig_mainloop = QtGui.qApp.exec_
     QtGui.qApp.exec_ = dummy_mainloop
     QtGui.QApplication.exec_ = dummy_mainloop
     QtCore.QCoreApplication.exec_ = dummy_mainloop
     return orig_mainloop
 
 #-----------------------------------------------------------------------------
 # The IPShell* classes below are the ones meant to be run by external code as
 # IPython instances.  Note that unless a specific threading strategy is
 # desired, the factory function start() below should be used instead (it
 # selects the proper threaded class).
 
 class IPThread(threading.Thread):
     def run(self):
         self.IP.mainloop(self._banner)
         self.IP.kill()
 
 class IPShellGTK(IPThread):
     """Run a gtk mainloop() in a separate thread.
     
     Python commands can be passed to the thread where they will be executed.
     This is implemented by periodically checking for passed code using a
     GTK timeout callback."""
     
     TIMEOUT = 100 # Millisecond interval between timeouts.
 
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,
                  debug=1,shell_class=MTInteractiveShell):
 
         import gtk
         # Check for set_interactive, coming up in new pygtk.
         # Disable it so that this code works, but notify 
         # the user that he has a better option as well.
         # XXX TODO better support when set_interactive is released
         try:
             gtk.set_interactive(False)
             print "Your PyGtk has set_interactive(), so you can use the"
             print "more stable single-threaded Gtk mode."
             print "See https://bugs.launchpad.net/ipython/+bug/270856"
         except AttributeError:
             pass
         
         self.gtk = gtk
         self.gtk_mainloop = hijack_gtk()
 
         # Allows us to use both Tk and GTK.
         self.tk = get_tk()
         
         if gtk.pygtk_version >= (2,4,0): mainquit = self.gtk.main_quit
         else:                            mainquit = self.gtk.mainquit
 
         self.IP = make_IPython(argv,user_ns=user_ns,
                                user_global_ns=user_global_ns,
                                debug=debug,
                                shell_class=shell_class,
                                on_kill=[mainquit])
 
         # HACK: slot for banner in self; it will be passed to the mainloop
         # method only and .run() needs it.  The actual value will be set by
         # .mainloop().
         self._banner = None 
 
         threading.Thread.__init__(self)
 
     def mainloop(self,sys_exit=0,banner=None):
 
         self._banner = banner
         
         if self.gtk.pygtk_version >= (2,4,0):
             import gobject
             gobject.idle_add(self.on_timer)
         else:
             self.gtk.idle_add(self.on_timer)
 
         if sys.platform != 'win32':
             try:
                 if self.gtk.gtk_version[0] >= 2:
                     self.gtk.gdk.threads_init()
             except AttributeError:
                 pass
             except RuntimeError:
                 error('Your pyGTK likely has not been compiled with '
                       'threading support.\n'
                       'The exception printout is below.\n'
                       'You can either rebuild pyGTK with threads, or '
                       'try using \n'
                       'matplotlib with a different backend (like Tk or WX).\n'
                       'Note that matplotlib will most likely not work in its '
                       'current state!')
                 self.IP.InteractiveTB()
 
         self.start()
         self.gtk.gdk.threads_enter()
         self.gtk_mainloop()
         self.gtk.gdk.threads_leave()
         self.join()
 
     def on_timer(self):
         """Called when GTK is idle.
 
         Must return True always, otherwise GTK stops calling it"""
         
         update_tk(self.tk)
         self.IP.runcode()
         time.sleep(0.01)
         return True
 
 
 class IPShellWX(IPThread):
     """Run a wx mainloop() in a separate thread.
     
     Python commands can be passed to the thread where they will be executed.
     This is implemented by periodically checking for passed code using a
     GTK timeout callback."""
     
     TIMEOUT = 100 # Millisecond interval between timeouts.
 
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,
                  debug=1,shell_class=MTInteractiveShell):
 
         self.IP = make_IPython(argv,user_ns=user_ns,
                                user_global_ns=user_global_ns,
                                debug=debug,
                                shell_class=shell_class,
                                on_kill=[self.wxexit])
 
         wantedwxversion=self.IP.rc.wxversion
         if wantedwxversion!="0":
             try:
                 import wxversion
             except ImportError:
                 error('The wxversion module is needed for WX version selection')
             else:
                 try:
                     wxversion.select(wantedwxversion)
                 except:
                     self.IP.InteractiveTB()
                     error('Requested wxPython version %s could not be loaded' %
                                                                wantedwxversion)
 
         import wx
 
         threading.Thread.__init__(self)
         self.wx = wx
         self.wx_mainloop = hijack_wx()
 
         # Allows us to use both Tk and GTK.
         self.tk = get_tk()
         
         # HACK: slot for banner in self; it will be passed to the mainloop
         # method only and .run() needs it.  The actual value will be set by
         # .mainloop().
         self._banner = None 
 
         self.app = None
 
     def wxexit(self, *args):
         if self.app is not None:
             self.app.agent.timer.Stop()
             self.app.ExitMainLoop()
 
     def mainloop(self,sys_exit=0,banner=None):
 
         self._banner = banner
         
         self.start()
 
         class TimerAgent(self.wx.MiniFrame):
             wx = self.wx
             IP = self.IP
             tk = self.tk
             def __init__(self, parent, interval):
                 style = self.wx.DEFAULT_FRAME_STYLE | self.wx.TINY_CAPTION_HORIZ
                 self.wx.MiniFrame.__init__(self, parent, -1, ' ', pos=(200, 200),
                                              size=(100, 100),style=style)
                 self.Show(False)
                 self.interval = interval
                 self.timerId = self.wx.NewId()                                
 
             def StartWork(self):
                 self.timer = self.wx.Timer(self, self.timerId)
                 self.wx.EVT_TIMER(self,  self.timerId, self.OnTimer)
                 self.timer.Start(self.interval)
 
             def OnTimer(self, event):
                 update_tk(self.tk)
                 self.IP.runcode()
 
         class App(self.wx.App):
             wx = self.wx
             TIMEOUT = self.TIMEOUT
             def OnInit(self):
                 'Create the main window and insert the custom frame'
                 self.agent = TimerAgent(None, self.TIMEOUT)
                 self.agent.Show(False)
                 self.agent.StartWork()
                 return True
 
         self.app = App(redirect=False)
         self.wx_mainloop(self.app)
         self.join()
 
 
 class IPShellQt(IPThread):
     """Run a Qt event loop in a separate thread.
     
     Python commands can be passed to the thread where they will be executed.
     This is implemented by periodically checking for passed code using a
     Qt timer / slot."""
     
     TIMEOUT = 100 # Millisecond interval between timeouts.
 
     def __init__(self, argv=None, user_ns=None, user_global_ns=None,
                  debug=0, shell_class=MTInteractiveShell):
 
         import qt
 
         self.exec_loop = hijack_qt()
 
         # Allows us to use both Tk and QT.
         self.tk = get_tk()
 
         self.IP = make_IPython(argv,
                                user_ns=user_ns,
                                user_global_ns=user_global_ns,
                                debug=debug,
                                shell_class=shell_class,
                                on_kill=[qt.qApp.exit])
 
         # HACK: slot for banner in self; it will be passed to the mainloop
         # method only and .run() needs it.  The actual value will be set by
         # .mainloop().
         self._banner = None 
         
         threading.Thread.__init__(self)
 
     def mainloop(self, sys_exit=0, banner=None):
 
         import qt
 
         self._banner = banner
 
         if qt.QApplication.startingUp():
             a = qt.QApplication(sys.argv)
 
         self.timer = qt.QTimer()
         qt.QObject.connect(self.timer,
                            qt.SIGNAL('timeout()'),
                            self.on_timer)
 
         self.start()
         self.timer.start(self.TIMEOUT, True)
         while True:
             if self.IP._kill: break
             self.exec_loop()
         self.join()
 
     def on_timer(self):
         update_tk(self.tk)
         result = self.IP.runcode()
         self.timer.start(self.TIMEOUT, True)
         return result
 
 
 class IPShellQt4(IPThread):
     """Run a Qt event loop in a separate thread.
 
     Python commands can be passed to the thread where they will be executed.
     This is implemented by periodically checking for passed code using a
     Qt timer / slot."""
 
     TIMEOUT = 100 # Millisecond interval between timeouts.
 
     def __init__(self, argv=None, user_ns=None, user_global_ns=None,
                  debug=0, shell_class=MTInteractiveShell):
 
         from PyQt4 import QtCore, QtGui
 
         try:
             # present in PyQt4-4.2.1 or later
             QtCore.pyqtRemoveInputHook()
         except AttributeError:
             pass
 
         if QtCore.PYQT_VERSION_STR == '4.3':
             warn('''PyQt4 version 4.3 detected.
 If you experience repeated threading warnings, please update PyQt4.
 ''')
 
         self.exec_ = hijack_qt4()
 
         # Allows us to use both Tk and QT.
         self.tk = get_tk()
 
         self.IP = make_IPython(argv,
                                user_ns=user_ns,
                                user_global_ns=user_global_ns,
                                debug=debug,
                                shell_class=shell_class,
                                on_kill=[QtGui.qApp.exit])
 
         # HACK: slot for banner in self; it will be passed to the mainloop
         # method only and .run() needs it.  The actual value will be set by
         # .mainloop().
         self._banner = None
 
         threading.Thread.__init__(self)
 
     def mainloop(self, sys_exit=0, banner=None):
 
         from PyQt4 import QtCore, QtGui
 
         self._banner = banner
 
         if QtGui.QApplication.startingUp():
             a = QtGui.QApplication(sys.argv)
 
         self.timer = QtCore.QTimer()
         QtCore.QObject.connect(self.timer,
                                QtCore.SIGNAL('timeout()'),
                                self.on_timer)
 
         self.start()
         self.timer.start(self.TIMEOUT)
         while True:
             if self.IP._kill: break
             self.exec_()
         self.join()
 
     def on_timer(self):
         update_tk(self.tk)
         result = self.IP.runcode()
         self.timer.start(self.TIMEOUT)
         return result
 
 
 # A set of matplotlib public IPython shell classes, for single-threaded (Tk*
 # and FLTK*) and multithreaded (GTK*, WX* and Qt*) backends to use.
 def _load_pylab(user_ns):
     """Allow users to disable pulling all of pylab into the top-level
     namespace.
 
     This little utility must be called AFTER the actual ipython instance is
     running, since only then will the options file have been fully parsed."""
     
     ip = ipapi.get()
     if ip.options.pylab_import_all:
         ip.ex("from matplotlib.pylab import *")
         ip.IP.user_config_ns.update(ip.user_ns)
         
 
 class IPShellMatplotlib(IPShell):
     """Subclass IPShell with MatplotlibShell as the internal shell.
 
     Single-threaded class, meant for the Tk* and FLTK* backends.
 
     Having this on a separate class simplifies the external driver code."""
     
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
         IPShell.__init__(self,argv,user_ns,user_global_ns,debug,
                          shell_class=MatplotlibShell)
         _load_pylab(self.IP.user_ns)
 
 class IPShellMatplotlibGTK(IPShellGTK):
     """Subclass IPShellGTK with MatplotlibMTShell as the internal shell.
 
     Multi-threaded class, meant for the GTK* backends."""
     
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
         IPShellGTK.__init__(self,argv,user_ns,user_global_ns,debug,
                             shell_class=MatplotlibMTShell)
         _load_pylab(self.IP.user_ns)
 
 class IPShellMatplotlibWX(IPShellWX):
     """Subclass IPShellWX with MatplotlibMTShell as the internal shell.
 
     Multi-threaded class, meant for the WX* backends."""
     
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
         IPShellWX.__init__(self,argv,user_ns,user_global_ns,debug,
                            shell_class=MatplotlibMTShell)
         _load_pylab(self.IP.user_ns)
 
 class IPShellMatplotlibQt(IPShellQt):
     """Subclass IPShellQt with MatplotlibMTShell as the internal shell.
 
     Multi-threaded class, meant for the Qt* backends."""
     
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
         IPShellQt.__init__(self,argv,user_ns,user_global_ns,debug,
                            shell_class=MatplotlibMTShell)
         _load_pylab(self.IP.user_ns)
 
 class IPShellMatplotlibQt4(IPShellQt4):
     """Subclass IPShellQt4 with MatplotlibMTShell as the internal shell.
 
     Multi-threaded class, meant for the Qt4* backends."""
 
     def __init__(self,argv=None,user_ns=None,user_global_ns=None,debug=1):
         IPShellQt4.__init__(self,argv,user_ns,user_global_ns,debug,
                            shell_class=MatplotlibMTShell)
         _load_pylab(self.IP.user_ns)
 
 #-----------------------------------------------------------------------------
 # Factory functions to actually start the proper thread-aware shell
 
 def _select_shell(argv):
     """Select a shell from the given argv vector.
 
     This function implements the threading selection policy, allowing runtime
     control of the threading mode, both for general users and for matplotlib.
 
     Return:
       Shell class to be instantiated for runtime operation.
     """
     
     global USE_TK
 
     mpl_shell = {'gthread' : IPShellMatplotlibGTK,
                  'wthread' : IPShellMatplotlibWX,
                  'qthread' : IPShellMatplotlibQt,
                  'q4thread' : IPShellMatplotlibQt4,
                  'tkthread' : IPShellMatplotlib,  # Tk is built-in
                  }
 
     th_shell = {'gthread' : IPShellGTK,
                 'wthread' : IPShellWX,
                 'qthread' : IPShellQt,
                 'q4thread' : IPShellQt4,
                 'tkthread' : IPShell, # Tk is built-in
                 }
 
     backends = {'gthread' : 'GTKAgg',
                 'wthread' : 'WXAgg',
                 'qthread' : 'QtAgg',
                 'q4thread' :'Qt4Agg',
                 'tkthread' :'TkAgg',
                 }
 
     all_opts = set(['tk','pylab','gthread','qthread','q4thread','wthread',
                     'tkthread'])
     user_opts = set([s.replace('-','') for s in argv[:3]])
     special_opts = user_opts & all_opts            
 
     if 'tk' in special_opts:
         USE_TK = True
         special_opts.remove('tk')
 
     if 'pylab' in special_opts:
 
         try:
             import matplotlib
         except ImportError:
             error('matplotlib could NOT be imported!  Starting normal IPython.')
             return IPShell
         
         special_opts.remove('pylab')
         # If there's any option left, it means the user wants to force the
         # threading backend, else it's auto-selected from the rc file
         if special_opts:
             th_mode = special_opts.pop()
             matplotlib.rcParams['backend'] = backends[th_mode]
         else:
             backend = matplotlib.rcParams['backend']
             if backend.startswith('GTK'):
                 th_mode = 'gthread'
             elif backend.startswith('WX'):
                 th_mode = 'wthread'
             elif backend.startswith('Qt4'):
                 th_mode = 'q4thread'
             elif backend.startswith('Qt'):
                 th_mode = 'qthread'
             else:
                 # Any other backend, use plain Tk
                 th_mode = 'tkthread'
                 
         return mpl_shell[th_mode]
     else:
         # No pylab requested, just plain threads
         try:
             th_mode = special_opts.pop()
         except KeyError:
             th_mode = 'tkthread'
         return th_shell[th_mode]
 
 
 # This is the one which should be called by external code.
 def start(user_ns = None):
     """Return a running shell instance, dealing with threading options.
 
     This is a factory function which will instantiate the proper IPython shell
     based on the user's threading choice.  Such a selector is needed because
     different GUI toolkits require different thread handling details."""
 
     shell = _select_shell(sys.argv)
     return shell(user_ns = user_ns)
 
 # Some aliases for backwards compatibility
 IPythonShell = IPShell
 IPythonShellEmbed = IPShellEmbed
 #************************ End of file <Shell.py> ***************************

IPython/UserConfig/ipythonrc

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

IPython/core/tests/test_imports.py

@@ -1,29 +1,33
 #!/usr/bin/env python
 # encoding: utf-8
 
 def test_import_completer():
     from IPython.core import completer
 
 def test_import_crashhandler():
     from IPython.core import crashhandler
 
 def test_import_debugger():
     from IPython.core import debugger
 
 def test_import_fakemodule():
     from IPython.core import fakemodule
 
 def test_import_excolors():
     from IPython.core import excolors
 
 def test_import_history():
     from IPython.core import history
 
 def test_import_hooks():
     from IPython.core import hooks
 
 def test_import_ipapi():
     from IPython.core import ipapi
 
+def test_imort_iplib():
+    from IPython.core import iplib
+
+
 
 

IPython/core/tests/test_iplib.py

@@ -1,81 +1,81
 """Tests for the key iplib module, where the main ipython class is defined.
 """
 #-----------------------------------------------------------------------------
 # Module imports
 #-----------------------------------------------------------------------------
 
 # stdlib
 import os
 import shutil
 import tempfile
 
 # third party
 import nose.tools as nt
 
 # our own packages
-from IPython import iplib
+from IPython.core import iplib
 from IPython.core import ipapi
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 # Useful global ipapi object and main IPython one.  Unfortunately we have a
 # long precedent of carrying the 'ipapi' global object which is injected into
 # the system namespace as _ip, but that keeps a pointer to the actual IPython
 # InteractiveShell instance, which is named IP.  Since in testing we do need
 # access to the real thing (we want to probe beyond what ipapi exposes), make
 # here a global reference to each.  In general, things that are exposed by the
 # ipapi instance should be read from there, but we also will often need to use
 # the actual IPython one.
 
 # Get the public instance of IPython, and if it's None, make one so we can use
 # it for testing
 ip = ipapi.get()
 if ip is None:
     # IPython not running yet,  make one from the testing machinery for
     # consistency when the test suite is being run via iptest
     from IPython.testing.plugin import ipdoctest
     ip = ipapi.get()
     
 IP = ip.IP  # This is the actual IPython shell 'raw' object.
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
 def test_reset():
     """reset must clear most namespaces."""
     IP.reset()  # first, it should run without error
     # Then, check that most namespaces end up empty
     for ns in IP.ns_refs_table:
         if ns is IP.user_ns:
             # The user namespace is reset with some data, so we can't check for
             # it being empty
             continue
         nt.assert_equals(len(ns),0)
 
 
 # make sure that user_setup can be run re-entrantly in 'install' mode.
 def test_user_setup():
     # use a lambda to pass kwargs to the generator
     user_setup = lambda a,k: iplib.user_setup(*a,**k)
     kw = dict(mode='install', interactive=False)
 
     # Call the user setup and verify that the directory exists
     yield user_setup, (ip.options.ipythondir,''), kw
     yield os.path.isdir, ip.options.ipythondir
 
     # Now repeat the operation with a non-existent directory. Check both that
     # the call succeeds and that the directory is created.
     tmpdir = tempfile.mktemp(prefix='ipython-test-')
     # Use a try with an empty except because try/finally doesn't work with a 
     # yield in Python 2.4.
     try:
         yield user_setup, (tmpdir,''), kw
         yield os.path.isdir, tmpdir
     except:
         pass
     # Clean up the temp dir once done
     shutil.rmtree(tmpdir)
     
  No newline at end of file

IPython/deathrow/GnuplotInteractive.py

@@ -1,147 +1,147
 # -*- 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.
 """
 
 __all__ = ['Gnuplot','gp','gp_new','plot','plot2','splot','replot',
            'hardcopy','gpdata','gpfile','gpstring','gpfunc','gpgrid',
            'gphelp']
 
 import IPython.GnuplotRuntime as GRun
 from IPython.utils.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
+    from IPython.core.iplib import InteractiveShell
     InteractiveShell.magic_gpc = magic_gpc
     InteractiveShell.magic_gp_set_default = magic_gp_set_default
 
 #********************** End of file <GnuplotInteractive.py> *******************

IPython/deathrow/twshell.py

@@ -1,282 +1,282
 """Twisted shell support.
 
 XXX - This module is missing proper docs.
 """
 import sys
 
 from twisted.internet import reactor, threads
 
 from IPython.ipmaker import make_IPython
-from IPython.iplib import InteractiveShell 
+from IPython.core.iplib import InteractiveShell 
 from IPython.ipstruct import Struct
 import Queue,thread,threading,signal
 from signal import signal, SIGINT
 from IPython.utils.genutils import Term,warn,error,flag_calls, ask_yes_no
 import shellglobals
 
 def install_gtk2():
     """ Install gtk2 reactor, needs to be called bef """
     from twisted.internet import gtk2reactor
     gtk2reactor.install()
 
 
 def hijack_reactor():
     """Modifies Twisted's reactor with a dummy so user code does
     not block IPython.  This function returns the original
     'twisted.internet.reactor' that has been hijacked.
 
     NOTE: Make sure you call this *AFTER* you've installed
     the reactor of your choice.
     """
     from twisted import internet
     orig_reactor = internet.reactor
 
     class DummyReactor(object):
         def run(self):
             pass
         def __getattr__(self, name):
             return getattr(orig_reactor, name)
         def __setattr__(self, name, value):
             return setattr(orig_reactor, name, value)
     
     internet.reactor = DummyReactor()
     return orig_reactor
 
 class TwistedInteractiveShell(InteractiveShell):
     """Simple multi-threaded shell."""
 
     # Threading strategy taken from:
     # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
     # McErlean and John Finlay.  Modified with corrections by Antoon Pardon,
     # from the pygtk mailing list, to avoid lockups with system calls.
 
     # class attribute to indicate whether the class supports threads or not.
     # Subclasses with thread support should override this as needed.
     isthreaded = True
 
     def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
                  user_ns=None,user_global_ns=None,banner2='',**kw):
         """Similar to the normal InteractiveShell, but with threading control"""
         
         InteractiveShell.__init__(self,name,usage,rc,user_ns,
                                   user_global_ns,banner2)
 
 
         # A queue to hold the code to be executed. 
         self.code_queue = Queue.Queue()
 
         # Stuff to do at closing time
         self._kill = None
         on_kill = kw.get('on_kill', [])
         # Check that all things to kill are callable:
         for t in on_kill:
             if not callable(t):
                 raise TypeError,'on_kill must be a list of callables'
         self.on_kill = on_kill
         # thread identity of the "worker thread" (that may execute code directly)
         self.worker_ident = None
         self.reactor_started = False
         self.first_run = True
         
     def runsource(self, source, filename="<input>", symbol="single"):
         """Compile and run some source in the interpreter.
 
         Modified version of code.py's runsource(), to handle threading issues.
         See the original for full docstring details."""
         
         # If Ctrl-C was typed, we reset the flag and return right away
         if shellglobals.KBINT:
             shellglobals.KBINT = False
             return False
 
         if self._kill:
             # can't queue new code if we are being killed
             return True
         
         try:
             code = self.compile(source, filename, symbol)
         except (OverflowError, SyntaxError, ValueError):
             # Case 1
             self.showsyntaxerror(filename)
             return False
 
         if code is None:
             # Case 2
             return True
 
         # shortcut - if we are in worker thread, or the worker thread is not running, 
         # execute directly (to allow recursion and prevent deadlock if code is run early 
         # in IPython construction)
         
         if (not self.reactor_started or (self.worker_ident is None and not self.first_run) 
             or self.worker_ident == thread.get_ident() or shellglobals.run_in_frontend(source)):
             InteractiveShell.runcode(self,code)
             return
 
         # Case 3
         # Store code in queue, so the execution thread can handle it.
  
         self.first_run = False
         completed_ev, received_ev = threading.Event(), threading.Event() 
         
         self.code_queue.put((code,completed_ev, received_ev))
 
         reactor.callLater(0.0,self.runcode)
         received_ev.wait(5)
         if not received_ev.isSet():
             # the mainloop is dead, start executing code directly
             print "Warning: Timeout for mainloop thread exceeded"
             print "switching to nonthreaded mode (until mainloop wakes up again)"
             self.worker_ident = None
         else:            
             completed_ev.wait()
         
         return False
 
     def runcode(self):
         """Execute a code object.
 
         Multithreaded wrapper around IPython's runcode()."""
         
         
         # we are in worker thread, stash out the id for runsource() 
         self.worker_ident = thread.get_ident()
 
         if self._kill:
             print >>Term.cout, 'Closing threads...',
             Term.cout.flush()
             for tokill in self.on_kill:
                 tokill()
             print >>Term.cout, 'Done.'
             # allow kill() to return
             self._kill.set()
             return True
 
         # Install SIGINT handler.  We do it every time to ensure that if user
         # code modifies it, we restore our own handling.
         try:
             pass
             signal(SIGINT,shellglobals.sigint_handler)
         except SystemError:
             # This happens under Windows, which seems to have all sorts
             # of problems with signal handling.  Oh well...
             pass
 
         # Flush queue of pending code by calling the run methood of the parent
         # class with all items which may be in the queue.
         code_to_run = None
         while 1:
             try:
                 code_to_run, completed_ev, received_ev = self.code_queue.get_nowait()                
             except Queue.Empty:
                 break
             received_ev.set()
 
             
             # Exceptions need to be raised differently depending on which
             # thread is active.  This convoluted try/except is only there to
             # protect against asynchronous exceptions, to ensure that a shellglobals.KBINT
             # at the wrong time doesn't deadlock everything.  The global
             # CODE_TO_RUN is set to true/false as close as possible to the
             # runcode() call, so that the KBINT handler is correctly informed.
             try:
                 try:
                    shellglobals.CODE_RUN = True
                    InteractiveShell.runcode(self,code_to_run)
                 except KeyboardInterrupt:
                    print "Keyboard interrupted in mainloop"
                    while not self.code_queue.empty():
                       code = self.code_queue.get_nowait()
                    break
             finally:
                 shellglobals.CODE_RUN = False
                 # allow runsource() return from wait
                 completed_ev.set()                
         
         # This MUST return true for gtk threading to work
         return True
 
     def kill(self):
         """Kill the thread, returning when it has been shut down."""
         self._kill = threading.Event()
         reactor.callLater(0.0,self.runcode)
         self._kill.wait()
 
 
 
 class IPShellTwisted:
     """Run a Twisted reactor while in an IPython session.
 
     Python commands can be passed to the thread where they will be
     executed.  This is implemented by periodically checking for
     passed code using a Twisted reactor callback.
     """
 
     TIMEOUT = 0.01 # Millisecond interval between reactor runs.
 
     def __init__(self, argv=None, user_ns=None, debug=1,
                  shell_class=TwistedInteractiveShell):
 
         from twisted.internet import reactor
         self.reactor = hijack_reactor()
 
         mainquit = self.reactor.stop
 
         # Make sure IPython keeps going after reactor stop.
         def reactorstop():
             pass
         self.reactor.stop = reactorstop
         reactorrun_orig = self.reactor.run
         self.quitting = False
         def reactorrun():
             while True and not self.quitting:
                 reactorrun_orig()
         self.reactor.run = reactorrun
         
         self.IP = make_IPython(argv, user_ns=user_ns, debug=debug,
                                shell_class=shell_class,
                                on_kill=[mainquit])
 
         # threading.Thread.__init__(self)
 
     def run(self):
         self.IP.mainloop()
         self.quitting = True
         self.IP.kill()
 
     def mainloop(self):
         def mainLoopThreadDeath(r):
             print "mainLoopThreadDeath: ", str(r)
         def spawnMainloopThread():
             d=threads.deferToThread(self.run)
             d.addBoth(mainLoopThreadDeath)
         reactor.callWhenRunning(spawnMainloopThread)
         self.IP.reactor_started = True
         self.reactor.run()
         print "mainloop ending...."   
         
 exists = True
 
 
 if __name__ == '__main__':
     # Sample usage.
 
     # Create the shell object. This steals twisted.internet.reactor
     # for its own purposes, to make sure you've already installed a
     # reactor of your choice.
     shell = IPShellTwisted(
         argv=[],
         user_ns={'__name__': '__example__',
                  'hello': 'world',
                  },
         )
 
     # Run the mainloop.  This runs the actual reactor.run() method.
     # The twisted.internet.reactor object at this point is a dummy
     # object that passes through to the actual reactor, but prevents
     # run() from being called on it again.
     shell.mainloop()
 
     # You must exit IPython to terminate your program.
     print 'Goodbye!'
 

IPython/frontend/prefilterfrontend.py

@@ -1,285 +1,285
 """
 Frontend class that uses IPython0 to prefilter the inputs.
 
 Using the IPython0 mechanism gives us access to the magics.
 
 This is a transitory class, used here to do the transition between
 ipython0 and ipython1. This class is meant to be short-lived as more
 functionnality is abstracted out of ipython0 in reusable functions and
 is added on the interpreter. This class can be a used to guide this
 refactoring.
 """
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 import sys
 import pydoc
 import os
 import re
 import __builtin__
 
 from IPython.ipmaker import make_IPython
 from IPython.core.ipapi import IPApi
 from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap
 
 from IPython.kernel.core.sync_traceback_trap import SyncTracebackTrap
 
 from IPython.utils.genutils import Term
 
 from linefrontendbase import LineFrontEndBase, common_prefix
 
 
 def mk_system_call(system_call_function, command):
     """ given a os.system replacement, and a leading string command,
         returns a function that will execute the command with the given
         argument string.
     """
     def my_system_call(args):
         system_call_function("%s %s" % (command, args))
 
     my_system_call.__doc__ = "Calls %s" % command
     return my_system_call
 
 #-------------------------------------------------------------------------------
 # Frontend class using ipython0 to do the prefiltering. 
 #-------------------------------------------------------------------------------
 class PrefilterFrontEnd(LineFrontEndBase):
     """ Class that uses ipython0 to do prefilter the input, do the
     completion and the magics.
 
     The core trick is to use an ipython0 instance to prefilter the
     input, and share the namespace between the interpreter instance used
     to execute the statements and the ipython0 used for code
     completion...
     """
 
     debug = False
     
     def __init__(self, ipython0=None, argv=None, *args, **kwargs):
         """ Parameters:
             -----------
 
             ipython0: an optional ipython0 instance to use for command
             prefiltering and completion.
 
             argv : list, optional
               Used as the instance's argv value.  If not given, [] is used.
         """
         if argv is None:
             argv = []
         # This is a hack to avoid the IPython exception hook to trigger
         # on exceptions (https://bugs.launchpad.net/bugs/337105)
         # XXX: This is horrible: module-leve monkey patching -> side
         # effects.
-        from IPython import iplib
+        from IPython.core import iplib
         iplib.InteractiveShell.isthreaded = True
 
         LineFrontEndBase.__init__(self, *args, **kwargs)
         self.shell.output_trap = RedirectorOutputTrap(
                             out_callback=self.write,
                             err_callback=self.write,
                                             )
         self.shell.traceback_trap = SyncTracebackTrap(
                         formatters=self.shell.traceback_trap.formatters,
                             )
 
         # Start the ipython0 instance:
         self.save_output_hooks()
         if ipython0 is None:
             # Instanciate an IPython0 interpreter to be able to use the
             # prefiltering.
             # Suppress all key input, to avoid waiting
             def my_rawinput(x=None):
                 return '\n'
             old_rawinput = __builtin__.raw_input
             __builtin__.raw_input = my_rawinput
             # XXX: argv=[] is a bit bold.
             ipython0 = make_IPython(argv=argv, 
                                     user_ns=self.shell.user_ns,
                                     user_global_ns=self.shell.user_global_ns)
             __builtin__.raw_input = old_rawinput
         self.ipython0 = ipython0
         # Set the pager:
         self.ipython0.set_hook('show_in_pager', 
                     lambda s, string: self.write("\n" + string))
         self.ipython0.write = self.write
         self._ip = _ip = IPApi(self.ipython0)
         # Make sure the raw system call doesn't get called, as we don't
         # have a stdin accessible.
         self._ip.system = self.system_call
         # XXX: Muck around with magics so that they work better
         # in our environment
         if not sys.platform.startswith('win'):
             self.ipython0.magic_ls = mk_system_call(self.system_call, 
                                                                 'ls -CF')
         # And now clean up the mess created by ipython0
         self.release_output()
 
 
         if not 'banner' in kwargs and self.banner is None:
             self.banner = self.ipython0.BANNER
 
         # FIXME: __init__ and start should be two different steps
         self.start()
 
     #--------------------------------------------------------------------------
     # FrontEndBase interface 
     #--------------------------------------------------------------------------
 
     def show_traceback(self):
         """ Use ipython0 to capture the last traceback and display it.
         """
         # Don't do the capture; the except_hook has already done some
         # modifications to the IO streams, if we store them, we'll be
         # storing the wrong ones.
         #self.capture_output()
         self.ipython0.showtraceback(tb_offset=-1)
         self.release_output()
 
 
     def execute(self, python_string, raw_string=None):
         if self.debug:
             print 'Executing Python code:', repr(python_string)
         self.capture_output()
         LineFrontEndBase.execute(self, python_string,
                                     raw_string=raw_string)
         self.release_output()
 
 
     def save_output_hooks(self):
         """ Store all the output hooks we can think of, to be able to
         restore them. 
         
         We need to do this early, as starting the ipython0 instance will
         screw ouput hooks.
         """
         self.__old_cout_write = Term.cout.write
         self.__old_cerr_write = Term.cerr.write
         self.__old_stdout = sys.stdout
         self.__old_stderr= sys.stderr
         self.__old_help_output = pydoc.help.output
         self.__old_display_hook = sys.displayhook
 
 
     def capture_output(self):
         """ Capture all the output mechanisms we can think of.
         """
         self.save_output_hooks()
         Term.cout.write = self.write
         Term.cerr.write = self.write
         sys.stdout = Term.cout
         sys.stderr = Term.cerr
         pydoc.help.output = self.shell.output_trap.out
 
 
     def release_output(self):
         """ Release all the different captures we have made.
         """
         Term.cout.write = self.__old_cout_write
         Term.cerr.write = self.__old_cerr_write
         sys.stdout = self.__old_stdout
         sys.stderr = self.__old_stderr
         pydoc.help.output = self.__old_help_output 
         sys.displayhook = self.__old_display_hook 
 
 
     def complete(self, line):
         # FIXME: This should be factored out in the linefrontendbase
         # method.
         word = self._get_completion_text(line)
         completions = self.ipython0.complete(word)
         # FIXME: The proper sort should be done in the complete method.
         key = lambda x: x.replace('_', '')
         completions.sort(key=key)
         if completions:
             prefix = common_prefix(completions) 
             line = line[:-len(word)] + prefix
         return line, completions 
  
     
     #--------------------------------------------------------------------------
     # LineFrontEndBase interface 
     #--------------------------------------------------------------------------
 
     def prefilter_input(self, input_string):
         """ Using IPython0 to prefilter the commands to turn them
         in executable statements that are valid Python strings.
         """
         input_string = LineFrontEndBase.prefilter_input(self, input_string)
         filtered_lines = []
         # The IPython0 prefilters sometime produce output. We need to
         # capture it.
         self.capture_output()
         self.last_result = dict(number=self.prompt_number)
         
         ## try:
         ##     for line in input_string.split('\n'):
         ##         filtered_lines.append(
         ##                 self.ipython0.prefilter(line, False).rstrip())
         ## except:
         ##     # XXX: probably not the right thing to do.
         ##     self.ipython0.showsyntaxerror()
         ##     self.after_execute()
         ## finally:
         ##     self.release_output()
 
 
         try:
             try:
                 for line in input_string.split('\n'):
                     filtered_lines.append(
                             self.ipython0.prefilter(line, False).rstrip())
             except:
                 # XXX: probably not the right thing to do.
                 self.ipython0.showsyntaxerror()
                 self.after_execute()
         finally:
             self.release_output()
 
 
 
         # Clean up the trailing whitespace, to avoid indentation errors
         filtered_string = '\n'.join(filtered_lines)
         return filtered_string
 
 
     #--------------------------------------------------------------------------
     # PrefilterFrontEnd interface 
     #--------------------------------------------------------------------------
  
     def system_call(self, command_string):
         """ Allows for frontend to define their own system call, to be
             able capture output and redirect input.
         """
         return os.system(command_string)
 
 
     def do_exit(self):
         """ Exit the shell, cleanup and save the history.
         """
         self.ipython0.atexit_operations()
 
 
     def _get_completion_text(self, line):
         """ Returns the text to be completed by breaking the line at specified
         delimiters.
         """
         # Break at: spaces, '=', all parentheses (except if balanced).
         # FIXME2: In the future, we need to make the implementation similar to
         # that in the 'pyreadline' module (modes/basemode.py) where we break at
         # each delimiter and try to complete the residual line, until we get a
         # successful list of completions.
         expression = '\s|=|,|:|\((?!.*\))|\[(?!.*\])|\{(?!.*\})' 
         complete_sep = re.compile(expression)
         text = complete_sep.split(line)[-1]
         return text
 

IPython/frontend/tests/test_prefilterfrontend.py

@@ -1,252 +1,252
 # encoding: utf-8
 """
 Test process execution and IO redirection.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is
 #  in the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 from copy import copy, deepcopy
 from cStringIO import StringIO
 import string
 
 from nose.tools import assert_equal
 
 from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
 from IPython.core.ipapi import get as get_ipython0
 from IPython.testing.plugin.ipdoctest import default_argv
 
 
 def safe_deepcopy(d):
     """ Deep copy every key of the given dict, when possible. Elsewhere
         do a copy.
     """
     copied_d = dict()
     for key, value in d.iteritems():
         try:
             copied_d[key] = deepcopy(value)
         except:
             try:
                 copied_d[key] = copy(value)
             except:
                 copied_d[key] = value
     return copied_d
 
 
 class TestPrefilterFrontEnd(PrefilterFrontEnd):
     
     input_prompt_template = string.Template('')
     output_prompt_template = string.Template('')
     banner = ''
 
     def __init__(self):
         self.out = StringIO()
         PrefilterFrontEnd.__init__(self,argv=default_argv())
         # Some more code for isolation (yeah, crazy)
         self._on_enter()
         self.out.flush()
         self.out.reset()
         self.out.truncate()
 
     def write(self, string, *args, **kwargs):
        self.out.write(string) 
 
     def _on_enter(self):
         self.input_buffer += '\n'
         PrefilterFrontEnd._on_enter(self)
 
 
 def isolate_ipython0(func):
     """ Decorator to isolate execution that involves an iptyhon0.
 
         Notes
         -----
 
         Apply only to functions with no arguments. Nose skips functions
         with arguments.
     """
     def my_func():
         iplib = get_ipython0()
         if iplib is None:
             return func()
         ipython0 = iplib.IP
         global_ns = safe_deepcopy(ipython0.user_global_ns)
         user_ns = safe_deepcopy(ipython0.user_ns)
         try:
             out = func()
         finally:
             ipython0.user_ns = user_ns
             ipython0.user_global_ns = global_ns
         # Undo the hack at creation of PrefilterFrontEnd
-        from IPython import iplib
+        from IPythoncore. import iplib
         iplib.InteractiveShell.isthreaded = False
         return out
 
     my_func.__name__ = func.__name__
     return my_func
 
 
 @isolate_ipython0
 def test_execution():
     """ Test execution of a command.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'print 1'
     f._on_enter()
     out_value = f.out.getvalue()
     assert_equal(out_value, '1\n')
 
 
 @isolate_ipython0
 def test_multiline():
     """ Test execution of a multiline command.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'if True:'
     f._on_enter()
     f.input_buffer += 'print 1'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, ''
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1\n'
     f = TestPrefilterFrontEnd()
     f.input_buffer='(1 +'
     f._on_enter()
     f.input_buffer += '0)'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, ''
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1\n'
 
 
 @isolate_ipython0
 def test_capture():
     """ Test the capture of output in different channels.
     """
     # Test on the OS-level stdout, stderr.
     f = TestPrefilterFrontEnd()
     f.input_buffer = \
             'import os; out=os.fdopen(1, "w"); out.write("1") ; out.flush()'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1'
     f = TestPrefilterFrontEnd()
     f.input_buffer = \
             'import os; out=os.fdopen(2, "w"); out.write("1") ; out.flush()'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1'
 
      
 @isolate_ipython0
 def test_magic():
     """ Test the magic expansion and history.
     
         This test is fairly fragile and will break when magics change.
     """
     f = TestPrefilterFrontEnd()
     # Before checking the interactive namespace, make sure it's clear (it can
     # otherwise pick up things stored in the user's local db)
     f.input_buffer += '%reset -f'
     f._on_enter()
     f.complete_current_input()
     # Now, run the %who magic and check output
     f.input_buffer += '%who'
     f._on_enter()
     out_value = f.out.getvalue()
     assert_equal(out_value, 'Interactive namespace is empty.\n')
 
 
 @isolate_ipython0
 def test_help():
     """ Test object inspection.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer += "def f():"
     f._on_enter()
     f.input_buffer += "'foobar'"
     f._on_enter()
     f.input_buffer += "pass"
     f._on_enter()
     f._on_enter()
     f.input_buffer += "f?"
     f._on_enter()
     assert 'traceback' not in f.last_result
     ## XXX: ipython doctest magic breaks this. I have no clue why
     #out_value = f.out.getvalue()
     #assert out_value.split()[-1] == 'foobar' 
 
 
 @isolate_ipython0
 def test_completion_simple():
     """ Test command-line completion on trivial examples.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'zzza = 1'
     f._on_enter()
     f.input_buffer = 'zzzb = 2'
     f._on_enter()
     f.input_buffer = 'zz'
     f.complete_current_input()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '\nzzza zzzb '
     yield assert_equal, f.input_buffer, 'zzz'
 
 
 @isolate_ipython0
 def test_completion_parenthesis():
     """ Test command-line completion when a parenthesis is open.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'zzza = 1'
     f._on_enter()
     f.input_buffer = 'zzzb = 2'
     f._on_enter()
     f.input_buffer = 'map(zz'
     f.complete_current_input()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '\nzzza zzzb '
     yield assert_equal, f.input_buffer, 'map(zzz'
 
 
 @isolate_ipython0
 def test_completion_indexing():
     """ Test command-line completion when indexing on objects.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'a = [0]'
     f._on_enter()
     f.input_buffer = 'a[0].'
     f.complete_current_input()
     assert_equal(f.input_buffer, 'a[0].__')
 
 
 @isolate_ipython0
 def test_completion_equal():
     """ Test command-line completion when the delimiter is "=", not " ".
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'a=1.'
     f.complete_current_input()
     assert_equal(f.input_buffer, 'a=1.__')
 
 
 
 if __name__ == '__main__':
     test_magic()
     test_help()
     test_execution()
     test_multiline()
     test_capture()
     test_completion_simple()
     test_completion_complex()

IPython/gui/wx/ipshell_nonblocking.py

@@ -1,526 +1,527
 #!/usr/bin/python
 # -*- coding: iso-8859-15 -*-
 '''
 Provides IPython remote instance.
 
 @author: Laurent Dufrechou
 laurent.dufrechou _at_ gmail.com
 @license: BSD
 
 All rights reserved. This program and the accompanying materials are made
 available under the terms of the BSD which accompanies this distribution, and
 is available at U{http://www.opensource.org/licenses/bsd-license.php}
 '''
 
 __version__ = 0.9
 __author__  = "Laurent Dufrechou"
 __email__   = "laurent.dufrechou _at_ gmail.com"
 __license__ = "BSD"
 
 import re
 import sys
 import os
 import locale
 from thread_ex import ThreadEx
 
 try:
     import IPython
     from IPython.utils import genutils
+    from IPython.core import iplib
 except Exception,e:
     print "Error importing IPython (%s)" % str(e)
     raise Exception, e
 
 ##############################################################################
 class _Helper(object):
     """Redefine the built-in 'help'.
     This is a wrapper around pydoc.help (with a twist).
     """
 
     def __init__(self, pager):
         self._pager = pager
 
     def __repr__(self):
         return "Type help() for interactive help, " \
                "or help(object) for help about object."
     
     def __call__(self, *args, **kwds):
         class DummyWriter(object):
             '''Dumy class to handle help output'''	
             def __init__(self, pager):
                 self._pager = pager
                 
             def write(self, data):
                 '''hook to fill self._pager'''
                 self._pager(data)
 
         import pydoc
         pydoc.help.output = DummyWriter(self._pager)
         pydoc.help.interact = lambda :1
         
         return pydoc.help(*args, **kwds)
 
   
 ##############################################################################
 class _CodeExecutor(ThreadEx):
     ''' Thread that execute ipython code '''
     def __init__(self, instance):
         ThreadEx.__init__(self)
         self.instance = instance
         
     def run(self):
         '''Thread main loop'''
         try:
             self.instance._doc_text = None
             self.instance._help_text = None
             self.instance._execute()
             # used for uper class to generate event after execution
             self.instance._after_execute() 
             
         except KeyboardInterrupt:
             pass
  
 
 ##############################################################################
 class NonBlockingIPShell(object):
     '''
     Create an IPython instance, running the commands in a separate,
     non-blocking thread. 
     This allows embedding in any GUI without blockage.
 
     Note: The ThreadEx class supports asynchroneous function call
           via raise_exc()
     '''
 
     def __init__(self, argv=[], user_ns={}, user_global_ns=None,
                  cin=None, cout=None, cerr=None,
                  ask_exit_handler=None):
         '''
         @param argv: Command line options for IPython
         @type argv: list
         @param user_ns: User namespace.
         @type user_ns: dictionary
         @param user_global_ns: User global namespace.
         @type user_global_ns: dictionary.
         @param cin: Console standard input.
         @type cin: IO stream
         @param cout: Console standard output.
         @type cout: IO stream
         @param cerr: Console standard error.
         @type cerr: IO stream
         @param exit_handler: Replacement for builtin exit() function
         @type exit_handler: function
         @param time_loop: Define the sleep time between two thread's loop
         @type int
         '''
         #ipython0 initialisation
         self._IP = None
         self.init_ipython0(argv, user_ns, user_global_ns,
                           cin, cout, cerr,
                           ask_exit_handler)
         
         #vars used by _execute
         self._iter_more = 0
         self._history_level = 0
         self._complete_sep =  re.compile('[\s\{\}\[\]\(\)\=]')
         self._prompt = str(self._IP.outputcache.prompt1).strip()
 
         #thread working vars
         self._line_to_execute = ''
         self._threading = True
         
         #vars that will be checked by GUI loop to handle thread states...
         #will be replaced later by PostEvent GUI funtions...
         self._doc_text = None
         self._help_text = None
         self._add_button = None
 
     def init_ipython0(self, argv=[], user_ns={}, user_global_ns=None,
                      cin=None, cout=None, cerr=None,
                      ask_exit_handler=None):
         ''' Initialize an ipython0 instance '''
         
         #first we redefine in/out/error functions of IPython
         #BUG: we've got a limitation form ipython0 there
         #only one instance can be instanciated else tehre will be
         #cin/cout/cerr clash...
         if cin:
             genutils.Term.cin = cin
         if cout:
             genutils.Term.cout = cout
         if cerr:
             genutils.Term.cerr = cerr
         
         excepthook = sys.excepthook
 
         #Hack to save sys.displayhook, because ipython seems to overwrite it...
         self.sys_displayhook_ori = sys.displayhook
         
         self._IP = IPython.Shell.make_IPython(
                                     argv,user_ns=user_ns,
                                     user_global_ns=user_global_ns,
                                     embedded=True,
                                     shell_class=IPython.Shell.InteractiveShell)
 
         #we save ipython0 displayhook and we restore sys.displayhook
         self.displayhook = sys.displayhook
         sys.displayhook = self.sys_displayhook_ori
 
         #we replace IPython default encoding by wx locale encoding
         loc = locale.getpreferredencoding()
         if loc:
             self._IP.stdin_encoding = loc
         #we replace the ipython default pager by our pager
         self._IP.set_hook('show_in_pager', self._pager)
         
         #we replace the ipython default shell command caller 
         #by our shell handler
         self._IP.set_hook('shell_hook', self._shell)
         
         #we replace the ipython default input command caller by our method
-        IPython.iplib.raw_input_original = self._raw_input_original
+        iplib.raw_input_original = self._raw_input_original
         #we replace the ipython default exit command by our method
         self._IP.exit = ask_exit_handler
         #we replace the help command
         self._IP.user_ns['help'] = _Helper(self._pager_help)
 
         #we disable cpase magic... until we found a way to use it properly.
         from IPython.core import ipapi
         ip = ipapi.get()
         def bypass_magic(self, arg):
             print '%this magic is currently disabled.'
         ip.expose_magic('cpaste', bypass_magic)
 
         import __builtin__
         __builtin__.raw_input = self._raw_input
         
         sys.excepthook = excepthook
 
     #----------------------- Thread management section ----------------------   
     def do_execute(self, line):
         """
         Tell the thread to process the 'line' command
         """
 
         self._line_to_execute = line
 
         if self._threading:
             #we launch the ipython line execution in a thread to make it 
             #interruptible with include it in self namespace to be able 
             #to call  ce.raise_exc(KeyboardInterrupt)
             self.ce = _CodeExecutor(self)
             self.ce.start()
         else:
             try:
                 self._doc_text = None
                 self._help_text = None
                 self._execute()
                 # used for uper class to generate event after execution
                 self._after_execute() 
             
             except KeyboardInterrupt:
                 pass
 
     #----------------------- IPython management section ----------------------
     def get_threading(self):
         """
         Returns threading status, is set to True, then each command sent to
         the interpreter will be executed in a separated thread allowing,
         for example, breaking a long running commands.
         Disallowing it, permits better compatibilty with instance that is embedding
         IPython instance.
 
         @return: Execution method
         @rtype: bool
         """
         return self._threading
     
     def set_threading(self, state):
         """
         Sets threading state, if set to True, then each command sent to
         the interpreter will be executed in a separated thread allowing,
         for example, breaking a long running commands.
         Disallowing it, permits better compatibilty with instance that is embedding
         IPython instance.
 
         @param state: Sets threading state
         @type bool
         """
         self._threading = state
 
     def get_doc_text(self):
         """
         Returns the output of the processing that need to be paged (if any)
 
         @return: The std output string.
         @rtype: string
         """
         return self._doc_text
         
     def get_help_text(self):
         """
         Returns the output of the processing that need to be paged via help pager(if any)
 
         @return: The std output string.
         @rtype: string
         """
         return self._help_text
 
     def get_banner(self):
         """
         Returns the IPython banner for useful info on IPython instance
 
         @return: The banner string.
         @rtype: string
         """
         return self._IP.BANNER
     
     def get_prompt_count(self):
         """
         Returns the prompt number.
         Each time a user execute a line in the IPython shell the prompt count is increased
 
         @return: The prompt number
         @rtype: int
         """
         return self._IP.outputcache.prompt_count
 
     def get_prompt(self):
         """
         Returns current prompt inside IPython instance
         (Can be In [...]: ot ...:)
 
         @return: The current prompt.
         @rtype: string
         """
         return self._prompt
 
     def get_indentation(self):
         """
         Returns the current indentation level
         Usefull to put the caret at the good start position if we want to do autoindentation.
 
         @return: The indentation level.
         @rtype: int
         """
         return self._IP.indent_current_nsp
         
     def update_namespace(self, ns_dict):
         '''
         Add the current dictionary to the shell namespace.
 
         @param ns_dict: A dictionary of symbol-values.
         @type ns_dict: dictionary
         '''
         self._IP.user_ns.update(ns_dict)
 
     def complete(self, line):
         '''
         Returns an auto completed line and/or posibilities for completion.
 
         @param line: Given line so far.
         @type line: string
 
         @return: Line completed as for as possible,
         and possible further completions.
         @rtype: tuple
         '''
         split_line = self._complete_sep.split(line)
         possibilities = self._IP.complete(split_line[-1])
         if possibilities:
 
             def _common_prefix(str1, str2):
                 '''
                 Reduction function. returns common prefix of two given strings.
 
                 @param str1: First string.
                 @type str1: string
                 @param str2: Second string
                 @type str2: string
 
                 @return: Common prefix to both strings.
                 @rtype: string
                 '''
                 for i in range(len(str1)):
                     if not str2.startswith(str1[:i+1]):
                         return str1[:i]
                 return str1
             common_prefix = reduce(_common_prefix, possibilities)
             completed = line[:-len(split_line[-1])]+common_prefix
         else:
             completed = line
         return completed, possibilities
 
     def history_back(self):
         '''
         Provides one history command back.
 
         @return: The command string.
         @rtype: string
         '''
         history = ''
         #the below while loop is used to suppress empty history lines
         while((history == '' or history == '\n') and self._history_level >0):
             if self._history_level >= 1:
                 self._history_level -= 1
             history = self._get_history()            
         return history
 
     def history_forward(self):
         '''
         Provides one history command forward.
 
         @return: The command string.
         @rtype: string
         '''
         history = ''
         #the below while loop is used to suppress empty history lines
         while((history == '' or history == '\n') \
         and self._history_level <= self._get_history_max_index()):
             if self._history_level < self._get_history_max_index():
                 self._history_level += 1
                 history = self._get_history()
             else:
                 if self._history_level == self._get_history_max_index():
                     history = self._get_history()
                     self._history_level += 1
                 else:
                     history = ''
         return history
 
     def init_history_index(self):
         '''
         set history to last command entered
         '''
         self._history_level = self._get_history_max_index()+1
 
     #----------------------- IPython PRIVATE management section --------------
     def _after_execute(self):
         '''
         Can be redefined to generate post event after excution is done
         '''
         pass
 
     def _ask_exit(self):
         '''
         Can be redefined to generate post event to exit the Ipython shell
         '''
         pass
 
     def _get_history_max_index(self):
         '''
         returns the max length of the history buffer
 
         @return: history length
         @rtype: int
         '''
         return len(self._IP.input_hist_raw)-1
         
     def _get_history(self):
         '''
         Get's the command string of the current history level.
 
         @return: Historic command stri
         @rtype: string
         '''
         rv = self._IP.input_hist_raw[self._history_level].strip('\n')
         return rv
 
     def _pager_help(self, text):
         '''
         This function is used as a callback replacment to IPython help pager function
 
         It puts the 'text' value inside the self._help_text string that can be retrived via
         get_help_text function.
         '''
         if self._help_text == None:
             self._help_text = text
         else:
             self._help_text += text
     
     def _pager(self, IP, text):
         '''
         This function is used as a callback replacment to IPython pager function
 
         It puts the 'text' value inside the self._doc_text string that can be retrived via
         get_doc_text function.
         '''
         self._doc_text = text
     
     def _raw_input_original(self, prompt=''):
         '''
         Custom raw_input() replacement. Get's current line from console buffer.
 
         @param prompt: Prompt to print. Here for compatability as replacement.
         @type prompt: string
 
         @return: The current command line text.
         @rtype: string
         '''
         return self._line_to_execute
 
     def _raw_input(self, prompt=''):
         """ A replacement from python's raw_input.
         """
         raise NotImplementedError
     
     def _execute(self):
         '''
         Executes the current line provided by the shell object.
         '''
 
         orig_stdout = sys.stdout
         sys.stdout = IPython.Shell.Term.cout
         #self.sys_displayhook_ori = sys.displayhook
         #sys.displayhook = self.displayhook
         
         try:
             line = self._IP.raw_input(None, self._iter_more)
             if self._IP.autoindent:
                 self._IP.readline_startup_hook(None)
 
         except KeyboardInterrupt:
             self._IP.write('\nKeyboardInterrupt\n')
             self._IP.resetbuffer()
             # keep cache in sync with the prompt counter:
             self._IP.outputcache.prompt_count -= 1
 
             if self._IP.autoindent:
                 self._IP.indent_current_nsp = 0
             self._iter_more = 0
         except:
             self._IP.showtraceback()
         else:
             self._IP.write(str(self._IP.outputcache.prompt_out).strip())
             self._iter_more = self._IP.push(line)
             if (self._IP.SyntaxTB.last_syntax_error and \
                                                             self._IP.rc.autoedit_syntax):
                 self._IP.edit_syntax_error()
         if self._iter_more:
             self._prompt = str(self._IP.outputcache.prompt2).strip()
             if self._IP.autoindent:
                 self._IP.readline_startup_hook(self._IP.pre_readline)
         else:
             self._prompt = str(self._IP.outputcache.prompt1).strip()
             self._IP.indent_current_nsp = 0 #we set indentation to 0
 
         sys.stdout = orig_stdout
         #sys.displayhook = self.sys_displayhook_ori
                 
     def _shell(self, ip, cmd):
         '''
         Replacement method to allow shell commands without them blocking.
 
         @param ip: Ipython instance, same as self._IP
         @type cmd: Ipython instance
         @param cmd: Shell command to execute.
         @type cmd: string
         '''
         stdin, stdout = os.popen4(cmd)
         result = stdout.read().decode('cp437').\
                                             encode(locale.getpreferredencoding())
         #we use print command because the shell command is called
         #inside IPython instance and thus is redirected to thread cout
         #"\x01\x1b[1;36m\x02" <-- add colour to the text...
         print "\x01\x1b[1;36m\x02"+result
         stdout.close()
         stdin.close()

IPython/ipmaker.py

@@ -1,771 +1,771
 # -*- coding: utf-8 -*-
 """
 IPython -- An enhanced Interactive Python
 
 Requires Python 2.1 or better.
 
 This file contains the main make_IPython() starter function.
 """
 
 #*****************************************************************************
 #       Copyright (C) 2008-2009 The IPython Development Team
 #       Copyright (C) 2001-2007 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.
 #*****************************************************************************
 
 try:
     credits._Printer__data = """
     Python: %s
 
     IPython: The IPython Development Team.
     See http://ipython.scipy.org for more information.""" \
     % credits._Printer__data
 
     copyright._Printer__data += """
 
     Copyright (c) 2008-2009 The IPython Development Team.
     Copyright (c) 2001-2007 Fernando Perez, Janko Hauser, Nathan Gray.
     All Rights Reserved."""
 except NameError:
     # Can happen if ipython was started with 'python -S', so that site.py is
     # not loaded
     pass
 
 #****************************************************************************
 # Required modules
 
 # From the standard library
 import __main__
 import __builtin__
 import os
 import sys
 from pprint import pprint
 
 # Our own
 from IPython.utils import DPyGetOpt
 from IPython import Release
 from IPython.ipstruct import Struct
 from IPython.OutputTrap import OutputTrap
 from IPython.config.configloader import ConfigLoader
-from IPython.iplib import InteractiveShell
+from IPython.core.iplib import InteractiveShell
 from IPython.usage import cmd_line_usage,interactive_usage
 from IPython.utils.genutils import *
 
 def force_import(modname,force_reload=False):
     if modname in sys.modules and force_reload:
         info("reloading: %s" % modname)
         reload(sys.modules[modname])
     else:
         __import__(modname)
         
 
 #-----------------------------------------------------------------------------
 def make_IPython(argv=None,user_ns=None,user_global_ns=None,debug=1,
                  rc_override=None,shell_class=InteractiveShell,
                  embedded=False,**kw):
     """This is a dump of IPython into a single function.
 
     Later it will have to be broken up in a sensible manner.
 
     Arguments:
 
     - argv: a list similar to sys.argv[1:].  It should NOT contain the desired
     script name, b/c DPyGetOpt strips the first argument only for the real
     sys.argv.
 
     - user_ns: a dict to be used as the user's namespace."""
 
     #----------------------------------------------------------------------
     # Defaults and initialization
     
     # For developer debugging, deactivates crash handler and uses pdb.
     DEVDEBUG = False
 
     if argv is None:
         argv = sys.argv
 
     # __IP is the main global that lives throughout and represents the whole
     # application. If the user redefines it, all bets are off as to what
     # happens.
 
     # __IP is the name of he global which the caller will have accessible as
     # __IP.name. We set its name via the first parameter passed to
     # InteractiveShell:
 
     IP = shell_class('__IP',user_ns=user_ns,user_global_ns=user_global_ns,
                      embedded=embedded,**kw)
 
     # Put 'help' in the user namespace
     try:
         from site import _Helper
         IP.user_ns['help'] = _Helper()
     except ImportError:
         warn('help() not available - check site.py')
 
     if DEVDEBUG:
         # For developer debugging only (global flag)
         from IPython import ultraTB
         sys.excepthook = ultraTB.VerboseTB(call_pdb=1)
 
     IP.BANNER_PARTS = ['Python %s\n'
                          'Type "copyright", "credits" or "license" '
                          'for more information.\n'
                          % (sys.version.split('\n')[0],),
                          "IPython %s -- An enhanced Interactive Python."
                          % (Release.version,),
 """\
 ?         -> Introduction and overview of IPython's features.
 %quickref -> Quick reference.
 help      -> Python's own help system.
 object?   -> Details about 'object'. ?object also works, ?? prints more.
 """ ]
 
     IP.usage = interactive_usage
 
     # Platform-dependent suffix.
     if os.name == 'posix':
         rc_suffix = ''
     else:
         rc_suffix = '.ini'
 
     # default directory for configuration
     ipythondir_def = get_ipython_dir() 
     
     sys.path.insert(0, '') # add . to sys.path. Fix from Prabhu Ramachandran
 
     # we need the directory where IPython itself is installed
     import IPython
     IPython_dir = os.path.dirname(IPython.__file__)
     del IPython
     
     #-------------------------------------------------------------------------
     # Command line handling
 
     # Valid command line options (uses DPyGetOpt syntax, like Perl's
     # GetOpt::Long)
 
     # Any key not listed here gets deleted even if in the file (like session
     # or profile). That's deliberate, to maintain the rc namespace clean.
 
     # Each set of options appears twice: under _conv only the names are
     # listed, indicating which type they must be converted to when reading the
     # ipythonrc file. And under DPyGetOpt they are listed with the regular
     # DPyGetOpt syntax (=s,=i,:f,etc).
 
     # Make sure there's a space before each end of line (they get auto-joined!)
     cmdline_opts = ('autocall=i autoindent! automagic! banner! cache_size|cs=i '
                     'c=s classic|cl color_info! colors=s confirm_exit! '
                     'debug! deep_reload! editor=s log|l messages! nosep '
                     'object_info_string_level=i pdb! '
                     'pprint! prompt_in1|pi1=s prompt_in2|pi2=s prompt_out|po=s '
                     'pydb! '
                     'pylab_import_all! '
                     'quick screen_length|sl=i prompts_pad_left=i '
                     'logfile|lf=s logplay|lp=s profile|p=s '
                     'readline! readline_merge_completions! '
                     'readline_omit__names! '
                     'rcfile=s separate_in|si=s separate_out|so=s '
                     'separate_out2|so2=s xmode=s wildcards_case_sensitive! '
                     'magic_docstrings system_verbose! '
                     'multi_line_specials! '
                     'term_title! wxversion=s '
                     'autoedit_syntax!')
 
     # Options that can *only* appear at the cmd line (not in rcfiles).
     
     cmdline_only = ('help interact|i ipythondir=s Version upgrade '
                     'gthread! qthread! q4thread! wthread! tkthread! pylab! tk! '
                     # 'twisted!'  # disabled for now.
                     )
 
     # Build the actual name list to be used by DPyGetOpt
     opts_names = qw(cmdline_opts) + qw(cmdline_only)
 
     # Set sensible command line defaults.
     # This should have everything from  cmdline_opts and cmdline_only
     opts_def = Struct(autocall = 1,
                       autoedit_syntax = 0,
                       autoindent = 0,
                       automagic = 1,
                       autoexec = [],
                       banner = 1,
                       c = '',
                       cache_size = 1000,
                       classic = 0,
                       color_info = 0,
                       colors = 'NoColor',
                       confirm_exit = 1,
                       debug = 0,
                       deep_reload = 0,
                       editor = '0',
                       gthread = 0,
                       help = 0,
                       interact = 0,
                       ipythondir = ipythondir_def,
                       log = 0,
                       logfile = '',
                       logplay = '',
                       messages = 1,
                       multi_line_specials = 1,
                       nosep = 0,
                       object_info_string_level = 0,
                       pdb = 0,
                       pprint = 0,
                       profile = '',
                       prompt_in1 = 'In [\\#]: ',
                       prompt_in2 = '   .\\D.: ',
                       prompt_out = 'Out[\\#]: ',
                       prompts_pad_left = 1,
                       pydb = 0,
                       pylab = 0,
                       pylab_import_all = 1,
                       q4thread = 0,
                       qthread = 0,
                       quick = 0,
                       quiet = 0,
                       rcfile = 'ipythonrc' + rc_suffix,
                       readline = 1,
                       readline_merge_completions = 1,
                       readline_omit__names = 0,
                       screen_length = 0,
                       separate_in = '\n',
                       separate_out = '\n',
                       separate_out2 = '',
                       system_header = 'IPython system call: ',
                       system_verbose = 0,
                       term_title = 1,
                       tk = 0,
                       #twisted= 0,  # disabled for now
                       upgrade = 0,
                       Version = 0,
                       wildcards_case_sensitive = 1,
                       wthread = 0,
                       wxversion = '0',
                       xmode = 'Context',
                       magic_docstrings = 0,  # undocumented, for doc generation
                       )
     
     # Things that will *only* appear in rcfiles (not at the command line).
     # Make sure there's a space before each end of line (they get auto-joined!)
     rcfile_opts = { qwflat: 'include import_mod import_all execfile ',
                     qw_lol: 'import_some ',
                     # for things with embedded whitespace:
                     list_strings:'execute alias readline_parse_and_bind ',
                     # Regular strings need no conversion:
                     None:'readline_remove_delims ',
                     }
     # Default values for these
     rc_def = Struct(include = [],
                     import_mod = [], 
                     import_all = [],
                     import_some = [[]],
                     execute = [],
                     execfile = [],
                     alias = [],
                     readline_parse_and_bind = [],
                     readline_remove_delims = '',
                     )
 
     # Build the type conversion dictionary from the above tables:
     typeconv = rcfile_opts.copy()
     typeconv.update(optstr2types(cmdline_opts))
 
     # FIXME: the None key appears in both, put that back together by hand. Ugly!
     typeconv[None] += ' ' + rcfile_opts[None]
 
     # Remove quotes at ends of all strings (used to protect spaces)
     typeconv[unquote_ends] = typeconv[None]
     del typeconv[None]
 
     # Build the list we'll use to make all config decisions with defaults:
     opts_all = opts_def.copy()
     opts_all.update(rc_def)
 
     # Build conflict resolver for recursive loading of config files:
     # - preserve means the outermost file maintains the value, it is not
     # overwritten if an included file has the same key.
     # - add_flip applies + to the two values, so it better make sense to add
     # those types of keys. But it flips them first so that things loaded
     # deeper in the inclusion chain have lower precedence.
     conflict = {'preserve': ' '.join([ typeconv[int],
                                        typeconv[unquote_ends] ]),
                 'add_flip': ' '.join([ typeconv[qwflat],
                                        typeconv[qw_lol],
                                        typeconv[list_strings] ])
                 }
 
     # Now actually process the command line
     getopt = DPyGetOpt.DPyGetOpt()
     getopt.setIgnoreCase(0)
 
     getopt.parseConfiguration(opts_names)
 
     try:
         getopt.processArguments(argv)
     except DPyGetOpt.ArgumentError, exc:
         print cmd_line_usage
         warn('\nError in Arguments: "%s"' % exc)
         sys.exit(1)
 
     # convert the options dict to a struct for much lighter syntax later
     opts = Struct(getopt.optionValues)
     args = getopt.freeValues
 
     # this is the struct (which has default values at this point) with which
     # we make all decisions:
     opts_all.update(opts)
 
     # Options that force an immediate exit
     if opts_all.help:
         page(cmd_line_usage)
         sys.exit()
 
     if opts_all.Version:
         print Release.version
         sys.exit()
 
     if opts_all.magic_docstrings:
         IP.magic_magic('-latex')
         sys.exit()
 
     # add personal ipythondir to sys.path so that users can put things in
     # there for customization
     sys.path.append(os.path.abspath(opts_all.ipythondir))
 
     # Create user config directory if it doesn't exist. This must be done
     # *after* getting the cmd line options.
     if not os.path.isdir(opts_all.ipythondir):
         IP.user_setup(opts_all.ipythondir,rc_suffix,'install')
 
     # upgrade user config files while preserving a copy of the originals
     if opts_all.upgrade:
         IP.user_setup(opts_all.ipythondir,rc_suffix,'upgrade')
 
     # check mutually exclusive options in the *original* command line
     mutex_opts(opts,[qw('log logfile'),qw('rcfile profile'),
                      qw('classic profile'),qw('classic rcfile')])
 
     #---------------------------------------------------------------------------
     # Log replay
     
     # if -logplay, we need to 'become' the other session. That basically means
     # replacing the current command line environment with that of the old
     # session and moving on.
 
     # this is needed so that later we know we're in session reload mode, as
     # opts_all will get overwritten:
     load_logplay = 0
 
     if opts_all.logplay:
         load_logplay = opts_all.logplay 
         opts_debug_save = opts_all.debug
         try:
             logplay = open(opts_all.logplay)
         except IOError:
             if opts_all.debug: IP.InteractiveTB()
             warn('Could not open logplay file '+`opts_all.logplay`)
             # restore state as if nothing had happened and move on, but make
             # sure that later we don't try to actually load the session file
             logplay = None
             load_logplay = 0
             del opts_all.logplay
         else:
             try: 
                 logplay.readline()
                 logplay.readline();
                 # this reloads that session's command line
                 cmd = logplay.readline()[6:] 
                 exec cmd
                 # restore the true debug flag given so that the process of
                 # session loading itself can be monitored.
                 opts.debug = opts_debug_save
                 # save the logplay flag so later we don't overwrite the log
                 opts.logplay = load_logplay
                 # now we must update our own structure with defaults
                 opts_all.update(opts)
                 # now load args
                 cmd = logplay.readline()[6:] 
                 exec cmd
                 logplay.close()
             except:
                 logplay.close()
                 if opts_all.debug: IP.InteractiveTB()
                 warn("Logplay file lacking full configuration information.\n"
                      "I'll try to read it, but some things may not work.")
 
     #-------------------------------------------------------------------------
     # set up output traps: catch all output from files, being run, modules
     # loaded, etc. Then give it to the user in a clean form at the end.
     
     msg_out = 'Output messages. '
     msg_err = 'Error messages. '
     msg_sep = '\n'
     msg = Struct(config    = OutputTrap('Configuration Loader',msg_out,
                                         msg_err,msg_sep,debug,
                                         quiet_out=1),
                  user_exec = OutputTrap('User File Execution',msg_out,
                                         msg_err,msg_sep,debug),
                  logplay   = OutputTrap('Log Loader',msg_out,
                                         msg_err,msg_sep,debug),
                  summary = ''
                  )
 
     #-------------------------------------------------------------------------
     # Process user ipythonrc-type configuration files
 
     # turn on output trapping and log to msg.config
     # remember that with debug on, trapping is actually disabled
     msg.config.trap_all()
 
     # look for rcfile in current or default directory
     try:
         opts_all.rcfile = filefind(opts_all.rcfile,opts_all.ipythondir)
     except IOError:
         if opts_all.debug:  IP.InteractiveTB()
         warn('Configuration file %s not found. Ignoring request.'
              % (opts_all.rcfile) )
 
     # 'profiles' are a shorthand notation for config filenames
     profile_handled_by_legacy = False
     if opts_all.profile:
             
         try:
             opts_all.rcfile = filefind('ipythonrc-' + opts_all.profile
                                        + rc_suffix,
                                        opts_all.ipythondir)
             profile_handled_by_legacy = True
         except IOError:
            if opts_all.debug:  IP.InteractiveTB()
            opts.profile = ''  # remove profile from options if invalid
            # We won't warn anymore, primary method is ipy_profile_PROFNAME
            # which does trigger a warning.
 
     # load the config file
     rcfiledata = None
     if opts_all.quick:
         print 'Launching IPython in quick mode. No config file read.'
     elif opts_all.rcfile:
         try:
             cfg_loader = ConfigLoader(conflict)
             rcfiledata = cfg_loader.load(opts_all.rcfile,typeconv,
                                          'include',opts_all.ipythondir,
                                          purge = 1,
                                          unique = conflict['preserve'])
         except:
             IP.InteractiveTB()
             warn('Problems loading configuration file '+
                  `opts_all.rcfile`+
                  '\nStarting with default -bare bones- configuration.')
     else:
         warn('No valid configuration file found in either currrent directory\n'+
              'or in the IPython config. directory: '+`opts_all.ipythondir`+
              '\nProceeding with internal defaults.')
 
     #------------------------------------------------------------------------
     # Set exception handlers in mode requested by user.
     otrap = OutputTrap(trap_out=1)  # trap messages from magic_xmode
     IP.magic_xmode(opts_all.xmode)
     otrap.release_out()
 
     #------------------------------------------------------------------------
     # Execute user config
 
     # Create a valid config structure with the right precedence order:
     # defaults < rcfile < command line.  This needs to be in the instance, so
     # that method calls below that rely on it find it.
     IP.rc = rc_def.copy()
 
     # Work with a local alias inside this routine to avoid unnecessary
     # attribute lookups.
     IP_rc = IP.rc
     
     IP_rc.update(opts_def)
     if rcfiledata:
         # now we can update 
         IP_rc.update(rcfiledata)
     IP_rc.update(opts)
     IP_rc.update(rc_override)
 
     # Store the original cmd line for reference:
     IP_rc.opts = opts
     IP_rc.args = args
 
     # create a *runtime* Struct like rc for holding parameters which may be
     # created and/or modified by runtime user extensions.
     IP.runtime_rc = Struct()
 
     # from this point on, all config should be handled through IP_rc,
     # opts* shouldn't be used anymore.
 
     
     # update IP_rc with some special things that need manual
     # tweaks. Basically options which affect other options. I guess this
     # should just be written so that options are fully orthogonal and we
     # wouldn't worry about this stuff!
 
     if IP_rc.classic:
         IP_rc.quick = 1
         IP_rc.cache_size = 0
         IP_rc.pprint = 0
         IP_rc.prompt_in1 = '>>> '
         IP_rc.prompt_in2 = '... '
         IP_rc.prompt_out = ''
         IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
         IP_rc.colors = 'NoColor'
         IP_rc.xmode = 'Plain'
 
     IP.pre_config_initialization()
     # configure readline
 
     # update exception handlers with rc file status
     otrap.trap_out()  # I don't want these messages ever.
     IP.magic_xmode(IP_rc.xmode)
     otrap.release_out()
 
     # activate logging if requested and not reloading a log
     if IP_rc.logplay:
         IP.magic_logstart(IP_rc.logplay + ' append')
     elif  IP_rc.logfile:
         IP.magic_logstart(IP_rc.logfile)
     elif IP_rc.log:
         IP.magic_logstart()
 
     # find user editor so that it we don't have to look it up constantly
     if IP_rc.editor.strip()=='0':
         try:
             ed = os.environ['EDITOR']
         except KeyError:
             if os.name == 'posix':
                 ed = 'vi'  # the only one guaranteed to be there!
             else:
                 ed = 'notepad' # same in Windows!
         IP_rc.editor = ed
 
     # Keep track of whether this is an embedded instance or not (useful for
     # post-mortems).
     IP_rc.embedded = IP.embedded
 
     # Recursive reload
     try:
         from IPython.lib import deepreload
         if IP_rc.deep_reload:
             __builtin__.reload = deepreload.reload
         else:
             __builtin__.dreload = deepreload.reload
         del deepreload
     except ImportError:
         pass
 
     # Save the current state of our namespace so that the interactive shell
     # can later know which variables have been created by us from config files
     # and loading. This way, loading a file (in any way) is treated just like
     # defining things on the command line, and %who works as expected.
 
     # DON'T do anything that affects the namespace beyond this point!
     IP.internal_ns.update(__main__.__dict__)
 
     #IP.internal_ns.update(locals()) # so our stuff doesn't show up in %who
 
     # Now run through the different sections of the users's config
     if IP_rc.debug:    
         print 'Trying to execute the following configuration structure:'
         print '(Things listed first are deeper in the inclusion tree and get'
         print 'loaded first).\n'
         pprint(IP_rc.__dict__)
         
     for mod in IP_rc.import_mod:
         try:
             exec 'import '+mod in IP.user_ns
         except :
             IP.InteractiveTB()
             import_fail_info(mod)
 
     for mod_fn in IP_rc.import_some:
         if not mod_fn == []: 
             mod,fn = mod_fn[0],','.join(mod_fn[1:])
             try:
                 exec 'from '+mod+' import '+fn in IP.user_ns
             except :
                 IP.InteractiveTB()
                 import_fail_info(mod,fn)
 
     for mod in IP_rc.import_all:
         try:
             exec 'from '+mod+' import *' in IP.user_ns
         except :
             IP.InteractiveTB()
             import_fail_info(mod)
 
     for code in IP_rc.execute:
         try:
             exec code in IP.user_ns
         except:
             IP.InteractiveTB()
             warn('Failure executing code: ' + `code`)
 
     # Execute the files the user wants in ipythonrc
     for file in IP_rc.execfile:
         try:
             file = filefind(file,sys.path+[IPython_dir])
         except IOError:
             warn(itpl('File $file not found. Skipping it.'))
         else:
             IP.safe_execfile(os.path.expanduser(file),IP.user_ns)
 
     # finally, try importing ipy_*_conf for final configuration
     try:
         import ipy_system_conf
     except ImportError:
         if opts_all.debug:  IP.InteractiveTB()
         warn("Could not import 'ipy_system_conf'")        
     except:
         IP.InteractiveTB()
         import_fail_info('ipy_system_conf')
 
     # only import prof module if ipythonrc-PROF was not found
     if opts_all.profile and not profile_handled_by_legacy:
         profmodname = 'ipy_profile_' + opts_all.profile
         try:
             force_import(profmodname)
         except:
             IP.InteractiveTB()
             print "Error importing",profmodname,\
                   "- perhaps you should run %upgrade?"
             import_fail_info(profmodname)
         else:
             opts.profile = opts_all.profile
     else:
         force_import('ipy_profile_none')
     # XXX - this is wrong: ipy_user_conf should not be loaded unconditionally,
     # since the user could have specified a config file path by hand.
     try:
         force_import('ipy_user_conf')
     except:
         conf = opts_all.ipythondir + "/ipy_user_conf.py"
         IP.InteractiveTB()
         if not os.path.isfile(conf):
             warn(conf + ' does not exist, please run %upgrade!')
 
         import_fail_info("ipy_user_conf")
 
     # Define the history file for saving commands in between sessions
     try:
         histfname = 'history-%s' % opts.profile
     except AttributeError:
         histfname = 'history'
     IP.histfile = os.path.join(opts_all.ipythondir,histfname)
 
     # finally, push the argv to options again to ensure highest priority
     IP_rc.update(opts)
     
     # release stdout and stderr and save config log into a global summary
     msg.config.release_all()
     if IP_rc.messages:
         msg.summary += msg.config.summary_all()
 
     #------------------------------------------------------------------------
     # Setup interactive session
 
     # Now we should be fully configured. We can then execute files or load
     # things only needed for interactive use. Then we'll open the shell.
 
     # Take a snapshot of the user namespace before opening the shell. That way
     # we'll be able to identify which things were interactively defined and
     # which were defined through config files.
     IP.user_config_ns.update(IP.user_ns)
 
     # Force reading a file as if it were a session log. Slower but safer.
     if load_logplay:
         print 'Replaying log...'
         try:
             if IP_rc.debug:
                 logplay_quiet = 0
             else:
                  logplay_quiet = 1
 
             msg.logplay.trap_all()
             IP.safe_execfile(load_logplay,IP.user_ns,
                              islog = 1, quiet = logplay_quiet)
             msg.logplay.release_all()
             if IP_rc.messages:
                 msg.summary += msg.logplay.summary_all()
         except:
             warn('Problems replaying logfile %s.' % load_logplay)
             IP.InteractiveTB()
 
     # Load remaining files in command line
     msg.user_exec.trap_all()
 
     # Do NOT execute files named in the command line as scripts to be loaded
     # by embedded instances.  Doing so has the potential for an infinite
     # recursion if there are exceptions thrown in the process.
 
     # XXX FIXME: the execution of user files should be moved out to after
     # ipython is fully initialized, just as if they were run via %run at the
     # ipython prompt.  This would also give them the benefit of ipython's
     # nice tracebacks.
 
     if (not embedded and IP_rc.args and 
         not IP_rc.args[0].lower().endswith('.ipy')):
         name_save = IP.user_ns['__name__']
         IP.user_ns['__name__'] = '__main__'
         # Set our own excepthook in case the user code tries to call it
         # directly. This prevents triggering the IPython crash handler.
         old_excepthook,sys.excepthook = sys.excepthook, IP.excepthook
 
         save_argv = sys.argv[1:] # save it for later restoring
         
         sys.argv = args
         
         try:
             IP.safe_execfile(args[0], IP.user_ns)
         finally:
             # Reset our crash handler in place
             sys.excepthook = old_excepthook
             sys.argv[:] = save_argv
             IP.user_ns['__name__'] = name_save
         
     msg.user_exec.release_all()
 
     if IP_rc.messages:
         msg.summary += msg.user_exec.summary_all()
 
     # since we can't specify a null string on the cmd line, 0 is the equivalent:
     if IP_rc.nosep:
         IP_rc.separate_in = IP_rc.separate_out = IP_rc.separate_out2 = '0'
     if IP_rc.separate_in == '0': IP_rc.separate_in = ''
     if IP_rc.separate_out == '0': IP_rc.separate_out = ''
     if IP_rc.separate_out2 == '0': IP_rc.separate_out2 = ''
     IP_rc.separate_in = IP_rc.separate_in.replace('\\n','\n')
     IP_rc.separate_out = IP_rc.separate_out.replace('\\n','\n')
     IP_rc.separate_out2 = IP_rc.separate_out2.replace('\\n','\n')
 
     # Determine how many lines at the bottom of the screen are needed for
     # showing prompts, so we can know wheter long strings are to be printed or
     # paged:
     num_lines_bot = IP_rc.separate_in.count('\n')+1
     IP_rc.screen_length = IP_rc.screen_length - num_lines_bot
 
     # configure startup banner
     if IP_rc.c:  # regular python doesn't print the banner with -c
         IP_rc.banner = 0
     if IP_rc.banner:
         BANN_P = IP.BANNER_PARTS
     else:
         BANN_P = []
 
     if IP_rc.profile: BANN_P.append('IPython profile: %s\n' % IP_rc.profile)
 
     # add message log (possibly empty)
     if msg.summary: BANN_P.append(msg.summary)
     # Final banner is a string
     IP.BANNER = '\n'.join(BANN_P)
 
     # Finalize the IPython instance.  This assumes the rc structure is fully
     # in place.
     IP.post_config_initialization()
 
     return IP
 #************************ end of file <ipmaker.py> **************************

IPython/kernel/magic.py

@@ -1,171 +1,171
 # encoding: utf-8
 
 """Magic command interface for interactive parallel work."""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import new
 
-from IPython.iplib import InteractiveShell
+from IPython.core.iplib import InteractiveShell
 from IPython.Shell import MTInteractiveShell
 
 from twisted.internet.defer import Deferred
 
 
 #-------------------------------------------------------------------------------
 # Definitions of magic functions for use with IPython
 #-------------------------------------------------------------------------------
 
 NO_ACTIVE_CONTROLLER = """
 Error:  No Controller is activated
 Use activate() on a RemoteController object to activate it for magics.
 """
 
 def magic_result(self,parameter_s=''):
     """Print the result of command i on all engines of the active controller.
     
     To activate a controller in IPython, first create it and then call
     the activate() method.
     
     Then you can do the following:
     
     >>> result                                # Print the latest result
     Printing result... 
     [127.0.0.1:0] In [1]: b = 10
     [127.0.0.1:1] In [1]: b = 10
     
     >>> result 0                              # Print result 0
     In [14]: result 0
     Printing result... 
     [127.0.0.1:0] In [0]: a = 5
     [127.0.0.1:1] In [0]: a = 5
     """
     try:
         activeController = __IPYTHON__.activeController
     except AttributeError:
         print NO_ACTIVE_CONTROLLER
     else:
         try:
             index = int(parameter_s)
         except:
             index = None
         result = activeController.get_result(index)
         return result
 
 def magic_px(self,parameter_s=''):
     """Executes the given python command on the active IPython Controller.
     
     To activate a Controller in IPython, first create it and then call
     the activate() method.
     
     Then you can do the following:
      
     >>> %px a = 5       # Runs a = 5 on all nodes
     """
 
     try:
         activeController = __IPYTHON__.activeController
     except AttributeError:
         print NO_ACTIVE_CONTROLLER
     else:
         print "Parallel execution on engines: %s" % activeController.targets
         result = activeController.execute(parameter_s)
         return result
 
 def pxrunsource(self, source, filename="<input>", symbol="single"):
 
     try:
         code = self.compile(source, filename, symbol)
     except (OverflowError, SyntaxError, ValueError):
         # Case 1
         self.showsyntaxerror(filename)
         return None
 
     if code is None:
         # Case 2
         return True
 
     # Case 3
     # Because autopx is enabled, we now call executeAll or disable autopx if
     # %autopx or autopx has been called
     if '_ip.magic("%autopx' in source or '_ip.magic("autopx' in source:
         _disable_autopx(self)
         return False
     else:
         try:
             result = self.activeController.execute(source)
         except:
             self.showtraceback()
         else:
             print result.__repr__()
         return False
         
 def magic_autopx(self, parameter_s=''):
     """Toggles auto parallel mode for the active IPython Controller.
     
     To activate a Controller in IPython, first create it and then call
     the activate() method.
     
     Then you can do the following:
      
     >>> %autopx                    # Now all commands are executed in parallel
     Auto Parallel Enabled
     Type %autopx to disable
     ...
     >>> %autopx                    # Now all commands are locally executed
     Auto Parallel Disabled
     """
   
     if hasattr(self, 'autopx'):
         if self.autopx == True:
             _disable_autopx(self)
         else:
             _enable_autopx(self)
     else:
         _enable_autopx(self)
 
 def _enable_autopx(self):
     """Enable %autopx mode by saving the original runsource and installing 
     pxrunsource.
     """
     try:
         activeController = __IPYTHON__.activeController
     except AttributeError:
         print "No active RemoteController found, use RemoteController.activate()."
     else:
         self._original_runsource = self.runsource
         self.runsource = new.instancemethod(pxrunsource, self, self.__class__)
         self.autopx = True
         print "Auto Parallel Enabled\nType %autopx to disable"
 
 def _disable_autopx(self):
     """Disable %autopx by restoring the original runsource."""
     if hasattr(self, 'autopx'):
         if self.autopx == True:
             self.runsource = self._original_runsource
             self.autopx = False
             print "Auto Parallel Disabled"
             
 # Add the new magic function to the class dict:
 
 InteractiveShell.magic_result = magic_result
 InteractiveShell.magic_px = magic_px
 InteractiveShell.magic_autopx = magic_autopx
 
 # And remove the global name to keep global namespace clean.  Don't worry, the
 # copy bound to IPython stays, we're just removing the global name.
 del magic_result
 del magic_px
 del magic_autopx
 

IPython/kernel/scripts/ipcluster.py

@@ -1,813 +1,813
  #!/usr/bin/env python
 # encoding: utf-8
 
 """Start an IPython cluster = (controller + engines)."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import re
 import sys
 import signal
 import tempfile
 pjoin = os.path.join
 
 from twisted.internet import reactor, defer
 from twisted.internet.protocol import ProcessProtocol
 from twisted.internet.error import ProcessDone, ProcessTerminated
 from twisted.internet.utils import getProcessOutput
 from twisted.python import failure, log
 
 from IPython.external import argparse
 from IPython.external import Itpl
 from IPython.utils.genutils import (
     get_ipython_dir, 
     get_log_dir, 
     get_security_dir, 
     num_cpus
 )
 from IPython.kernel.fcutil import have_crypto
 
 # Create various ipython directories if they don't exist.
 # This must be done before IPython.kernel.config is imported.
-from IPython.iplib import user_setup
+from IPython.core.iplib import user_setup
 if os.name == 'posix':
     rc_suffix = ''
 else:
     rc_suffix = '.ini'
 user_setup(get_ipython_dir(), rc_suffix, mode='install', interactive=False)
 get_log_dir()
 get_security_dir()
 
 from IPython.kernel.config import config_manager as kernel_config_manager
 from IPython.kernel.error import SecurityError, FileTimeoutError
 from IPython.kernel.fcutil import have_crypto
 from IPython.kernel.twistedutil import gatherBoth, wait_for_file
 from IPython.kernel.util import printer
 
 #-----------------------------------------------------------------------------
 # General process handling code
 #-----------------------------------------------------------------------------
 
 
 class ProcessStateError(Exception):
     pass
 
 class UnknownStatus(Exception):
     pass
 
 class LauncherProcessProtocol(ProcessProtocol):
     """
     A ProcessProtocol to go with the ProcessLauncher.
     """
     def __init__(self, process_launcher):
         self.process_launcher = process_launcher
     
     def connectionMade(self):
         self.process_launcher.fire_start_deferred(self.transport.pid)
     
     def processEnded(self, status):
         value = status.value
         if isinstance(value, ProcessDone):
             self.process_launcher.fire_stop_deferred(0)
         elif isinstance(value, ProcessTerminated):
             self.process_launcher.fire_stop_deferred(
                 {'exit_code':value.exitCode,
                  'signal':value.signal,
                  'status':value.status
                 }
             )
         else:
             raise UnknownStatus("unknown exit status, this is probably a bug in Twisted")
     
     def outReceived(self, data):
         log.msg(data)
     
     def errReceived(self, data):
         log.err(data)
 
 class ProcessLauncher(object):
     """
     Start and stop an external process in an asynchronous manner.
     
     Currently this uses deferreds to notify other parties of process state
     changes.  This is an awkward design and should be moved to using
     a formal NotificationCenter.
     """
     def __init__(self, cmd_and_args):
         self.cmd = cmd_and_args[0]
         self.args = cmd_and_args
         self._reset()
     
     def _reset(self):
         self.process_protocol = None
         self.pid = None
         self.start_deferred = None
         self.stop_deferreds = []
         self.state = 'before' # before, running, or after
     
     @property
     def running(self):
         if self.state == 'running':
             return True
         else:
             return False
     
     def fire_start_deferred(self, pid):
         self.pid = pid
         self.state = 'running'
         log.msg('Process %r has started with pid=%i' % (self.args, pid))
         self.start_deferred.callback(pid)
     
     def start(self):
         if self.state == 'before':
             self.process_protocol = LauncherProcessProtocol(self)
             self.start_deferred = defer.Deferred()
             self.process_transport = reactor.spawnProcess(
                 self.process_protocol,
                 self.cmd,
                 self.args,
                 env=os.environ
             )
             return self.start_deferred
         else:
             s = 'the process has already been started and has state: %r' % \
                 self.state
             return defer.fail(ProcessStateError(s))
     
     def get_stop_deferred(self):
         if self.state == 'running' or self.state == 'before':
             d = defer.Deferred()
             self.stop_deferreds.append(d)
             return d
         else:
             s = 'this process is already complete'
             return defer.fail(ProcessStateError(s))
     
     def fire_stop_deferred(self, exit_code):
         log.msg('Process %r has stopped with %r' % (self.args, exit_code))
         self.state = 'after'
         for d in self.stop_deferreds:
             d.callback(exit_code)
     
     def signal(self, sig):
         """
         Send a signal to the process.
         
         The argument sig can be ('KILL','INT', etc.) or any signal number.
         """
         if self.state == 'running':
             self.process_transport.signalProcess(sig)
     
     # def __del__(self):
     #     self.signal('KILL')
     
     def interrupt_then_kill(self, delay=1.0):
         self.signal('INT')
         reactor.callLater(delay, self.signal, 'KILL')
 
 
 #-----------------------------------------------------------------------------
 # Code for launching controller and engines
 #-----------------------------------------------------------------------------
 
 
 class ControllerLauncher(ProcessLauncher):
     
     def __init__(self, extra_args=None):
         if sys.platform == 'win32':
             # This logic is needed because the ipcontroller script doesn't
             # always get installed in the same way or in the same location.
             from IPython.kernel.scripts import ipcontroller
             script_location = ipcontroller.__file__.replace('.pyc', '.py')
             # The -u option here turns on unbuffered output, which is required
             # on Win32 to prevent wierd conflict and problems with Twisted.
             # Also, use sys.executable to make sure we are picking up the 
             # right python exe.
             args = [sys.executable, '-u', script_location]
         else:
             args = ['ipcontroller']
         self.extra_args = extra_args
         if extra_args is not None:
             args.extend(extra_args)
         
         ProcessLauncher.__init__(self, args)
 
 
 class EngineLauncher(ProcessLauncher):
     
     def __init__(self, extra_args=None):
         if sys.platform == 'win32':
             # This logic is needed because the ipcontroller script doesn't
             # always get installed in the same way or in the same location.
             from IPython.kernel.scripts import ipengine
             script_location = ipengine.__file__.replace('.pyc', '.py')
             # The -u option here turns on unbuffered output, which is required
             # on Win32 to prevent wierd conflict and problems with Twisted.
             # Also, use sys.executable to make sure we are picking up the 
             # right python exe.
             args = [sys.executable, '-u', script_location]
         else:
             args = ['ipengine']
         self.extra_args = extra_args
         if extra_args is not None:
             args.extend(extra_args)
         
         ProcessLauncher.__init__(self, args)
 
 
 class LocalEngineSet(object):
     
     def __init__(self, extra_args=None):
         self.extra_args = extra_args
         self.launchers = []
     
     def start(self, n):
         dlist = []
         for i in range(n):
             el = EngineLauncher(extra_args=self.extra_args)
             d = el.start()
             self.launchers.append(el)
             dlist.append(d)
         dfinal = gatherBoth(dlist, consumeErrors=True)
         dfinal.addCallback(self._handle_start)
         return dfinal
     
     def _handle_start(self, r):
         log.msg('Engines started with pids: %r' % r)
         return r
     
     def _handle_stop(self, r):
         log.msg('Engines received signal: %r' % r)
         return r
     
     def signal(self, sig):
         dlist = []
         for el in self.launchers:
             d = el.get_stop_deferred()
             dlist.append(d)
             el.signal(sig)
         dfinal = gatherBoth(dlist, consumeErrors=True)
         dfinal.addCallback(self._handle_stop)
         return dfinal
     
     def interrupt_then_kill(self, delay=1.0):
         dlist = []
         for el in self.launchers:
             d = el.get_stop_deferred()
             dlist.append(d)
             el.interrupt_then_kill(delay)
         dfinal = gatherBoth(dlist, consumeErrors=True)
         dfinal.addCallback(self._handle_stop)
         return dfinal
 
 
 class BatchEngineSet(object):
     
     # Subclasses must fill these in.  See PBSEngineSet
     submit_command = ''
     delete_command = ''
     job_id_regexp = ''
     
     def __init__(self, template_file, **kwargs):
         self.template_file = template_file
         self.context = {}
         self.context.update(kwargs)
         self.batch_file = self.template_file+'-run'
     
     def parse_job_id(self, output):
         m = re.match(self.job_id_regexp, output)
         if m is not None:
             job_id = m.group()
         else:
             raise Exception("job id couldn't be determined: %s" % output)
         self.job_id = job_id
         log.msg('Job started with job id: %r' % job_id)
         return job_id
     
     def write_batch_script(self, n):
         self.context['n'] = n
         template = open(self.template_file, 'r').read()
         log.msg('Using template for batch script: %s' % self.template_file)
         script_as_string = Itpl.itplns(template, self.context)
         log.msg('Writing instantiated batch script: %s' % self.batch_file)
         f = open(self.batch_file,'w')
         f.write(script_as_string)
         f.close()
     
     def handle_error(self, f):
         f.printTraceback()
         f.raiseException()
     
     def start(self, n):
         self.write_batch_script(n)
         d = getProcessOutput(self.submit_command,
             [self.batch_file],env=os.environ)
         d.addCallback(self.parse_job_id)
         d.addErrback(self.handle_error)
         return d
     
     def kill(self):
         d = getProcessOutput(self.delete_command,
             [self.job_id],env=os.environ)
         return d
 
 class PBSEngineSet(BatchEngineSet):
     
     submit_command = 'qsub'
     delete_command = 'qdel'
     job_id_regexp = '\d+'
     
     def __init__(self, template_file, **kwargs):
         BatchEngineSet.__init__(self, template_file, **kwargs)
 
 
 sshx_template="""#!/bin/sh
 "$@" &> /dev/null &
 echo $!
 """
 
 engine_killer_template="""#!/bin/sh
 ps -fu `whoami` | grep '[i]pengine' | awk '{print $2}' | xargs kill -TERM
 """
 
 class SSHEngineSet(object):
     sshx_template=sshx_template
     engine_killer_template=engine_killer_template
     
     def __init__(self, engine_hosts, sshx=None, ipengine="ipengine"):
         """Start a controller on localhost and engines using ssh.
         
         The engine_hosts argument is a dict with hostnames as keys and
         the number of engine (int) as values.  sshx is the name of a local
         file that will be used to run remote commands.  This file is used
         to setup the environment properly.
         """
         
         self.temp_dir = tempfile.gettempdir()
         if sshx is not None:
             self.sshx = sshx
         else:
             # Write the sshx.sh file locally from our template.
             self.sshx = os.path.join(
                 self.temp_dir,
                 '%s-main-sshx.sh' % os.environ['USER']
             )
             f = open(self.sshx, 'w')
             f.writelines(self.sshx_template)
             f.close()
         self.engine_command = ipengine
         self.engine_hosts = engine_hosts
         # Write the engine killer script file locally from our template.
         self.engine_killer = os.path.join(
             self.temp_dir,  
             '%s-local-engine_killer.sh' % os.environ['USER']
         )
         f = open(self.engine_killer, 'w')
         f.writelines(self.engine_killer_template)
         f.close()
     
     def start(self, send_furl=False):
         dlist = []
         for host in self.engine_hosts.keys():
             count = self.engine_hosts[host]
             d = self._start(host, count, send_furl)
             dlist.append(d)
         return gatherBoth(dlist, consumeErrors=True)
     
     def _start(self, hostname, count=1, send_furl=False):
         if send_furl:
             d = self._scp_furl(hostname)
         else:
             d = defer.succeed(None)
         d.addCallback(lambda r: self._scp_sshx(hostname))
         d.addCallback(lambda r: self._ssh_engine(hostname, count))
         return d
         
     def _scp_furl(self, hostname):
         scp_cmd = "scp ~/.ipython/security/ipcontroller-engine.furl %s:.ipython/security/" % (hostname)
         cmd_list = scp_cmd.split()
         cmd_list[1] = os.path.expanduser(cmd_list[1])
         log.msg('Copying furl file: %s' % scp_cmd)
         d = getProcessOutput(cmd_list[0], cmd_list[1:], env=os.environ) 
         return d
     
     def _scp_sshx(self, hostname):
         scp_cmd = "scp %s %s:%s/%s-sshx.sh" % (
             self.sshx, hostname, 
             self.temp_dir, os.environ['USER']
         )
         print
         log.msg("Copying sshx: %s" % scp_cmd)
         sshx_scp = scp_cmd.split()
         d = getProcessOutput(sshx_scp[0], sshx_scp[1:], env=os.environ)
         return d
     
     def _ssh_engine(self, hostname, count):
         exec_engine = "ssh %s sh %s/%s-sshx.sh %s" % (
             hostname, self.temp_dir, 
             os.environ['USER'], self.engine_command
         )
         cmds = exec_engine.split()
         dlist = []
         log.msg("about to start engines...")
         for i in range(count):
             log.msg('Starting engines: %s' % exec_engine)
             d = getProcessOutput(cmds[0], cmds[1:], env=os.environ)
             dlist.append(d)
         return gatherBoth(dlist, consumeErrors=True)
     
     def kill(self):
         dlist = []
         for host in self.engine_hosts.keys():
             d = self._killall(host)
             dlist.append(d)
         return gatherBoth(dlist, consumeErrors=True)
     
     def _killall(self, hostname):
         d = self._scp_engine_killer(hostname)
         d.addCallback(lambda r: self._ssh_kill(hostname))
         # d.addErrback(self._exec_err)
         return d
 
     def _scp_engine_killer(self, hostname):
         scp_cmd = "scp %s %s:%s/%s-engine_killer.sh" % (
             self.engine_killer, 
             hostname, 
             self.temp_dir, 
             os.environ['USER']
         )
         cmds = scp_cmd.split()
         log.msg('Copying engine_killer: %s' % scp_cmd)
         d = getProcessOutput(cmds[0], cmds[1:], env=os.environ)
         return d
     
     def _ssh_kill(self, hostname):
         kill_cmd = "ssh %s sh %s/%s-engine_killer.sh" % (
             hostname,
             self.temp_dir, 
             os.environ['USER']
         )
         log.msg('Killing engine: %s' % kill_cmd)
         kill_cmd = kill_cmd.split()
         d = getProcessOutput(kill_cmd[0], kill_cmd[1:], env=os.environ)
         return d
 
     def _exec_err(self, r):
         log.msg(r)
 
 #-----------------------------------------------------------------------------
 # Main functions for the different types of clusters
 #-----------------------------------------------------------------------------
 
 # TODO:
 # The logic in these codes should be moved into classes like LocalCluster
 # MpirunCluster, PBSCluster, etc.  This would remove alot of the duplications.
 # The main functions should then just parse the command line arguments, create
 # the appropriate class and call a 'start' method.
 
 
 def check_security(args, cont_args):
     """Check to see if we should run with SSL support."""
     if (not args.x or not args.y) and not have_crypto:
         log.err("""
 OpenSSL/pyOpenSSL is not available, so we can't run in secure mode.
 Try running ipcluster with the -xy flags:  ipcluster local -xy -n 4""")
         reactor.stop()
         return False
     if args.x:
         cont_args.append('-x')
     if args.y:
         cont_args.append('-y')
     return True
 
 
 def check_reuse(args, cont_args):
     """Check to see if we should try to resuse FURL files."""
     if args.r:
         cont_args.append('-r')
         if args.client_port == 0 or args.engine_port == 0:
             log.err("""
 To reuse FURL files, you must also set the client and engine ports using
 the --client-port and --engine-port options.""")
             reactor.stop()
             return False
         cont_args.append('--client-port=%i' % args.client_port)
         cont_args.append('--engine-port=%i' % args.engine_port)
     return True
 
 
 def _err_and_stop(f):
     """Errback to log a failure and halt the reactor on a fatal error."""
     log.err(f)
     reactor.stop()
 
 
 def _delay_start(cont_pid, start_engines, furl_file, reuse):
     """Wait for controller to create FURL files and the start the engines."""
     if not reuse:
         if os.path.isfile(furl_file):
             os.unlink(furl_file)
     log.msg('Waiting for controller to finish starting...')
     d = wait_for_file(furl_file, delay=0.2, max_tries=50)
     d.addCallback(lambda _: log.msg('Controller started'))
     d.addCallback(lambda _: start_engines(cont_pid))
     return d
 
 
 def main_local(args):
     cont_args = []
     cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
     
     # Check security settings before proceeding
     if not check_security(args, cont_args):
         return
     
     # See if we are reusing FURL files
     if not check_reuse(args, cont_args):
         return
     
     cl = ControllerLauncher(extra_args=cont_args)
     dstart = cl.start()
     def start_engines(cont_pid):
         engine_args = []
         engine_args.append('--logfile=%s' % \
             pjoin(args.logdir,'ipengine%s-' % cont_pid))
         eset = LocalEngineSet(extra_args=engine_args)
         def shutdown(signum, frame):
             log.msg('Stopping local cluster')
             # We are still playing with the times here, but these seem
             # to be reliable in allowing everything to exit cleanly.
             eset.interrupt_then_kill(0.5)
             cl.interrupt_then_kill(0.5)
             reactor.callLater(1.0, reactor.stop)
         signal.signal(signal.SIGINT,shutdown)
         d = eset.start(args.n)
         return d
     config = kernel_config_manager.get_config_obj()
     furl_file = config['controller']['engine_furl_file']
     dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
     dstart.addErrback(_err_and_stop)
 
 
 def main_mpi(args):
     cont_args = []
     cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
     
     # Check security settings before proceeding
     if not check_security(args, cont_args):
         return
     
     # See if we are reusing FURL files
     if not check_reuse(args, cont_args):
         return
     
     cl = ControllerLauncher(extra_args=cont_args)
     dstart = cl.start()
     def start_engines(cont_pid):
         raw_args = [args.cmd]
         raw_args.extend(['-n',str(args.n)])
         raw_args.append('ipengine')
         raw_args.append('-l')
         raw_args.append(pjoin(args.logdir,'ipengine%s-' % cont_pid))
         if args.mpi:
             raw_args.append('--mpi=%s' % args.mpi)
         eset = ProcessLauncher(raw_args)
         def shutdown(signum, frame):
             log.msg('Stopping local cluster')
             # We are still playing with the times here, but these seem
             # to be reliable in allowing everything to exit cleanly.
             eset.interrupt_then_kill(1.0)
             cl.interrupt_then_kill(1.0)
             reactor.callLater(2.0, reactor.stop)
         signal.signal(signal.SIGINT,shutdown)
         d = eset.start()
         return d
     config = kernel_config_manager.get_config_obj()
     furl_file = config['controller']['engine_furl_file']
     dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
     dstart.addErrback(_err_and_stop)
 
 
 def main_pbs(args):
     cont_args = []
     cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
     
     # Check security settings before proceeding
     if not check_security(args, cont_args):
         return
     
     # See if we are reusing FURL files
     if not check_reuse(args, cont_args):
         return
     
     cl = ControllerLauncher(extra_args=cont_args)
     dstart = cl.start()
     def start_engines(r):
         pbs_set =  PBSEngineSet(args.pbsscript)
         def shutdown(signum, frame):
             log.msg('Stopping pbs cluster')
             d = pbs_set.kill()
             d.addBoth(lambda _: cl.interrupt_then_kill(1.0))
             d.addBoth(lambda _: reactor.callLater(2.0, reactor.stop))
         signal.signal(signal.SIGINT,shutdown)
         d = pbs_set.start(args.n)
         return d
     config = kernel_config_manager.get_config_obj()
     furl_file = config['controller']['engine_furl_file']
     dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
     dstart.addErrback(_err_and_stop)
 
 
 def main_ssh(args):
     """Start a controller on localhost and engines using ssh.
     
     Your clusterfile should look like::
     
         send_furl = False # True, if you want 
         engines = {
             'engine_host1' : engine_count, 
             'engine_host2' : engine_count2
         } 
     """
     clusterfile = {}
     execfile(args.clusterfile, clusterfile)
     if not clusterfile.has_key('send_furl'):
         clusterfile['send_furl'] = False
         
     cont_args = []
     cont_args.append('--logfile=%s' % pjoin(args.logdir,'ipcontroller'))
     
     # Check security settings before proceeding
     if not check_security(args, cont_args):
         return
     
     # See if we are reusing FURL files
     if not check_reuse(args, cont_args):
         return
     
     cl = ControllerLauncher(extra_args=cont_args)
     dstart = cl.start()
     def start_engines(cont_pid):
         ssh_set = SSHEngineSet(clusterfile['engines'], sshx=args.sshx)
         def shutdown(signum, frame):
             d = ssh_set.kill()
             cl.interrupt_then_kill(1.0)
             reactor.callLater(2.0, reactor.stop)
         signal.signal(signal.SIGINT,shutdown)
         d = ssh_set.start(clusterfile['send_furl'])
         return d
     config = kernel_config_manager.get_config_obj()
     furl_file = config['controller']['engine_furl_file']
     dstart.addCallback(_delay_start, start_engines, furl_file, args.r)
     dstart.addErrback(_err_and_stop)
 
 
 def get_args():
     base_parser = argparse.ArgumentParser(add_help=False)
     base_parser.add_argument(
         '-r',
         action='store_true',
         dest='r',
         help='try to reuse FURL files.  Use with --client-port and --engine-port'
     )
     base_parser.add_argument(
         '--client-port',
         type=int,
         dest='client_port',
         help='the port the controller will listen on for client connections',
         default=0
     )
     base_parser.add_argument(
         '--engine-port',
         type=int,
         dest='engine_port',
         help='the port the controller will listen on for engine connections',
         default=0
     )
     base_parser.add_argument(
         '-x',
         action='store_true',
         dest='x',
         help='turn off client security'
     )
     base_parser.add_argument(
         '-y',
         action='store_true',
         dest='y',
         help='turn off engine security'
     )
     base_parser.add_argument(
         "--logdir", 
         type=str,
         dest="logdir",
         help="directory to put log files (default=$IPYTHONDIR/log)",
         default=pjoin(get_ipython_dir(),'log')
     )
     base_parser.add_argument(
         "-n",
         "--num", 
         type=int,
         dest="n",
         default=2,
         help="the number of engines to start"
     )
     
     parser = argparse.ArgumentParser(
         description='IPython cluster startup.  This starts a controller and\
         engines using various approaches.  Use the IPYTHONDIR environment\
         variable to change your IPython directory from the default of\
         .ipython or _ipython.  The log and security subdirectories of your\
         IPython directory will be used by this script for log files and\
         security files.'
     )
     subparsers = parser.add_subparsers(
         help='available cluster types.  For help, do "ipcluster TYPE --help"')
     
     parser_local = subparsers.add_parser(
         'local',
         help='run a local cluster',
         parents=[base_parser]
     )
     parser_local.set_defaults(func=main_local)
     
     parser_mpirun = subparsers.add_parser(
         'mpirun',
         help='run a cluster using mpirun (mpiexec also works)',
         parents=[base_parser]
     )
     parser_mpirun.add_argument(
         "--mpi",
         type=str,
         dest="mpi", # Don't put a default here to allow no MPI support
         help="how to call MPI_Init (default=mpi4py)"
     )
     parser_mpirun.set_defaults(func=main_mpi, cmd='mpirun')
 
     parser_mpiexec = subparsers.add_parser(
         'mpiexec',
         help='run a cluster using mpiexec (mpirun also works)',
         parents=[base_parser]
     )
     parser_mpiexec.add_argument(
         "--mpi",
         type=str,
         dest="mpi", # Don't put a default here to allow no MPI support
         help="how to call MPI_Init (default=mpi4py)"
     )
     parser_mpiexec.set_defaults(func=main_mpi, cmd='mpiexec')
     
     parser_pbs = subparsers.add_parser(
         'pbs', 
         help='run a pbs cluster',
         parents=[base_parser]
     )
     parser_pbs.add_argument(
         '--pbs-script',
         type=str, 
         dest='pbsscript',
         help='PBS script template',
         default='pbs.template'
     )
     parser_pbs.set_defaults(func=main_pbs)
     
     parser_ssh = subparsers.add_parser(
         'ssh',
         help='run a cluster using ssh, should have ssh-keys setup',
         parents=[base_parser]
     )
     parser_ssh.add_argument(
         '--clusterfile', 
         type=str,
         dest='clusterfile',
         help='python file describing the cluster',
         default='clusterfile.py',
     )
     parser_ssh.add_argument(
         '--sshx', 
         type=str,
         dest='sshx',
         help='sshx launcher helper'
     )
     parser_ssh.set_defaults(func=main_ssh)
     
     args = parser.parse_args()
     return args
 
 def main():
     args = get_args()
     reactor.callWhenRunning(args.func, args)
     log.startLogging(sys.stdout)
     reactor.run()
 
 if __name__ == '__main__':
     main()

IPython/kernel/scripts/ipcontroller.py

@@ -1,416 +1,416
 #!/usr/bin/env python
 # encoding: utf-8
 
 """The IPython controller."""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 # Python looks for an empty string at the beginning of sys.path to enable
 # importing from the cwd.
 import sys
 sys.path.insert(0, '')
 
 from optparse import OptionParser
 import os
 import time
 import tempfile
 
 from twisted.application import internet, service
 from twisted.internet import reactor, error, defer
 from twisted.python import log
 
 from IPython.kernel.fcutil import Tub, UnauthenticatedTub, have_crypto
 
 # from IPython.tools import growl
 # growl.start("IPython1 Controller")
 
 from IPython.kernel.error import SecurityError
 from IPython.kernel import controllerservice
 from IPython.kernel.fcutil import check_furl_file_security
 
 # Create various ipython directories if they don't exist.
 # This must be done before IPython.kernel.config is imported.
-from IPython.iplib import user_setup
+from IPython.core.iplib import user_setup
 from IPython.utils.genutils import get_ipython_dir, get_log_dir, get_security_dir
 if os.name == 'posix':
     rc_suffix = ''
 else:
     rc_suffix = '.ini'
 user_setup(get_ipython_dir(), rc_suffix, mode='install', interactive=False)
 get_log_dir()
 get_security_dir()
 
 from IPython.kernel.config import config_manager as kernel_config_manager
 from IPython.config.cutils import import_item
 
 
 #-------------------------------------------------------------------------------
 # Code
 #-------------------------------------------------------------------------------
 
 def get_temp_furlfile(filename):
     return tempfile.mktemp(dir=os.path.dirname(filename),
                            prefix=os.path.basename(filename))
 
 def make_tub(ip, port, secure, cert_file):
     """
     Create a listening tub given an ip, port, and cert_file location.
     
     :Parameters:
         ip : str
             The ip address that the tub should listen on.  Empty means all
         port : int
             The port that the tub should listen on.  A value of 0 means
             pick a random port
         secure: boolean
             Will the connection be secure (in the foolscap sense)
         cert_file:
             A filename of a file to be used for theSSL certificate
     """
     if secure:
         if have_crypto:
             tub = Tub(certFile=cert_file)
         else:
             raise SecurityError("""
 OpenSSL/pyOpenSSL is not available, so we can't run in secure mode.
 Try running without security using 'ipcontroller -xy'.
 """)
     else:
         tub = UnauthenticatedTub()
     
     # Set the strport based on the ip and port and start listening
     if ip == '':
         strport = "tcp:%i" % port
     else:
         strport = "tcp:%i:interface=%s" % (port, ip)
     listener = tub.listenOn(strport)
     
     return tub, listener
 
 def make_client_service(controller_service, config):
     """
     Create a service that will listen for clients.
     
     This service is simply a `foolscap.Tub` instance that has a set of Referenceables
     registered with it.
     """
 
     # Now create the foolscap tub
     ip = config['controller']['client_tub']['ip']
     port = config['controller']['client_tub'].as_int('port')
     location = config['controller']['client_tub']['location']
     secure = config['controller']['client_tub']['secure']
     cert_file = config['controller']['client_tub']['cert_file']
     client_tub, client_listener = make_tub(ip, port, secure, cert_file)
     
     # Set the location in the trivial case of localhost
     if ip == 'localhost' or ip == '127.0.0.1':
         location = "127.0.0.1"
     
     if not secure:
         log.msg("WARNING: you are running the controller with no client security")
     
     def set_location_and_register():
         """Set the location for the tub and return a deferred."""
 
         def register(empty, ref, furl_file):
             # We create and then move to make sure that when the file
             # appears to other processes, the buffer has the flushed
             # and the file has been closed
             temp_furl_file = get_temp_furlfile(furl_file)
             client_tub.registerReference(ref, furlFile=temp_furl_file)
             os.rename(temp_furl_file, furl_file)
         
         if location == '':
             d = client_tub.setLocationAutomatically()
         else:
             d = defer.maybeDeferred(client_tub.setLocation, "%s:%i" % (location, client_listener.getPortnum()))
         
         for ciname, ci in config['controller']['controller_interfaces'].iteritems():
             log.msg("Adapting Controller to interface: %s" % ciname)
             furl_file = ci['furl_file']
             log.msg("Saving furl for interface [%s] to file: %s" % (ciname, furl_file))
             check_furl_file_security(furl_file, secure)
             adapted_controller = import_item(ci['controller_interface'])(controller_service)
             d.addCallback(register, import_item(ci['fc_interface'])(adapted_controller), 
                 furl_file=ci['furl_file'])
     
     reactor.callWhenRunning(set_location_and_register)
     return client_tub
 
 
 def make_engine_service(controller_service, config):
     """
     Create a service that will listen for engines.
     
     This service is simply a `foolscap.Tub` instance that has a set of Referenceables
     registered with it.
     """
 
     # Now create the foolscap tub
     ip = config['controller']['engine_tub']['ip']
     port = config['controller']['engine_tub'].as_int('port')
     location = config['controller']['engine_tub']['location']
     secure = config['controller']['engine_tub']['secure']
     cert_file = config['controller']['engine_tub']['cert_file']
     engine_tub, engine_listener = make_tub(ip, port, secure, cert_file)
     
     # Set the location in the trivial case of localhost
     if ip == 'localhost' or ip == '127.0.0.1':
         location = "127.0.0.1"
     
     if not secure:
         log.msg("WARNING: you are running the controller with no engine security")
     
     def set_location_and_register():
         """Set the location for the tub and return a deferred."""
 
         def register(empty, ref, furl_file):
             # We create and then move to make sure that when the file
             # appears to other processes, the buffer has the flushed
             # and the file has been closed
             temp_furl_file = get_temp_furlfile(furl_file)
             engine_tub.registerReference(ref, furlFile=temp_furl_file)
             os.rename(temp_furl_file, furl_file)
         
         if location == '':
             d = engine_tub.setLocationAutomatically()
         else:
             d = defer.maybeDeferred(engine_tub.setLocation, "%s:%i" % (location, engine_listener.getPortnum()))
     
         furl_file = config['controller']['engine_furl_file']
         engine_fc_interface = import_item(config['controller']['engine_fc_interface'])
         log.msg("Saving furl for the engine to file: %s" % furl_file)
         check_furl_file_security(furl_file, secure)
         fc_controller = engine_fc_interface(controller_service)
         d.addCallback(register, fc_controller, furl_file=furl_file)
     
     reactor.callWhenRunning(set_location_and_register)
     return engine_tub
     
 def start_controller():
     """
     Start the controller by creating the service hierarchy and starting the reactor.
     
     This method does the following:
     
         * It starts the controller logging
         * In execute an import statement for the controller
         * It creates 2 `foolscap.Tub` instances for the client and the engines
           and registers `foolscap.Referenceables` with the tubs to expose the
           controller to engines and clients.
     """
     config = kernel_config_manager.get_config_obj()
     
     # Start logging
     logfile = config['controller']['logfile']
     if logfile:
         logfile = logfile + str(os.getpid()) + '.log'
         try:
             openLogFile = open(logfile, 'w')
         except:
             openLogFile = sys.stdout
     else:
         openLogFile = sys.stdout
     log.startLogging(openLogFile)
     
     # Execute any user defined import statements
     cis = config['controller']['import_statement']
     if cis:
         try:
             exec cis in globals(), locals()
         except:
             log.msg("Error running import_statement: %s" % cis)
     
     # Delete old furl files unless the reuse_furls is set
     reuse = config['controller']['reuse_furls']
     if not reuse:
         paths = (config['controller']['engine_furl_file'],
             config['controller']['controller_interfaces']['task']['furl_file'],
             config['controller']['controller_interfaces']['multiengine']['furl_file']
         )
         for p in paths:
             if os.path.isfile(p):
                 os.remove(p)
     
     # Create the service hierarchy
     main_service = service.MultiService()
     # The controller service
     controller_service = controllerservice.ControllerService()
     controller_service.setServiceParent(main_service)
     # The client tub and all its refereceables
     client_service = make_client_service(controller_service, config)
     client_service.setServiceParent(main_service)
     # The engine tub
     engine_service = make_engine_service(controller_service, config)
     engine_service.setServiceParent(main_service)
     # Start the controller service and set things running
     main_service.startService()
     reactor.run()
 
 def init_config():
     """
     Initialize the configuration using default and command line options.
     """
     
     parser = OptionParser("""ipcontroller [options]
 
 Start an IPython controller.
 
 Use the IPYTHONDIR environment variable to change your IPython directory 
 from the default of .ipython or _ipython.  The log and security 
 subdirectories of your IPython directory will be used by this script 
 for log files and security files.""")
     
     # Client related options
     parser.add_option(
         "--client-ip", 
         type="string",
         dest="client_ip",
         help="the IP address or hostname the controller will listen on for client connections"
     )
     parser.add_option(
         "--client-port", 
         type="int", 
         dest="client_port",
         help="the port the controller will listen on for client connections"
     )    
     parser.add_option(
         '--client-location',
         type="string",
         dest="client_location",
         help="hostname or ip for clients to connect to"
     )
     parser.add_option(
         "-x",
         action="store_false",
         dest="client_secure",
         help="turn off all client security"
     )
     parser.add_option(
         '--client-cert-file',
         type="string",
         dest="client_cert_file",
         help="file to store the client SSL certificate"
     )
     parser.add_option(
         '--task-furl-file',
         type="string",
         dest="task_furl_file",
         help="file to store the FURL for task clients to connect with"
     )
     parser.add_option(
         '--multiengine-furl-file',
         type="string",
         dest="multiengine_furl_file",
         help="file to store the FURL for multiengine clients to connect with"
     )
     # Engine related options
     parser.add_option(
         "--engine-ip", 
         type="string",
         dest="engine_ip",
         help="the IP address or hostname the controller will listen on for engine connections"
     )
     parser.add_option(
         "--engine-port", 
         type="int", 
         dest="engine_port",
         help="the port the controller will listen on for engine connections"
     )    
     parser.add_option(
         '--engine-location',
         type="string",
         dest="engine_location",
         help="hostname or ip for engines to connect to"
     )
     parser.add_option(
         "-y",
         action="store_false",
         dest="engine_secure",
         help="turn off all engine security"
     )
     parser.add_option(
         '--engine-cert-file',
         type="string",
         dest="engine_cert_file",
         help="file to store the engine SSL certificate"
     )
     parser.add_option(
         '--engine-furl-file',
         type="string",
         dest="engine_furl_file",
         help="file to store the FURL for engines to connect with"
     )
     parser.add_option(
         "-l", "--logfile",
         type="string",
         dest="logfile",
         help="log file name (default is stdout)"
     )
     parser.add_option(
         "-r",
         action="store_true",
         dest="reuse_furls",
         help="try to reuse all furl files"
     )
     
     (options, args) = parser.parse_args()
     
     config = kernel_config_manager.get_config_obj()
     
     # Update with command line options
     if options.client_ip is not None:
         config['controller']['client_tub']['ip'] = options.client_ip
     if options.client_port is not None:
         config['controller']['client_tub']['port'] = options.client_port
     if options.client_location is not None:
         config['controller']['client_tub']['location'] = options.client_location
     if options.client_secure is not None:
         config['controller']['client_tub']['secure'] = options.client_secure
     if options.client_cert_file is not None:
         config['controller']['client_tub']['cert_file'] = options.client_cert_file
     if options.task_furl_file is not None:
         config['controller']['controller_interfaces']['task']['furl_file'] = options.task_furl_file
     if options.multiengine_furl_file is not None:
         config['controller']['controller_interfaces']['multiengine']['furl_file'] = options.multiengine_furl_file
     if options.engine_ip is not None:
         config['controller']['engine_tub']['ip'] = options.engine_ip
     if options.engine_port is not None:
         config['controller']['engine_tub']['port'] = options.engine_port
     if options.engine_location is not None:
         config['controller']['engine_tub']['location'] = options.engine_location
     if options.engine_secure is not None:
         config['controller']['engine_tub']['secure'] = options.engine_secure
     if options.engine_cert_file is not None:
         config['controller']['engine_tub']['cert_file'] = options.engine_cert_file
     if options.engine_furl_file is not None:
         config['controller']['engine_furl_file'] = options.engine_furl_file
     if options.reuse_furls is not None:
             config['controller']['reuse_furls'] = options.reuse_furls
 
     if options.logfile is not None:
         config['controller']['logfile'] = options.logfile
     
     kernel_config_manager.update_config_obj(config)
 
 def main():
     """
     After creating the configuration information, start the controller.
     """
     init_config()
     start_controller()
     
 if __name__ == "__main__":
     main()

IPython/kernel/scripts/ipengine.py

@@ -1,193 +1,193
 #!/usr/bin/env python
 # encoding: utf-8
 
 """Start the IPython Engine."""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 # Python looks for an empty string at the beginning of sys.path to enable
 # importing from the cwd.
 import sys
 sys.path.insert(0, '')
 
 from optparse import OptionParser
 import os
 
 from twisted.application import service
 from twisted.internet import reactor
 from twisted.python import log
 
 from IPython.kernel.fcutil import Tub, UnauthenticatedTub
 
 from IPython.kernel.core.config import config_manager as core_config_manager
 from IPython.config.cutils import import_item
 from IPython.kernel.engineservice import EngineService
 
 # Create various ipython directories if they don't exist.
 # This must be done before IPython.kernel.config is imported.
-from IPython.iplib import user_setup
+from IPython.core.iplib import user_setup
 from IPython.utils.genutils import get_ipython_dir, get_log_dir, get_security_dir
 if os.name == 'posix':
     rc_suffix = ''
 else:
     rc_suffix = '.ini'
 user_setup(get_ipython_dir(), rc_suffix, mode='install', interactive=False)
 get_log_dir()
 get_security_dir()
 
 from IPython.kernel.config import config_manager as kernel_config_manager
 from IPython.kernel.engineconnector import EngineConnector
 
 
 #-------------------------------------------------------------------------------
 # Code
 #-------------------------------------------------------------------------------
 
 def start_engine():
     """
     Start the engine, by creating it and starting the Twisted reactor.
     
     This method does:
     
         * If it exists, runs the `mpi_import_statement` to call `MPI_Init`
         * Starts the engine logging
         * Creates an IPython shell and wraps it in an `EngineService`
         * Creates a `foolscap.Tub` to use in connecting to a controller.
         * Uses the tub and the `EngineService` along with a Foolscap URL
           (or FURL) to connect to the controller and register the engine
           with the controller
     """
     kernel_config = kernel_config_manager.get_config_obj()
     core_config = core_config_manager.get_config_obj()
     
 
     # Execute the mpi import statement that needs to call MPI_Init
     global mpi
     mpikey = kernel_config['mpi']['default']
     mpi_import_statement = kernel_config['mpi'].get(mpikey, None)
     if mpi_import_statement is not None:
         try:
             exec mpi_import_statement in globals()
         except:
             mpi = None
     else:
         mpi = None
     
     # Start logging
     logfile = kernel_config['engine']['logfile']
     if logfile:
         logfile = logfile + str(os.getpid()) + '.log'
         try:
             openLogFile = open(logfile, 'w')
         except:
             openLogFile = sys.stdout
     else:
         openLogFile = sys.stdout
     log.startLogging(openLogFile)
     
     # Create the underlying shell class and EngineService
     shell_class = import_item(core_config['shell']['shell_class'])
     engine_service = EngineService(shell_class, mpi=mpi)
     shell_import_statement = core_config['shell']['import_statement']
     if shell_import_statement:
         try:
             engine_service.execute(shell_import_statement)
         except:
             log.msg("Error running import_statement: %s" % shell_import_statement)
     
     # Create the service hierarchy
     main_service = service.MultiService()
     engine_service.setServiceParent(main_service)
     tub_service = Tub()
     tub_service.setServiceParent(main_service)
     # This needs to be called before the connection is initiated
     main_service.startService()
     
     # This initiates the connection to the controller and calls
     # register_engine to tell the controller we are ready to do work
     engine_connector = EngineConnector(tub_service)
     furl_file = kernel_config['engine']['furl_file']
     log.msg("Using furl file: %s" % furl_file)
     
     def call_connect(engine_service, furl_file):
         d = engine_connector.connect_to_controller(engine_service, furl_file)
         def handle_error(f):
             # If this print statement is replaced by a log.err(f) I get
             # an unhandled error, which makes no sense.  I shouldn't have
             # to use a print statement here.  My only thought is that
             # at the beginning of the process the logging is still starting up
             print "error connecting to controller:", f.getErrorMessage()
             reactor.callLater(0.1, reactor.stop)
         d.addErrback(handle_error)
     
     reactor.callWhenRunning(call_connect, engine_service, furl_file)
     reactor.run()
 
 
 def init_config():
     """
     Initialize the configuration using default and command line options.
     """
     
     parser = OptionParser("""ipengine [options]
 
 Start an IPython engine.
 
 Use the IPYTHONDIR environment variable to change your IPython directory 
 from the default of .ipython or _ipython.  The log and security 
 subdirectories of your IPython directory will be used by this script 
 for log files and security files.""")
     
     parser.add_option(
         "--furl-file",
         type="string", 
         dest="furl_file",
         help="The filename containing the FURL of the controller"
     )
     parser.add_option(
         "--mpi",
         type="string",
         dest="mpi",
         help="How to enable MPI (mpi4py, pytrilinos, or empty string to disable)"
     )
     parser.add_option(
         "-l",
         "--logfile",
         type="string",
         dest="logfile",
         help="log file name (default is stdout)"
     )
     
     (options, args) = parser.parse_args()
     
     kernel_config = kernel_config_manager.get_config_obj()
     # Now override with command line options
     if options.furl_file is not None:
         kernel_config['engine']['furl_file'] = options.furl_file
     if options.logfile is not None:
         kernel_config['engine']['logfile'] = options.logfile
     if options.mpi is not None:
         kernel_config['mpi']['default'] = options.mpi
 
 
 def main():
     """
     After creating the configuration information, start the engine.
     """
     init_config()
     start_engine()
 
 
 if __name__ == "__main__":
     main()

IPython/testing/plugin/Makefile

@@ -1,74 +1,74
 # Set this prefix to where you want to install the plugin
 PREFIX=/usr/local
 
 NOSE0=nosetests -vs --with-doctest --doctest-tests --detailed-errors
 NOSE=nosetests -vvs --with-ipdoctest --doctest-tests --doctest-extension=txt \
 --detailed-errors
 
 SRC=ipdoctest.py setup.py ../decorators.py
 
 # Default target for clean 'make'
 default: iplib
 
 # The actual plugin installation
 plugin: IPython_doctest_plugin.egg-info
 
 # Simple targets that test one thing
 simple: plugin simple.py
 	$(NOSE) simple.py
 
 dtest: plugin dtexample.py
 	$(NOSE) dtexample.py
 
 rtest: plugin test_refs.py
 	$(NOSE) test_refs.py
 
 test: plugin dtexample.py
 	$(NOSE) dtexample.py test*.py test*.txt
 
 deb: plugin dtexample.py
 	$(NOSE) test_combo.txt
 
 # IPython tests
 deco:
 	$(NOSE0) IPython.testing.decorators
 
 magic: plugin
 	$(NOSE) IPython.Magic
 
 excolors: plugin
 	$(NOSE) IPython.core.excolors
 
 iplib: plugin
-	$(NOSE)  IPython.iplib
+	$(NOSE)  IPython.core.iplib
 
 strd: plugin
 	$(NOSE) IPython.strdispatch
 
 engine: plugin
 	$(NOSE) IPython.kernel
 
 tf: plugin
 	$(NOSE) IPython.config.traitlets
 
 # All of ipython itself
 ipython: plugin
 	$(NOSE) IPython
 
 
 # Combined targets
 sr: rtest strd
 
 base: dtest rtest test strd deco
 
 quick: base iplib ipipe
 
 all: base ipython
 
 # Main plugin and cleanup
 IPython_doctest_plugin.egg-info: $(SRC)
 	python setup.py install --prefix=$(PREFIX)
 	touch $@
 
 clean:
 	rm -rf IPython_doctest_plugin.egg-info *~ *pyc build/ dist/

IPython/testing/plugin/ipdoctest.py

@@ -1,909 +1,909
 """Nose Plugin that supports IPython doctests.
 
 Limitations:
 
 - When generating examples for use as doctests, make sure that you have
   pretty-printing OFF.  This can be done either by starting ipython with the
   flag '--nopprint', by setting pprint to 0 in your ipythonrc file, or by
   interactively disabling it with %Pprint.  This is required so that IPython
   output matches that of normal Python, which is used by doctest for internal
   execution.
 
 - Do not rely on specific prompt numbers for results (such as using
   '_34==True', for example).  For IPython tests run via an external process the
   prompt numbers may be different, and IPython tests run as normal python code
   won't even have these special _NN variables set at all.
 """
 
 #-----------------------------------------------------------------------------
 # Module imports
 
 # From the standard library
 import __builtin__
 import commands
 import doctest
 import inspect
 import logging
 import os
 import re
 import sys
 import traceback
 import unittest
 
 from inspect import getmodule
 from StringIO import StringIO
 
 # We are overriding the default doctest runner, so we need to import a few
 # things from doctest directly
 from doctest import (REPORTING_FLAGS, REPORT_ONLY_FIRST_FAILURE,
                      _unittest_reportflags, DocTestRunner,
                      _extract_future_flags, pdb, _OutputRedirectingPdb,
                      _exception_traceback,
                      linecache)
 
 # Third-party modules
 import nose.core
 
 from nose.plugins import doctests, Plugin
 from nose.util import anyp, getpackage, test_address, resolve_name, tolist
 
 #-----------------------------------------------------------------------------
 # Module globals and other constants
 
 log = logging.getLogger(__name__)
 
 ###########################################################################
 # *** HACK ***
 # We must start our own ipython object and heavily muck with it so that all the
 # modifications IPython makes to system behavior don't send the doctest
 # machinery into a fit.  This code should be considered a gross hack, but it
 # gets the job done.
 
 def default_argv():
     """Return a valid default argv for creating testing instances of ipython"""
 
     # Get the install directory for the user configuration and tell ipython to
     # use the default profile from there.
     from IPython import UserConfig
     ipcdir = os.path.dirname(UserConfig.__file__)
     #ipconf = os.path.join(ipcdir,'ipy_user_conf.py')
     ipconf = os.path.join(ipcdir,'ipythonrc')
     #print 'conf:',ipconf # dbg
     
     return ['--colors=NoColor','--noterm_title','-rcfile=%s' % ipconf]
 
 
 # Hack to modify the %run command so we can sync the user's namespace with the
 # test globals.  Once we move over to a clean magic system, this will be done
 # with much less ugliness.
 
 class py_file_finder(object):
     def __init__(self,test_filename):
         self.test_filename = test_filename
         
     def __call__(self,name):
         from IPython.utils.genutils import get_py_filename
         try:
             return get_py_filename(name)
         except IOError:
             test_dir = os.path.dirname(self.test_filename)
             new_path = os.path.join(test_dir,name)
             return get_py_filename(new_path)
     
 
 def _run_ns_sync(self,arg_s,runner=None):
     """Modified version of %run that syncs testing namespaces.
 
     This is strictly needed for running doctests that call %run.
     """
 
     # When tests call %run directly (not via doctest) these function attributes
     # are not set
     try:
         fname = _run_ns_sync.test_filename
     except AttributeError:
         fname = arg_s
 
     finder = py_file_finder(fname)
     out = _ip.IP.magic_run_ori(arg_s,runner,finder)
     
     # Simliarly, there is no test_globs when a test is NOT a doctest
     if hasattr(_run_ns_sync,'test_globs'):
         _run_ns_sync.test_globs.update(_ip.user_ns)
     return out
 
 
 class ipnsdict(dict):
     """A special subclass of dict for use as an IPython namespace in doctests.
 
     This subclass adds a simple checkpointing capability so that when testing
     machinery clears it (we use it as the test execution context), it doesn't
     get completely destroyed.
     """
     
     def __init__(self,*a):
         dict.__init__(self,*a)
         self._savedict = {}
         
     def clear(self):
         dict.clear(self)
         self.update(self._savedict)
 
     def _checkpoint(self):
         self._savedict.clear()
         self._savedict.update(self)
 
     def update(self,other):
         self._checkpoint()
         dict.update(self,other)
 
         # If '_' is in the namespace, python won't set it when executing code,
         # and we have examples that test it.  So we ensure that the namespace
         # is always 'clean' of it before it's used for test code execution.
         self.pop('_',None)
 
         # The builtins namespace must *always* be the real __builtin__ module,
         # else weird stuff happens.  The main ipython code does have provisions
         # to ensure this after %run, but since in this class we do some
         # aggressive low-level cleaning of the execution namespace, we need to
         # correct for that ourselves, to ensure consitency with the 'real'
         # ipython.
         self['__builtins__'] = __builtin__
         
 
 def start_ipython():
     """Start a global IPython shell, which we need for IPython-specific syntax.
     """
 
     # This function should only ever run once!
     if hasattr(start_ipython,'already_called'):
         return
     start_ipython.already_called = True
 
     # Ok,  first time we're called, go ahead
     import new
 
     import IPython
     from IPython.core import ipapi
     
     def xsys(cmd):
         """Execute a command and print its output.
 
         This is just a convenience function to replace the IPython system call
         with one that is more doctest-friendly.
         """
         cmd = _ip.IP.var_expand(cmd,depth=1)
         sys.stdout.write(commands.getoutput(cmd))
         sys.stdout.flush()
 
     # Store certain global objects that IPython modifies
     _displayhook = sys.displayhook
     _excepthook = sys.excepthook
     _main = sys.modules.get('__main__')
 
     argv = default_argv()
     
     # Start IPython instance.  We customize it to start with minimal frills.
     user_ns,global_ns = ipapi.make_user_namespaces(ipnsdict(),dict())
     IPython.Shell.IPShell(argv,user_ns,global_ns)
 
     # Deactivate the various python system hooks added by ipython for
     # interactive convenience so we don't confuse the doctest system
     sys.modules['__main__'] = _main
     sys.displayhook = _displayhook
     sys.excepthook = _excepthook
 
     # So that ipython magics and aliases can be doctested (they work by making
     # a call into a global _ip object)
-    _ip = IPython.ipapi.get()
+    _ip = ipapi.get()
     __builtin__._ip = _ip
 
     # Modify the IPython system call with one that uses getoutput, so that we
     # can capture subcommands and print them to Python's stdout, otherwise the
     # doctest machinery would miss them.
     _ip.system = xsys
 
     # Also patch our %run function in.
     im = new.instancemethod(_run_ns_sync,_ip.IP, _ip.IP.__class__)
     _ip.IP.magic_run_ori = _ip.IP.magic_run
     _ip.IP.magic_run = im
 
 # The start call MUST be made here.  I'm not sure yet why it doesn't work if
 # it is made later, at plugin initialization time, but in all my tests, that's
 # the case.
 start_ipython()
 
 # *** END HACK ***
 ###########################################################################
 
 # Classes and functions
 
 def is_extension_module(filename):
     """Return whether the given filename is an extension module.
 
     This simply checks that the extension is either .so or .pyd.
     """
     return os.path.splitext(filename)[1].lower() in ('.so','.pyd')
 
 
 class DocTestSkip(object):
     """Object wrapper for doctests to be skipped."""
     
     ds_skip = """Doctest to skip.
     >>> 1 #doctest: +SKIP
     """
 
     def __init__(self,obj):
         self.obj = obj
 
     def __getattribute__(self,key):
         if key == '__doc__':
             return DocTestSkip.ds_skip
         else:
             return getattr(object.__getattribute__(self,'obj'),key)
 
 # Modified version of the one in the stdlib, that fixes a python bug (doctests
 # not found in extension modules, http://bugs.python.org/issue3158)
 class DocTestFinder(doctest.DocTestFinder):
 
     def _from_module(self, module, object):
         """
         Return true if the given object is defined in the given
         module.
         """
         if module is None:
             return True
         elif inspect.isfunction(object):
             return module.__dict__ is object.func_globals
         elif inspect.isbuiltin(object):
             return module.__name__ == object.__module__
         elif inspect.isclass(object):
             return module.__name__ == object.__module__
         elif inspect.ismethod(object):
             # This one may be a bug in cython that fails to correctly set the
             # __module__ attribute of methods, but since the same error is easy
             # to make by extension code writers, having this safety in place
             # isn't such a bad idea
             return module.__name__ == object.im_class.__module__
         elif inspect.getmodule(object) is not None:
             return module is inspect.getmodule(object)
         elif hasattr(object, '__module__'):
             return module.__name__ == object.__module__
         elif isinstance(object, property):
             return True # [XX] no way not be sure.
         else:
             raise ValueError("object must be a class or function")
 
     def _find(self, tests, obj, name, module, source_lines, globs, seen):
         """
         Find tests for the given object and any contained objects, and
         add them to `tests`.
         """
 
         if hasattr(obj,"skip_doctest"):
             #print 'SKIPPING DOCTEST FOR:',obj  # dbg
             obj = DocTestSkip(obj)
 
         doctest.DocTestFinder._find(self,tests, obj, name, module,
                                     source_lines, globs, seen)
 
         # Below we re-run pieces of the above method with manual modifications,
         # because the original code is buggy and fails to correctly identify
         # doctests in extension modules.
 
         # Local shorthands
         from inspect import isroutine, isclass, ismodule
 
         # Look for tests in a module's contained objects.
         if inspect.ismodule(obj) and self._recurse:
             for valname, val in obj.__dict__.items():
                 valname1 = '%s.%s' % (name, valname)
                 if ( (isroutine(val) or isclass(val))
                      and self._from_module(module, val) ):
 
                     self._find(tests, val, valname1, module, source_lines,
                                globs, seen)
 
         # Look for tests in a class's contained objects.
         if inspect.isclass(obj) and self._recurse:
             #print 'RECURSE into class:',obj  # dbg
             for valname, val in obj.__dict__.items():
                 # Special handling for staticmethod/classmethod.
                 if isinstance(val, staticmethod):
                     val = getattr(obj, valname)
                 if isinstance(val, classmethod):
                     val = getattr(obj, valname).im_func
 
                 # Recurse to methods, properties, and nested classes.
                 if ((inspect.isfunction(val) or inspect.isclass(val) or
                      inspect.ismethod(val) or
                       isinstance(val, property)) and
                       self._from_module(module, val)):
                     valname = '%s.%s' % (name, valname)
                     self._find(tests, val, valname, module, source_lines,
                                globs, seen)
 
 
 class IPDoctestOutputChecker(doctest.OutputChecker):
     """Second-chance checker with support for random tests.
     
     If the default comparison doesn't pass, this checker looks in the expected
     output string for flags that tell us to ignore the output.
     """
 
     random_re = re.compile(r'#\s*random\s+')
     
     def check_output(self, want, got, optionflags):
         """Check output, accepting special markers embedded in the output.
 
         If the output didn't pass the default validation but the special string
         '#random' is included, we accept it."""
 
         # Let the original tester verify first, in case people have valid tests
         # that happen to have a comment saying '#random' embedded in.
         ret = doctest.OutputChecker.check_output(self, want, got,
                                                  optionflags)
         if not ret and self.random_re.search(want):
             #print >> sys.stderr, 'RANDOM OK:',want  # dbg
             return True
 
         return ret
 
 
 class DocTestCase(doctests.DocTestCase):
     """Proxy for DocTestCase: provides an address() method that
     returns the correct address for the doctest case. Otherwise
     acts as a proxy to the test case. To provide hints for address(),
     an obj may also be passed -- this will be used as the test object
     for purposes of determining the test address, if it is provided.
     """
 
     # Note: this method was taken from numpy's nosetester module.
 
     # Subclass nose.plugins.doctests.DocTestCase to work around a bug in
     # its constructor that blocks non-default arguments from being passed
     # down into doctest.DocTestCase
 
     def __init__(self, test, optionflags=0, setUp=None, tearDown=None,
                  checker=None, obj=None, result_var='_'):
         self._result_var = result_var
         doctests.DocTestCase.__init__(self, test,
                                       optionflags=optionflags,
                                       setUp=setUp, tearDown=tearDown,
                                       checker=checker)
         # Now we must actually copy the original constructor from the stdlib
         # doctest class, because we can't call it directly and a bug in nose
         # means it never gets passed the right arguments.
 
         self._dt_optionflags = optionflags
         self._dt_checker = checker
         self._dt_test = test
         self._dt_setUp = setUp
         self._dt_tearDown = tearDown
 
         # XXX - store this runner once in the object!
         runner = IPDocTestRunner(optionflags=optionflags,
                                  checker=checker, verbose=False)
         self._dt_runner = runner
 
 
         # Each doctest should remember what directory it was loaded from...
         self._ori_dir = os.getcwd()
 
     # Modified runTest from the default stdlib
     def runTest(self):
         test = self._dt_test
         runner = self._dt_runner
         
         old = sys.stdout
         new = StringIO()
         optionflags = self._dt_optionflags
 
         if not (optionflags & REPORTING_FLAGS):
             # The option flags don't include any reporting flags,
             # so add the default reporting flags
             optionflags |= _unittest_reportflags
 
         try:
             # Save our current directory and switch out to the one where the
             # test was originally created, in case another doctest did a
             # directory change.  We'll restore this in the finally clause.
             curdir = os.getcwd()
             os.chdir(self._ori_dir)
 
             runner.DIVIDER = "-"*70
             failures, tries = runner.run(test,out=new.write,
                                          clear_globs=False)
         finally:
             sys.stdout = old
             os.chdir(curdir)
 
         if failures:
             raise self.failureException(self.format_failure(new.getvalue()))
 
     def setUp(self):
         """Modified test setup that syncs with ipython namespace"""
         
         if isinstance(self._dt_test.examples[0],IPExample):
             # for IPython examples *only*, we swap the globals with the ipython
             # namespace, after updating it with the globals (which doctest
             # fills with the necessary info from the module being tested).
             _ip.IP.user_ns.update(self._dt_test.globs)
             self._dt_test.globs = _ip.IP.user_ns
 
         doctests.DocTestCase.setUp(self)
 
 
 # A simple subclassing of the original with a different class name, so we can
 # distinguish and treat differently IPython examples from pure python ones.
 class IPExample(doctest.Example): pass
 
 
 class IPExternalExample(doctest.Example):
     """Doctest examples to be run in an external process."""
 
     def __init__(self, source, want, exc_msg=None, lineno=0, indent=0,
                  options=None):
         # Parent constructor
         doctest.Example.__init__(self,source,want,exc_msg,lineno,indent,options)
 
         # An EXTRA newline is needed to prevent pexpect hangs
         self.source += '\n'
 
 
 class IPDocTestParser(doctest.DocTestParser):
     """
     A class used to parse strings containing doctest examples.
 
     Note: This is a version modified to properly recognize IPython input and
     convert any IPython examples into valid Python ones.
     """
     # This regular expression is used to find doctest examples in a
     # string.  It defines three groups: `source` is the source code
     # (including leading indentation and prompts); `indent` is the
     # indentation of the first (PS1) line of the source code; and
     # `want` is the expected output (including leading indentation).
 
     # Classic Python prompts or default IPython ones
     _PS1_PY = r'>>>'
     _PS2_PY = r'\.\.\.'
 
     _PS1_IP = r'In\ \[\d+\]:'
     _PS2_IP = r'\ \ \ \.\.\.+:'
 
     _RE_TPL = r'''
         # Source consists of a PS1 line followed by zero or more PS2 lines.
         (?P<source>
             (?:^(?P<indent> [ ]*) (?P<ps1> %s) .*)    # PS1 line
             (?:\n           [ ]*  (?P<ps2> %s) .*)*)  # PS2 lines
         \n? # a newline
         # Want consists of any non-blank lines that do not start with PS1.
         (?P<want> (?:(?![ ]*$)    # Not a blank line
                      (?![ ]*%s)   # Not a line starting with PS1
                      (?![ ]*%s)   # Not a line starting with PS2
                      .*$\n?       # But any other line
                   )*)
                   '''
 
     _EXAMPLE_RE_PY = re.compile( _RE_TPL % (_PS1_PY,_PS2_PY,_PS1_PY,_PS2_PY),
                                  re.MULTILINE | re.VERBOSE)
 
     _EXAMPLE_RE_IP = re.compile( _RE_TPL % (_PS1_IP,_PS2_IP,_PS1_IP,_PS2_IP),
                                  re.MULTILINE | re.VERBOSE)
 
     # Mark a test as being fully random.  In this case, we simply append the
     # random marker ('#random') to each individual example's output.  This way
     # we don't need to modify any other code.
     _RANDOM_TEST = re.compile(r'#\s*all-random\s+')
 
     # Mark tests to be executed in an external process - currently unsupported.
     _EXTERNAL_IP = re.compile(r'#\s*ipdoctest:\s*EXTERNAL')
     
     def ip2py(self,source):
         """Convert input IPython source into valid Python."""
         out = []
         newline = out.append
         #print 'IPSRC:\n',source,'\n###'  # dbg
         # The input source must be first stripped of all bracketing whitespace
         # and turned into lines, so it looks to the parser like regular user
         # input
         for lnum,line in enumerate(source.strip().splitlines()):
             newline(_ip.IP.prefilter(line,lnum>0))
         newline('')  # ensure a closing newline, needed by doctest
         #print "PYSRC:", '\n'.join(out)  # dbg
         return '\n'.join(out)
 
     def parse(self, string, name='<string>'):
         """
         Divide the given string into examples and intervening text,
         and return them as a list of alternating Examples and strings.
         Line numbers for the Examples are 0-based.  The optional
         argument `name` is a name identifying this string, and is only
         used for error messages.
         """
 
         #print 'Parse string:\n',string # dbg
 
         string = string.expandtabs()
         # If all lines begin with the same indentation, then strip it.
         min_indent = self._min_indent(string)
         if min_indent > 0:
             string = '\n'.join([l[min_indent:] for l in string.split('\n')])
 
         output = []
         charno, lineno = 0, 0
 
         # We make 'all random' tests by adding the '# random' mark to every
         # block of output in the test.
         if self._RANDOM_TEST.search(string):
             random_marker = '\n# random'
         else:
             random_marker = ''
 
         # Whether to convert the input from ipython to python syntax
         ip2py = False
         # Find all doctest examples in the string.  First, try them as Python
         # examples, then as IPython ones
         terms = list(self._EXAMPLE_RE_PY.finditer(string))
         if terms:
             # Normal Python example
             #print '-'*70  # dbg
             #print 'PyExample, Source:\n',string  # dbg
             #print '-'*70  # dbg
             Example = doctest.Example
         else:
             # It's an ipython example.  Note that IPExamples are run
             # in-process, so their syntax must be turned into valid python.
             # IPExternalExamples are run out-of-process (via pexpect) so they
             # don't need any filtering (a real ipython will be executing them).
             terms = list(self._EXAMPLE_RE_IP.finditer(string))
             if self._EXTERNAL_IP.search(string):
                 #print '-'*70  # dbg
                 #print 'IPExternalExample, Source:\n',string  # dbg
                 #print '-'*70  # dbg
                 Example = IPExternalExample
             else:
                 #print '-'*70  # dbg
                 #print 'IPExample, Source:\n',string  # dbg
                 #print '-'*70  # dbg
                 Example = IPExample
                 ip2py = True
 
         for m in terms:
             # Add the pre-example text to `output`.
             output.append(string[charno:m.start()])
             # Update lineno (lines before this example)
             lineno += string.count('\n', charno, m.start())
             # Extract info from the regexp match.
             (source, options, want, exc_msg) = \
                      self._parse_example(m, name, lineno,ip2py)
 
             # Append the random-output marker (it defaults to empty in most
             # cases, it's only non-empty for 'all-random' tests):
             want += random_marker
                 
             if Example is IPExternalExample:
                 options[doctest.NORMALIZE_WHITESPACE] = True
                 want += '\n'
 
             # Create an Example, and add it to the list.
             if not self._IS_BLANK_OR_COMMENT(source):
                 output.append(Example(source, want, exc_msg,
                                       lineno=lineno,
                                       indent=min_indent+len(m.group('indent')),
                                       options=options))
             # Update lineno (lines inside this example)
             lineno += string.count('\n', m.start(), m.end())
             # Update charno.
             charno = m.end()
         # Add any remaining post-example text to `output`.
         output.append(string[charno:])
         return output
 
     def _parse_example(self, m, name, lineno,ip2py=False):
         """
         Given a regular expression match from `_EXAMPLE_RE` (`m`),
         return a pair `(source, want)`, where `source` is the matched
         example's source code (with prompts and indentation stripped);
         and `want` is the example's expected output (with indentation
         stripped).
 
         `name` is the string's name, and `lineno` is the line number
         where the example starts; both are used for error messages.
 
         Optional:
         `ip2py`: if true, filter the input via IPython to convert the syntax
         into valid python.
         """
 
         # Get the example's indentation level.
         indent = len(m.group('indent'))
 
         # Divide source into lines; check that they're properly
         # indented; and then strip their indentation & prompts.
         source_lines = m.group('source').split('\n')
 
         # We're using variable-length input prompts
         ps1 = m.group('ps1')
         ps2 = m.group('ps2')
         ps1_len = len(ps1)
 
         self._check_prompt_blank(source_lines, indent, name, lineno,ps1_len)
         if ps2:
             self._check_prefix(source_lines[1:], ' '*indent + ps2, name, lineno)
 
         source = '\n'.join([sl[indent+ps1_len+1:] for sl in source_lines])
 
         if ip2py:
             # Convert source input from IPython into valid Python syntax
             source = self.ip2py(source)
 
         # Divide want into lines; check that it's properly indented; and
         # then strip the indentation.  Spaces before the last newline should
         # be preserved, so plain rstrip() isn't good enough.
         want = m.group('want')
         want_lines = want.split('\n')
         if len(want_lines) > 1 and re.match(r' *$', want_lines[-1]):
             del want_lines[-1]  # forget final newline & spaces after it
         self._check_prefix(want_lines, ' '*indent, name,
                            lineno + len(source_lines))
 
         # Remove ipython output prompt that might be present in the first line
         want_lines[0] = re.sub(r'Out\[\d+\]: \s*?\n?','',want_lines[0])
 
         want = '\n'.join([wl[indent:] for wl in want_lines])
 
         # If `want` contains a traceback message, then extract it.
         m = self._EXCEPTION_RE.match(want)
         if m:
             exc_msg = m.group('msg')
         else:
             exc_msg = None
 
         # Extract options from the source.
         options = self._find_options(source, name, lineno)
 
         return source, options, want, exc_msg
 
     def _check_prompt_blank(self, lines, indent, name, lineno, ps1_len):
         """
         Given the lines of a source string (including prompts and
         leading indentation), check to make sure that every prompt is
         followed by a space character.  If any line is not followed by
         a space character, then raise ValueError.
 
         Note: IPython-modified version which takes the input prompt length as a
         parameter, so that prompts of variable length can be dealt with.
         """
         space_idx = indent+ps1_len
         min_len = space_idx+1
         for i, line in enumerate(lines):
             if len(line) >=  min_len and line[space_idx] != ' ':
                 raise ValueError('line %r of the docstring for %s '
                                  'lacks blank after %s: %r' %
                                  (lineno+i+1, name,
                                   line[indent:space_idx], line))
 
 
 SKIP = doctest.register_optionflag('SKIP')
 
 
 class IPDocTestRunner(doctest.DocTestRunner,object):
     """Test runner that synchronizes the IPython namespace with test globals.
     """
     
     def run(self, test, compileflags=None, out=None, clear_globs=True):
 
         # Hack: ipython needs access to the execution context of the example,
         # so that it can propagate user variables loaded by %run into
         # test.globs.  We put them here into our modified %run as a function
         # attribute.  Our new %run will then only make the namespace update
         # when called (rather than unconconditionally updating test.globs here
         # for all examples, most of which won't be calling %run anyway).
         _run_ns_sync.test_globs = test.globs
         _run_ns_sync.test_filename = test.filename
         
         return super(IPDocTestRunner,self).run(test,
                                                compileflags,out,clear_globs)
 
 
 class DocFileCase(doctest.DocFileCase):
     """Overrides to provide filename
     """
     def address(self):
         return (self._dt_test.filename, None, None)
 
 
 class ExtensionDoctest(doctests.Doctest):
     """Nose Plugin that supports doctests in extension modules.
     """
     name = 'extdoctest'   # call nosetests with --with-extdoctest
     enabled = True
 
     def __init__(self,exclude_patterns=None):
         """Create a new ExtensionDoctest plugin.
 
         Parameters
         ----------
 
         exclude_patterns : sequence of strings, optional
           These patterns are compiled as regular expressions, subsequently used
           to exclude any filename which matches them from inclusion in the test
           suite (using pattern.search(), NOT pattern.match() ).
         """
 
         if exclude_patterns is None:
             exclude_patterns = []
         self.exclude_patterns = map(re.compile,exclude_patterns)
         doctests.Doctest.__init__(self)
 
     def options(self, parser, env=os.environ):
         Plugin.options(self, parser, env)
         parser.add_option('--doctest-tests', action='store_true',
                           dest='doctest_tests',
                           default=env.get('NOSE_DOCTEST_TESTS',True),
                           help="Also look for doctests in test modules. "
                           "Note that classes, methods and functions should "
                           "have either doctests or non-doctest tests, "
                           "not both. [NOSE_DOCTEST_TESTS]")
         parser.add_option('--doctest-extension', action="append",
                           dest="doctestExtension",
                           help="Also look for doctests in files with "
                           "this extension [NOSE_DOCTEST_EXTENSION]")
         # Set the default as a list, if given in env; otherwise
         # an additional value set on the command line will cause
         # an error.
         env_setting = env.get('NOSE_DOCTEST_EXTENSION')
         if env_setting is not None:
             parser.set_defaults(doctestExtension=tolist(env_setting))
 
 
     def configure(self, options, config):
         Plugin.configure(self, options, config)
         self.doctest_tests = options.doctest_tests
         self.extension = tolist(options.doctestExtension)
 
         self.parser = doctest.DocTestParser()
         self.finder = DocTestFinder()
         self.checker = IPDoctestOutputChecker()
         self.globs = None
         self.extraglobs = None
 
 
     def loadTestsFromExtensionModule(self,filename):
         bpath,mod = os.path.split(filename)
         modname = os.path.splitext(mod)[0]
         try:
             sys.path.append(bpath)
             module = __import__(modname)
             tests = list(self.loadTestsFromModule(module))
         finally:
             sys.path.pop()
         return tests
 
     # NOTE: the method below is almost a copy of the original one in nose, with
     # a  few modifications to control output checking.
 
     def loadTestsFromModule(self, module):
         #print '*** ipdoctest - lTM',module  # dbg
         
         if not self.matches(module.__name__):
             log.debug("Doctest doesn't want module %s", module)
             return
 
         tests = self.finder.find(module,globs=self.globs,
                                  extraglobs=self.extraglobs)
         if not tests:
             return
 
         # always use whitespace and ellipsis options
         optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
 
         tests.sort()
         module_file = module.__file__
         if module_file[-4:] in ('.pyc', '.pyo'):
             module_file = module_file[:-1]
         for test in tests:
             if not test.examples:
                 continue
             if not test.filename:
                 test.filename = module_file
             
             yield DocTestCase(test,
                               optionflags=optionflags,
                               checker=self.checker)
 
 
     def loadTestsFromFile(self, filename):
         if is_extension_module(filename):
             for t in self.loadTestsFromExtensionModule(filename):
                 yield t
         else:
             if self.extension and anyp(filename.endswith, self.extension):
                 name = os.path.basename(filename)
                 dh = open(filename)
                 try:
                     doc = dh.read()
                 finally:
                     dh.close()
                 test = self.parser.get_doctest(
                     doc, globs={'__file__': filename}, name=name,
                     filename=filename, lineno=0)
                 if test.examples:
                     #print 'FileCase:',test.examples  # dbg
                     yield DocFileCase(test)
                 else:
                     yield False # no tests to load
 
     def wantFile(self,filename):
         """Return whether the given filename should be scanned for tests.
 
         Modified version that accepts extension modules as valid containers for
         doctests.
         """
         # print '*** ipdoctest- wantFile:',filename  # dbg
 
         for pat in self.exclude_patterns:
             if pat.search(filename):
                 # print '###>>> SKIP:',filename  # dbg
                 return False
 
         if is_extension_module(filename):
             return True
         else:
             return doctests.Doctest.wantFile(self,filename)
 
 
 class IPythonDoctest(ExtensionDoctest):
     """Nose Plugin that supports doctests in extension modules.
     """
     name = 'ipdoctest'   # call nosetests with --with-ipdoctest
     enabled = True
     
     def makeTest(self, obj, parent):
         """Look for doctests in the given object, which will be a
         function, method or class.
         """
         # always use whitespace and ellipsis options
         optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
 
         doctests = self.finder.find(obj, module=getmodule(parent))
         if doctests:
             for test in doctests:
                 if len(test.examples) == 0:
                     continue
 
                 yield DocTestCase(test, obj=obj,
                                   optionflags=optionflags,
                                   checker=self.checker)
 
     def options(self, parser, env=os.environ):
         Plugin.options(self, parser, env)
         parser.add_option('--ipdoctest-tests', action='store_true',
                           dest='ipdoctest_tests',
                           default=env.get('NOSE_IPDOCTEST_TESTS',True),
                           help="Also look for doctests in test modules. "
                           "Note that classes, methods and functions should "
                           "have either doctests or non-doctest tests, "
                           "not both. [NOSE_IPDOCTEST_TESTS]")
         parser.add_option('--ipdoctest-extension', action="append",
                           dest="ipdoctest_extension",
                           help="Also look for doctests in files with "
                           "this extension [NOSE_IPDOCTEST_EXTENSION]")
         # Set the default as a list, if given in env; otherwise
         # an additional value set on the command line will cause
         # an error.
         env_setting = env.get('NOSE_IPDOCTEST_EXTENSION')
         if env_setting is not None:
             parser.set_defaults(ipdoctest_extension=tolist(env_setting))
 
     def configure(self, options, config):
         Plugin.configure(self, options, config)
         self.doctest_tests = options.ipdoctest_tests
         self.extension = tolist(options.ipdoctest_extension)
 
         self.parser = IPDocTestParser()
         self.finder = DocTestFinder(parser=self.parser)
         self.checker = IPDoctestOutputChecker()
         self.globs = None
         self.extraglobs = None

docs/source/development/reorg.txt

@@ -1,252 +1,255
 =============================
 IPython module reorganization
 =============================
 
 Currently, IPython has many top-level modules that serve many different purposes.
 The lack of organization make it very difficult for developers to work on IPython
 and understand its design. This document contains notes about how we will reorganize
 the modules into sub-packages.
 
 .. warning::
 
     This effort will possibly break third party packages that use IPython as
     a library or hack on the IPython internals.
 
 .. warning::
 
     This effort will result in the removal from IPython of certain modules
     that are not used anymore, don't currently work, are unmaintained, etc.
 
 
 Current subpackges
 ==================
 
 IPython currently has the following sub-packages:
 
 * :mod:`IPython.config`
 
 * :mod:`IPython.Extensions`
 
 * :mod:`IPython.external`
 
 * :mod:`IPython.frontend`
 
 * :mod:`IPython.gui`
 
 * :mod:`IPython.kernel`
 
 * :mod:`IPython.testing`
 
 * :mod:`IPython.tests`
 
 * :mod:`IPython.tools`
 
 * :mod:`IPython.UserConfig`
 
 New Subpackages to be created
 =============================
 
 We propose to create the following new sub-packages:
 
 * :mod:`IPython.core`. This sub-package will contain the core of the IPython
   interpreter, but none of its extended capabilities.
 
 * :mod:`IPython.lib`. IPython has many extended capabilities that are not part
   of the IPython core. These things will go here.  Any better names than 
   :mod:`IPython.lib`?
 
 * :mod:`IPython.utils`. This sub-package will contain anything that might
   eventually be found in the Python standard library, like things in
   :mod:`genutils`. Each sub-module in this sub-package should contain
   functions and classes that serve a single purpose.
 
 * :mod:`IPython.deathrow`. This is for code that is untested and/or rotting
   and needs to be removed from IPython. Eventually all this code will either
   i) be revived by someone willing to maintain it with tests and docs and
   re-included into IPython or 2) be removed from IPython proper, but put into
   a separate top-level (not IPython) package that we keep around. No new code
   will be allowed here.
 
 * :mod:`IPython.quarantine`.  This is for code that doesn't meet IPython's 
   standards, but that we plan on keeping.  To be moved out of this sub-package
   a module needs to have a maintainer, tests and documentation.
 
 Prodecure
 =========
 
 1. Move the file to its new location with its new name.
 2. Rename all import statements to reflect the change.
 3. Run PyFlakes on each changes module.
 3. Add tests/test_imports.py to test it.
 
 Need to modify iptests to properly skip modules that are no longer top
 level modules.
 
 Need to update the top level IPython/__init__.py file.
 
 Where things will be moved
 ==========================
 
 * :file:`background_jobs.py`.  Move to :file:`IPython/lib/backgroundjobs.py`.
 
 * :file:`ColorANSI.py`.  Move to :file:`IPython/utils/coloransi.py`.
 
 * :file:`completer.py`.  Move to :file:`IPython/core/completer.py`.
 
 * :file:`ConfigLoader.py`.  Move to :file:`IPython/config/configloader.py`.
 
 * :file:`CrashHandler.py`.  Move to :file:`IPython/core/crashhandler`.
 
 * :file:`Debugger.py`.  Move to :file:`IPython/core/debugger.py`.
 
 * :file:`deep_reload.py`.  Move to :file:`IPython/lib/deepreload.py`.
 
 * :file:`demo.py`.  Move to :file:`IPython/lib/demo.py`.
 
 * :file:`DPyGetOpt.py`.  Move to :mod:`IPython.utils` and replace with newer options parser.
 
 * :file:`dtutils.py`.  Move to :file:`IPython.deathrow`.
 
 * :file:`excolors.py`.  Move to :file:`IPython.core` or :file:`IPython.config`.
   Maybe move to :mod:`IPython.lib` or :mod:`IPython.python`?
 
 * :file:`FakeModule.py`.  Move to :file:`IPython/core/fakemodule.py`.
 
 * :file:`generics.py`.  Move to :file:`IPython.python`.
 
 * :file:`genutils.py`.  Move to :file:`IPython.utils`.
 
 * :file:`Gnuplot2.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`GnuplotInteractive.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`GnuplotRuntime.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`numutils.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`twshell.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`Extensions`. This needs to be gone through separately.  Minimally,
   the package should be renamed to :file:`extensions`.
 
 * :file:`history.py`.  Move to :file:`IPython.core`.
 
 * :file:`hooks.py`.  Move to :file:`IPython.core`.
 
+* :file:`ipapi.py`.  Move to :file:`IPython.core`.
+
+
 
 * :file:`Itpl.py`.  Remove.  Version already in :file:`IPython.external`.
 
 * :file:`Logger.py`.  Move to :file:`IPython/core/logger.py`.
 
 * :file:`Magic.py`.  Move to :file:`IPython/core/magic.py`.
 
 * :file:`OInspect.py`.  Move to :file:`IPython/core/oinspect.py`.
 
 * :file:`OutputTrap.py`.  Move to :file:`IPython/core/outputtrap.py`.
 
 * :file:`Prompts.py`.  Move to :file:`IPython/core/prompts.py` or
   :file:`IPython/frontend/prompts.py`.
 
 * :file:`PyColorize.py`. Replace with pygments? If not, move to
   :file:`IPython/core/pycolorize.py`. Maybe move to :mod:`IPython.lib` or
   :mod:`IPython.python`?
 
 * :file:`Release.py`.  Move to ??? or remove?
 
 * :file:`Shell.py`.  Move to :file:`IPython.core.shell.py` or
   :file:`IPython/frontend/shell.py`.
 
 * :file:`UserConfig`.  Move to a subdirectory of :file:`IPython.config`.
 
 
 
 
 * :file:`config`.  Good where it is!
 
 * :file:`external`.  Good where it is!
 
 * :file:`frontend`.  Good where it is!
 
 
 
 * :file:`gui`.  Eventually this should be moved to a subdir of   
   :file:`IPython.frontend`.
 
 
 
 
 
-* :file:`ipapi.py`.  Move to :file:`IPython.core`.
+
 
 * :file:`iplib.py`.  Move to :file:`IPython.core`.
 
 * :file:`ipmaker.py`:  Move to :file:`IPython.core`.
 
 * :file:`ipstruct.py`.  Move to :file:`IPython.python`.
 
 * :file:`irunner.py`.  Move to :file:`IPython.scripts`.
 
 * :file:`kernel`.  Good where it is.
 
 * :file:`macro.py`.  Move to :file:`IPython.core`.
 
 
 
 * :file:`platutils.py`.  Move to :file:`IPython.python`.
 
 * :file:`platutils_dummy.py`.  Move to :file:`IPython.python`.
 
 * :file:`platutils_posix.py`.  Move to :file:`IPython.python`.
 
 * :file:`platutils_win32.py`.  Move to :file:`IPython.python`.
 
 * :file:`prefilter.py`:  Move to :file:`IPython.core`.
 
 * :file:`rlineimpl.py`.  Move to :file:`IPython.core`.
 
 * :file:`shadowns.py`.  Move to :file:`IPython.core`.
 
 * :file:`shellglobals.py`.  Move to :file:`IPython.core`.
 
 * :file:`strdispatch.py`.  Move to :file:`IPython.python`.
 
 * :file:`testing`.  Good where it is.
 
 * :file:`tests`.  Good where it is.
 
 * :file:`tools`.  Things in here need to be looked at and moved elsewhere like
   :file:`IPython.python`.
 
 * :file:`twshell.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`ultraTB.py`.  Move to :file:`IPython/core/ultratb.py`.
 
 * :file:`upgrade_dir.py`.  Move to :file:`IPython/python/upgradedir.py`.
 
 * :file:`usage.py`.  Move to :file:`IPython.core`.
 
 * :file:`wildcard.py`.  Move to :file:`IPython.python` or :file:`IPython.core`.
 
 * :file:`winconsole.py`.  Move to :file:`IPython.lib`.
 
 Other things
 ============
 
 When these files are moved around, a number of other things will happen at the same time:
 
 1. Test files will be created for each module in IPython. Minimally, all
    modules will be imported as a part of the test. This will serve as a 
    test of the module reorganization. These tests will be put into new
    :file:`tests` subdirectories that each package will have.
 
 2. PyFlakes and other code checkers will be run to look for problems.
 
 3. Modules will be renamed to comply with PEP 8 naming conventions:  all
    lowercase and no special characters like ``-`` or ``_``.
 
 4. Existing tests will be moved to the appropriate :file:`tests`
    subdirectories.