Merging upstream change from module-reorg branch.

Recently lp:ipython was merged into module-reorg.  This is propagating
that merge into this inputhook branch.

IPython/lib/clipboard.py

@@ -0,0 +1,56 b''
+""" Utilities for accessing the platform's clipboard.
+"""
+
+import subprocess
+import sys
+
+from IPython.core.ipapi import TryNext
+
+
+def win32_clipboard_get():
+    """ Get the current clipboard's text on Windows.
+
+    Requires Mark Hammond's pywin32 extensions.
+    """
+    try:
+        import win32clipboard
+    except ImportError:
+        message = ("Getting text from the clipboard requires the pywin32 "
+            "extensions: http://sourceforge.net/projects/pywin32/")
+        raise TryNext(message)
+    win32clipboard.OpenClipboard() 
+    text = win32clipboard.GetClipboardData(win32clipboard.CF_TEXT) 
+    # FIXME: convert \r\n to \n?
+    win32clipboard.CloseClipboard() 
+    return text
+
+def osx_clipboard_get():
+    """ Get the clipboard's text on OS X.
+    """
+    p = subprocess.Popen(['pbpaste', '-Prefer', 'ascii'],
+        stdout=subprocess.PIPE)
+    text, stderr = p.communicate()
+    # Text comes in with old Mac \r line endings. Change them to \n.
+    text = text.replace('\r', '\n')
+    return text
+
+def tkinter_clipboard_get():
+    """ Get the clipboard's text using Tkinter.
+
+    This is the default on systems that are not Windows or OS X. It may
+    interfere with other UI toolkits and should be replaced with an
+    implementation that uses that toolkit.
+    """
+    try:
+        import Tkinter
+    except ImportError:
+        message = ("Getting text from the clipboard on this platform "
+            "requires Tkinter.")
+        raise TryNext(message)
+    root = Tkinter.Tk()
+    root.withdraw()
+    text = root.clipboard_get()
+    root.destroy()
+    return text
+
+

docs/examples/core/demo-exercizer.py

@@ -0,0 +1,85 b''
+"""This is meant to be run from the IPython prompt:
+
+%run demo-exercizer.py
+
+It will create demo objects of the example that is embedded in demo.py in a
+number of ways and allow you to see how they work, just follow the printed
+directions."""
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# From std lib
+import StringIO
+import os
+import shutil
+import tempfile
+
+# From IPython
+from IPython.demo import (Demo, IPythonDemo, LineDemo, IPythonLineDemo,
+                          ClearDemo, ClearIPDemo)
+
+#-----------------------------------------------------------------------------
+# Demo code
+#-----------------------------------------------------------------------------
+
+example1 = """
+'''A simple interactive demo to illustrate the use of IPython's Demo class.'''
+
+print 'Hello, welcome to an interactive IPython demo.'
+
+# The mark below defines a block boundary, which is a point where IPython will
+# stop execution and return to the interactive prompt. The dashes are actually
+# optional and used only as a visual aid to clearly separate blocks while
+# editing the demo code.
+# <demo> stop
+
+x = 1
+y = 2
+
+# <demo> stop
+
+# the mark below makes this block as silent
+# <demo> silent
+
+print 'This is a silent block, which gets executed but not printed.'
+
+# <demo> stop
+# <demo> auto
+print 'This is an automatic block.'
+print 'It is executed without asking for confirmation, but printed.'
+z = x+y
+
+print 'z=',x
+
+# <demo> stop
+# This is just another normal block.
+print 'z is now:', z
+
+print 'bye!'
+"""
+fp = tempfile.mkdtemp(prefix = 'DemoTmp')
+fd, filename = tempfile.mkstemp(prefix = 'demoExample1File', suffix = '.py',
+                                dir = fp)
+f = os.fdopen(fd, 'wt')
+
+f.write(example1)
+f.close()
+
+my_d = Demo(filename)
+my_cd = ClearDemo(filename)
+
+fobj = StringIO.StringIO(example1)
+str_d = Demo(fobj, title='via stringio')
+
+print '''
+The example that is embeded in demo.py file has been used to create 
+the following 3 demos, and should now be available to use:
+   my_d()    -- created from a file
+   my_cd()   -- created from a file, a ClearDemo
+   str_d()   -- same as above, but created via a StringIO object 
+Call by typing their name, (with parentheses), at the 
+ipython prompt, interact with the block, then call again
+to run the next block.
+'''

docs/man/ipcluster.1

@@ -0,0 +1,48 b''
+.TH IPCLUSTER 1 "October 28, 2008" "" ""
+.SH NAME
+\fBipcluster \- IPython parallel computing cluster control tool
+.SH SYNOPSIS
+.nf
+.fam C
+\fBipcluster\fP {\fmpiexec,local,mpirun,pbs,ssh\fP} [\fIoptions\fP]
+.fam T
+.fi
+.SH DESCRIPTION
+ipcluster is a control tool for IPython's parallel computing functions.
+
+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.
+.SH POSITIONAL ARGUMENTS
+
+The first positional argument should be one of: {mpiexec, local, mpirun, pbs,
+ssh}, which are the available cluster types.
+
+For detailed help on each, type "ipcluster TYPE --help". Briefly:
+
+  local         run a local cluster
+  mpirun        run a cluster using mpirun (mpiexec also works)
+  mpiexec       run a cluster using mpiexec (mpirun also works)
+  pbs           run a pbs cluster
+  ssh           run a cluster using ssh, should have ssh-keys setup
+.SH OPTIONS
+.TP
+.B
+\-h, \-\-help
+show help message and exit
+.SH EXAMPLE
+ipcluster local -n 4
+
+This command will start 4 IPython engines on the local computer.
+.SH SEE ALSO
+.BR ipython(1), ipcontroller(1), ipengine(1)
+.br
+.SH AUTHOR
+\fBipcluster\fP is a tool that ships with IPython, created by
+the IPython Development Team.
+.PP
+This manual page was written by Stephan Peijnik <[e-mail]>,
+for the Debian project (but may be used by others).  Modified by Fernando Perez
+<[e-mail]> for inclusion in IPython.

docs/man/ipcontroller.1

@@ -0,0 +1,87 b''
+.TH IPCONTROLLER 1 "October 29, 2008" "" ""
+.SH NAME
+\fBipcontroller \- IPython parallel computing controller control tool
+.SH SYNOPSIS
+.nf
+.fam C
+\fBipengine\fP [\fIoptions\fP]
+.fam T
+.fi
+.SH DESCRIPTION
+ipcontroller is a control tool for IPython's parallel computing functions.
+.SH OPTIONS
+.TP
+.B
+\-h, \-\-help
+show this help message and exit
+.TP
+.B
+\-\-client\-ip=CLIENT_IP
+the IP address or hostname the controller will listen on for
+client connections
+.TP
+.B
+\-\-client\-port=CLIENT_PORT
+the port the controller will listen on for client connections
+.TP
+.B
+\-\-client\-location=CLIENT_LOCATION
+hostname or ip for clients to connect to
+.TP
+.B
+\-x
+turn off all client security
+.TP
+.B
+\-\-client\-cert\-file=CLIENT_CERT_FILE
+file to store the client SSL certificate
+.TP
+.B
+\-\-task\-furl\-file=TASK_FURL_FILE
+file to store the FURL for task clients to connect with
+.TP
+.B
+\-\-multiengine\-furl\-file=MULTIENGINE_FURL_FILE
+file to store the FURL for multiengine clients to connect with
+.TP
+.B
+\-\-engine\-ip=ENGINE_IP
+the IP address or hostname the controller will listen on for engine connections
+.TP
+.B
+\-\-engine\-port=ENGINE_PORT
+the port the controller will listen on for engine connections
+.TP
+.B
+\-\-engine\-location=ENGINE_LOCATION
+the IP address or hostname for engine to connect to
+.TP
+.B
+\-y
+turn off all engine security
+.TP
+.B
+\-\-engine\-cert\-file=ENGINE_CERT_FILE
+file to store the engine SSL certificate
+.TP
+.B
+\-\-engine\-furl\-file=ENGINE_FURL_FILE
+file to store the FURL for engines to connect with
+.TP
+.B
+\-l LOGFILE, \-\-logfile=LOGFILE
+log file name (default is stdout)
+.TP
+.B
+\-r
+try to reuse all furl files
+.SH SEE ALSO
+.BR ipython(1), ipcluster(1), ipengine(1)
+.br
+.SH AUTHOR
+\fBipcontroller\fP is a tool that ships with IPython, created by
+the IPython Development Team.
+.PP
+This manual page was written by Stephan Peijnik <[e-mail]>,
+for the Debian project (but may be used by others).  Modified by Fernando Perez
+<[e-mail]> for inclusion in IPython.

docs/man/ipengine.1

@@ -0,0 +1,38 b''
+.TH IPENGINE 1 "October 28, 2008" "" ""
+.SH NAME
+\fBipengine \- IPython parallel computing engine control tool
+.SH SYNOPSIS
+.nf
+.fam C
+\fBipengine\fP [\fIoptions\fP]
+.fam T
+.fi
+.SH DESCRIPTION
+ipengine is a control tool for IPython's parallel computing functions.
+.SH OPTIONS
+.TP
+.B
+\-h, \-\-help
+show this help message and exit
+.TP
+.B
+\-\-furl\-file=FURL_FILE
+The filename containing the FURL of the controller
+.TP
+.B
+\-\-mpi=MPI
+How to enable MPI (mpi4py, pytrilions, or empty string to disable)
+.TP
+.B
+\-l LOGFILE, \-\-logfile=LOGFILE
+log file name (defaults to stdout)
+.SH SEE ALSO
+.BR ipython(1), ipcluster(1), ipcontroller(1)
+.br
+.SH AUTHOR
+\fBipengine\fP is a tool that ships with IPython, created by
+the IPython Development Team.
+.PP
+This manual page was written by Stephan Peijnik <[e-mail]>,
+for the Debian project (but may be used by others).  Modified by Fernando Perez
+<[e-mail]> for inclusion in IPython.

docs/man/ipython-wx.1

@@ -0,0 +1,25 b''
+.TH IPYTHON-WX 1 "October 29, 2008" "" ""
+.SH NAME
+\fBipython-wx \- Graphical frontend that embeds a multithreaded IPython Shell
+.SH SYNOPSIS
+.nf
+.fam C
+\fBipython-wx\fP
+.fam T
+.fi
+.SH DESCRIPTION
+ipython-wx is, compared to ipythonx, a more advanced graphical frontend
+to IPython. It is implemented using WxWidgets. 
+.SH OPTIONS
+.TP
+.B
+ipython-wx does not accept any command line options.
+.SH SEE ALSO
+.BR ipython(1), ipythonx(1)
+.br
+.SH AUTHOR
+\fBipython-wx\fP is a tool that ships with IPython, created by
+the IPython Development Team.
+.PP
+This manual page was written by Stephan Peijnik <[e-mail]>,
+for the Debian project (but may be used by others).

docs/man/ipythonx.1

@@ -0,0 +1,30 b''
+.TH IPYTHONX 1 "October 29, 2008" "" ""
+.SH NAME
+\fBipythonx \- Simple graphical frontend to IPython, using WxWidgets.
+.SH SYNOPSIS
+.nf
+.fam C
+\fBipengine\fP [\fIoptions\fP]
+.fam T
+.fi
+.SH DESCRIPTION
+ipythonx is a simple graphical frontend to IPython, using WxWidgets.
+.SH OPTIONS
+.TP
+.B
+\-h, \-\-help
+show this help message and exit
+.TP
+.B
+\-d, \-\-debug
+Enable debug messages for the wx frontend.
+look for config files and profiles in this directory
+.SH SEE ALSO
+.BR ipython(1), ipython-wx(1)
+.br
+.SH AUTHOR
+\fBipythonx\fP is a tool that ships with IPython, created by
+the IPython Development Team.
+.PP
+This manual page was written by Stephan Peijnik <[e-mail]>,
+for the Debian project (but may be used by others).

docs/man/irunner.1

@@ -0,0 +1,49 b''
+.TH IRUNNER 1 "April 24, 2007" "" ""
+.SH NAME
+\fBirunner \- interactive runner interface
+.SH SYNOPSIS
+.nf
+.fam C
+\fBirunner\fP [\fIoptions\fP] \fIfile_to_run\fP
+.fam T
+.fi
+.SH DESCRIPTION
+irunner is an interface to the various interactive runners
+available in IPython's \fBirunner\fP module. 
+.PP
+The already implemented runners are listed below; adding
+one for a new program is a trivial task, see the source
+for examples.
+.SH OPTIONS
+.TP
+.B
+\-h, \-\-help
+show this help message and exit
+.TP
+.B
+\-\-ipython
+IPython interactive runner (default).
+.TP
+.B
+\-\-python
+Python interactive runner.
+.TP
+.B
+\-\-sage
+SAGE interactive runner.
+.SH EXAMPLE
+irunner.py \-\-python \-\- \-\-help
+will pass \-\-help to the python runner.
+Similarly,
+irunner.py \-\-ipython \-\- \-\-interact script.ipy
+.SH SEE ALSO
+.BR ipython(1)
+.br
+.SH AUTHOR
+\fBirunner\fP is an extension of Ken Schutte <kschutte-AT-csail.mit.edu>'s
+script contributed on the ipython-user list:
+http://scipy.net/pipermail/ipython-user/2006-May/001705.html
+.PP
+This manual page was written by Bernd Zeimetz <[e-mail]>, for the Debian
+project (but may be used by others).  Modified by Fernando Perez
+<[e-mail]> for inclusion in IPython.

tools/build_release

@@ -0,0 +1,42 b''
+#!/usr/bin/env python
+"""IPython release build script.
+"""
+from toollib import *
+
+# Get main ipython dir, this will raise if it doesn't pass some checks
+ipdir = get_ipdir()
+cd(ipdir)
+
+# Load release info
+execfile(pjoin('IPython','core','release.py'))
+
+# Check that everything compiles
+compile_tree()
+
+# Cleanup
+for d in ['build','dist',pjoin('docs','build'),pjoin('docs','dist')]:
+    if os.path.isdir(d):
+        remove_tree(d)
+
+# Build source and binary distros
+c('./setup.py sdist --formats=gztar')
+
+# Build version-specific RPMs, where we must use the --python option to ensure
+# that the resulting RPM is really built with the requested python version (so
+# things go to lib/python2.X/...)
+c("python2.5 ./setup.py bdist_rpm --binary-only --release=py25 "
+  "--python=/usr/bin/python2.5")
+c("python2.6 ./setup.py bdist_rpm --binary-only --release=py26 "
+  "--python=/usr/bin/python2.6")
+
+# Build eggs
+c('python2.5 ./setupegg.py bdist_egg')
+c('python2.6 ./setupegg.py bdist_egg')
+
+# Call the windows build separately, so that the extra Windows scripts don't
+# get pulled into Unix builds (setup.py has code which checks for
+# bdist_wininst)
+c("python setup.py bdist_wininst --install-script=ipython_win_post_install.py")
+
+# Change name so retarded Vista runs the installer correctly
+c("rename 's/linux-i686/win32-setup/' dist/*.exe")

tools/toollib.py

@@ -0,0 +1,55 b''
+"""Various utilities common to IPython release and maintenance tools.
+"""
+# Library imports
+import os
+import sys
+
+from distutils.dir_util import remove_tree
+
+# Useful shorthands
+pjoin = os.path.join
+cd = os.chdir
+
+# Utility functions
+def c(cmd):
+    """Run system command, raise SystemExit if it returns an error."""
+    print "$",cmd
+    stat = os.system(cmd)
+    #stat = 0  # Uncomment this and comment previous to run in debug mode
+    if stat:
+        raise SystemExit("Command %s failed with code: %s" % (cmd, stat))
+
+
+def get_ipdir():
+    """Get IPython directory from command line, or assume it's the one above."""
+
+    # Initialize arguments and check location
+    try:
+        ipdir = sys.argv[1]
+    except IndexError:
+        ipdir = '..'
+
+    ipdir = os.path.abspath(ipdir)
+
+    cd(ipdir)
+    if not os.path.isdir('IPython') and os.path.isfile('setup.py'):
+        raise SystemExit('Invalid ipython directory: %s' % ipdir)
+    return ipdir
+
+
+def compile_tree():
+    """Compile all Python files below current directory."""
+    vstr = '.'.join(map(str,sys.version_info[:2]))
+    stat = os.system('python %s/lib/python%s/compileall.py .' %
+                     (sys.prefix,vstr))
+    if stat:
+        msg = '*** ERROR: Some Python files in tree do NOT compile! ***\n'
+        msg += 'See messages above for the actual file that produced it.\n'
+        raise SystemExit(msg)
+
+
+def version_info():
+    """Return bzr version info as a dict."""
+    out = os.popen('bzr version-info')
+    pairs = (l.split(':',1) for l in out)
+    return dict(((k,v.strip()) for (k,v) in pairs)) 

IPython/core/crashhandler.py

@@ -190,7 +190,7 b' class IPythonCrashHandler(CrashHandler):'
     def __init__(self,IP):
 
         # Set here which of the IPython authors should be listed as contact
-        AUTHOR_CONTACT = 'Ville'
+        AUTHOR_CONTACT = 'Fernando'
         
         # Set argument defaults
         app_name = 'IPython'

IPython/core/hooks.py

@@ -43,8 +43,9 b' somewhere in your configuration files or ipython command line.'
 
 from IPython.core import ipapi
 
-import os,bisect
-from IPython.utils.genutils import Term,shell
+import os, bisect
+import sys
+from IPython.utils.genutils import Term, shell
 from pprint import PrettyPrinter
 
 # List here all the default hooks.  For now it's just the editor functions
@@ -53,7 +54,8 b' from pprint import PrettyPrinter'
 __all__ = ['editor', 'fix_error_editor', 'synchronize_with_editor', 'result_display',
            'input_prefilter', 'shutdown_hook', 'late_startup_hook',
            'generate_prompt', 'generate_output_prompt','shell_hook',
-           'show_in_pager','pre_prompt_hook', 'pre_runcode_hook']
+           'show_in_pager','pre_prompt_hook', 'pre_runcode_hook',
+           'clipboard_get']
 # vds: <<
 
 pformat = PrettyPrinter().pformat
@@ -109,7 +111,7 b' def fix_error_editor(self,filename,linenum,column,msg):'
 
 # vds: >>
 def synchronize_with_editor(self, filename, linenum, column):
-	pass
+        pass
 # vds: <<
 
 class CommandChainDispatcher:
@@ -243,5 +245,22 b' def pre_prompt_hook(self):'
 def pre_runcode_hook(self):
     """ Executed before running the (prefiltered) code in IPython """
     return None
-    
 
+def clipboard_get(self):
+    """ Get text from the clipboard.
+    """
+    from IPython.lib.clipboard import (
+        osx_clipboard_get, tkinter_clipboard_get, 
+        win32_clipboard_get
+    )
+    if sys.platform == 'win32':
+        chain = [win32_clipboard_get, tkinter_clipboard_get]
+    elif sys.platform == 'darwin':
+        chain = [osx_clipboard_get, tkinter_clipboard_get]
+    else:
+        chain = [tkinter_clipboard_get]
+    dispatcher = CommandChainDispatcher()
+    for func in chain:
+        dispatcher.add(func)
+    text = dispatcher()
+    return text

IPython/core/iplib.py

@@ -927,8 +927,8 b' class InteractiveShell(object,Magic):'
         Certain history lists are also initialized here, as they effectively
         act as user namespaces.
 
-        Note
-        ----
+        Notes
+        -----
         All data structures here are only filled in, they are NOT reset by this
         method.  If they were not empty before, data will simply be added to
         therm.
@@ -1315,8 +1315,8 b' class InteractiveShell(object,Magic):'
     def user_setup(self,ipythondir,rc_suffix,mode='install'):
         """Install the user configuration directory.
 
-        Note
-        ----
+        Notes
+        -----
         DEPRECATED: use the top-level user_setup() function instead.
         """
         return user_setup(ipythondir,rc_suffix,mode)

IPython/core/magic.py

@@ -1707,7 +1707,12 b' Currently the magic system has the following functions:\\n"""'
                     # (leaving dangling references).
                     self.shell.cache_main_mod(prog_ns,filename)
                     # update IPython interactive namespace
-                    del prog_ns['__name__']
+
+                    # Some forms of read errors on the file may mean the
+                    # __name__ key was never set; using pop we don't have to
+                    # worry about a possible KeyError.
+                    prog_ns.pop('__name__', None)
+
                     self.shell.user_ns.update(prog_ns)
         finally:
             # It's a bit of a mystery why, but __builtins__ can change from
@@ -3262,6 +3267,61 b' Defaulting color scheme to \'NoColor\'"""'
         page(self.shell.pycolorize(cont),
              screen_lines=self.shell.rc.screen_length)
 
+    def _rerun_pasted(self):
+        """ Rerun a previously pasted command.
+        """
+        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
+
+    def _get_pasted_lines(self, sentinel):
+        """ Yield pasted lines until the user enters the given sentinel value.
+        """
+        from IPython.core import iplib
+        print "Pasting code; enter '%s' alone on the line to stop." % sentinel
+        while True:
+            l = iplib.raw_input_original(':')
+            if l == sentinel:
+                return
+            else:
+                yield l
+
+    def _strip_pasted_lines_for_code(self, raw_lines):
+        """ Strip non-code parts of a sequence of lines to return a block of
+        code.
+        """
+        # 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)
+        
+        lines = []
+        for l in raw_lines:
+            for pat in strip_from_start: 
+                l = pat.sub('',l)
+            lines.append(l)
+                         
+        block = "\n".join(lines) + '\n'
+        #print "block:\n",block
+        return block
+
+    def _execute_block(self, block, par):
+        """ Execute a block, or store it in a variable, per the user's request.
+        """
+        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_cpaste(self, parameter_s=''):
         """Allows you to paste & execute a pre-formatted code block from clipboard.
         
@@ -3287,50 +3347,60 b' Defaulting color scheme to \'NoColor\'"""'
         will be what was just pasted.
         
         IPython statements (magics, shell escapes) are not supported (yet).
+
+        See also
+        --------
+        paste: automatically pull code from clipboard.
         """
+        
         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
+            self._rerun_pasted()
             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'^\++',
-                     ]
+        block = self._strip_pasted_lines_for_code(
+            self._get_pasted_lines(sentinel))
 
-        strip_from_start = map(re.compile,strip_re)
+        self._execute_block(block, par)
+
+    def magic_paste(self, parameter_s=''):
+        """Allows you to paste & execute a pre-formatted code block from clipboard.
         
-        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
-            
+        The text is pulled directly from the clipboard without user
+        intervention.
+
+        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. '%paste foo'.
+        This assigns the pasted block to variable 'foo' as string, without 
+        dedenting or executing it (preceding >>> and + is still stripped)
+        
+        '%paste -r' re-executes the block previously entered by cpaste.
+        
+        IPython statements (magics, shell escapes) are not supported (yet).
+
+        See also
+        --------
+        cpaste: manually paste code into terminal until you mark its end.
+        """
+        opts,args = self.parse_options(parameter_s,'r:',mode='string')
+        par = args.strip()
+        if opts.has_key('r'):
+            self._rerun_pasted()
+            return
+
+        text = self.shell.hooks.clipboard_get()
+        block = self._strip_pasted_lines_for_code(text.splitlines())
+        self._execute_block(block, par)
+
     def magic_quickref(self,arg):
         """ Show a quick reference sheet """
         import IPython.core.usage

IPython/core/release.py

@@ -2,8 +2,8 b''
 """Release data for the IPython project."""
 
 #*****************************************************************************
-#       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
-#
+#       Copyright (C) 2008-2009  The IPython Development Team
+#       Copyright (C) 2001-2008 Fernando Perez <[e-mail]>
 #       Copyright (c) 2001 Janko Hauser <[e-mail]> and Nathaniel Gray
 #       <[e-mail]>
 #
@@ -20,10 +20,10 b" name = 'ipython'"
 # because bdist_rpm does not accept dashes (an RPM) convention, and
 # bdist_deb does not accept underscores (a Debian convention).
 
-development = True    # change this to False to do a release
+development = False    # change this to False to do a release
 version_base = '0.10'
 branch = 'ipython'
-revision = '1163'
+revision = '1188'
 
 if development:
     if branch == 'ipython':
@@ -100,7 +100,7 b' site <http://launchpad.net/ipython>`_.'
 
 license = 'BSD'
 
-authors = {'Fernando' : ('Fernando Perez','[e-mail]'),
+authors = {'Fernando' : ('Fernando Perez','[e-mail]'),
            'Janko'    : ('Janko Hauser','[e-mail]'),
            'Nathan'   : ('Nathaniel Gray','[e-mail]'),
            'Ville'    : ('Ville Vainio','[e-mail]'),

IPython/core/tests/test_magic.py

@@ -25,14 +25,14 b' def test_rehashx():'
     _ip.magic('rehashx')
     # Practically ALL ipython development systems will have more than 10 aliases
 
-    assert len(_ip.IP.alias_table) > 10
+    yield (nt.assert_true, len(_ip.IP.alias_table) > 10)
     for key, val in _ip.IP.alias_table.items():
         # we must strip dots from alias names
-        assert '.' not in key
+        nt.assert_true('.' not in key)
 
     # rehashx must fill up syscmdlist
     scoms = _ip.db['syscmdlist']
-    assert len(scoms) > 10
+    yield (nt.assert_true, len(scoms) > 10)
 
 
 def doctest_hist_f():
@@ -42,7 +42,7 b' def doctest_hist_f():'
 
     In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-')
 
-    In [11]: %history -n -f $tfile 3
+    In [11]: %hist -n -f $tfile 3
     """
 
 
@@ -51,9 +51,12 b' def doctest_hist_r():'
 
     XXX - This test is not recording the output correctly.  Not sure why...
 
+    In [20]: 'hist' in _ip.IP.lsmagic()
+    Out[20]: True
+
     In [6]: x=1
 
-    In [7]: hist -n -r 2
+    In [7]: %hist -n -r 2
     x=1  # random
     hist -n -r 2  # random
     """
@@ -94,12 +97,13 b' def test_shist():'
     
 @dec.skipif_not_numpy
 def test_numpy_clear_array_undec():
+    from IPython.extensions import clearcmd
+
     _ip.ex('import numpy as np')
     _ip.ex('a = np.empty(2)')
-    
-    yield nt.assert_true,'a' in _ip.user_ns
+    yield (nt.assert_true, 'a' in _ip.user_ns)
     _ip.magic('clear array')
-    yield nt.assert_false,'a' in _ip.user_ns
+    yield (nt.assert_false, 'a' in _ip.user_ns)
     
 
 @dec.skip()
@@ -159,7 +163,6 b' def doctest_run_ns2():'
     tclass.py: deleting object: C-first_pass
     """
 
[e-mail]_win32
 def doctest_run_builtins():
     """Check that %run doesn't damage __builtins__ via a doctest.
 
@@ -172,24 +175,34 b' def doctest_run_builtins():'
 
     In [2]: bid1 = id(__builtins__)
 
-    In [3]: f = tempfile.NamedTemporaryFile()
+    In [3]: fname = tempfile.mkstemp()[1]
+
+    In [3]: f = open(fname,'w')
 
     In [4]: f.write('pass\\n')
 
     In [5]: f.flush()
 
-    In [6]: print 'B1:',type(__builtins__)
-    B1: <type 'module'>
+    In [6]: print type(__builtins__)
+    <type 'module'>
 
-    In [7]: %run $f.name
+    In [7]: %run "$fname"
+
+    In [7]: f.close()
 
     In [8]: bid2 = id(__builtins__)
 
-    In [9]: print 'B2:',type(__builtins__)
-    B2: <type 'module'>
+    In [9]: print type(__builtins__)
+    <type 'module'>
 
     In [10]: bid1 == bid2
     Out[10]: True
+
+    In [12]: try:
+       ....:     os.unlink(fname)
+       ....: except:
+       ....:     pass
+       ....: 
     """
 
 # For some tests, it will be handy to organize them in a class with a common
@@ -199,23 +212,18 b' class TestMagicRun(object):'
 
     def setup(self):
         """Make a valid python temp file."""
-        f = tempfile.NamedTemporaryFile()
+        fname = tempfile.mkstemp()[1]
+        f = open(fname,'w')
         f.write('pass\n')
         f.flush()
         self.tmpfile = f
+        self.fname = fname
 
     def run_tmpfile(self):
         # This fails on Windows if self.tmpfile.name has spaces or "~" in it.
         # See below and ticket https://bugs.launchpad.net/bugs/366353
-        _ip.magic('run %s' % self.tmpfile.name)
-
-    # See https://bugs.launchpad.net/bugs/366353
-    @dec.skip_if_not_win32
-    def test_run_tempfile_path(self):
-        tt.assert_equals(True,False,"%run doesn't work with tempfile paths on win32.")
+        _ip.magic('run "%s"' % self.fname)
 
-    # See https://bugs.launchpad.net/bugs/366353
-    @dec.skip_win32
     def test_builtins_id(self):
         """Check that %run doesn't damage __builtins__ """
 
@@ -225,8 +233,6 b' class TestMagicRun(object):'
         bid2 = id(_ip.user_ns['__builtins__'])
         tt.assert_equals(bid1, bid2)
 
-    # See https://bugs.launchpad.net/bugs/366353
-    @dec.skip_win32
     def test_builtins_type(self):
         """Check that the type of __builtins__ doesn't change with %run.
         
@@ -237,8 +243,6 b' class TestMagicRun(object):'
         self.run_tmpfile()
         tt.assert_equals(type(_ip.user_ns['__builtins__']),type(sys))
 
-    # See https://bugs.launchpad.net/bugs/366353
-    @dec.skip_win32
     def test_prompts(self):
         """Test that prompts correctly generate after %run"""
         self.run_tmpfile()
@@ -247,3 +251,52 b' class TestMagicRun(object):'
 
     def teardown(self):
         self.tmpfile.close()
+        try:
+            os.unlink(self.fname)
+        except:
+            # On Windows, even though we close the file, we still can't delete
+            # it.  I have no clue why
+            pass
+
+# Multiple tests for clipboard pasting
+def test_paste():
+
+    def paste(txt):
+        hooks.clipboard_get = lambda : txt
+        _ip.magic('paste')
+
+    # Inject fake clipboard hook but save original so we can restore it later
+    hooks = _ip.IP.hooks
+    user_ns = _ip.user_ns
+    original_clip = hooks.clipboard_get
+
+    try:
+        # This try/except with an emtpy except clause is here only because
+        # try/yield/finally is invalid syntax in Python 2.4.  This will be
+        # removed when we drop 2.4-compatibility, and the emtpy except below
+        # will be changed to a finally.
+
+        # Run tests with fake clipboard function
+        user_ns.pop('x', None)
+        paste('x=1')
+        yield (nt.assert_equal, user_ns['x'], 1)
+
+        user_ns.pop('x', None)
+        paste('>>> x=2')
+        yield (nt.assert_equal, user_ns['x'], 2)
+
+        paste("""
+        >>> x = [1,2,3]
+        >>> y = []
+        >>> for i in x:
+        ...     y.append(i**2)
+        ...
+        """)
+        yield (nt.assert_equal, user_ns['x'], [1,2,3])
+        yield (nt.assert_equal, user_ns['y'], [1,4,9])
+    except:
+        pass
+
+    # This should be in a finally clause, instead of the bare except above.
+    # Restore original hook
+    hooks.clipboard_get = original_clip

IPython/core/ultratb.py

@@ -91,7 +91,7 b' from inspect import getsourcefile, getfile, getmodule,\\'
 # IPython's own modules
 # Modified pdb which doesn't damage IPython's readline handling
 from IPython.utils import PyColorize
-from IPython.core import debugger
+from IPython.core import debugger, ipapi
 from IPython.utils.ipstruct import Struct
 from IPython.core.excolors import exception_colors
 from IPython.utils.genutils import Term,uniq_stable,error,info
@@ -268,10 +268,12 b' def _formatTracebackLines(lnum, index, lines, Colors, lvals=None,scheme=None):'
 
     # This lets us get fully syntax-highlighted tracebacks.
     if scheme is None:
-        try:
-            scheme = __IPYTHON__.rc.colors
-        except:
+        ipinst = ipapi.get()
+        if ipinst is not None:
+            scheme = ipinst.IP.rc.colors
+        else:
             scheme = DEFAULT_SCHEME
+
     _line_format = _parser.format2
 
     for line in lines:
@@ -490,7 +492,9 b' class ListTB(TBTools):'
 
         # vds:>>
         if have_filedata:
-            __IPYTHON__.hooks.synchronize_with_editor(filename, lineno, 0)
+            ipinst = ipapi.get()
+            if ipinst is not None:
+                ipinst.IP.hooks.synchronize_with_editor(filename, lineno, 0)
         # vds:<<
 
         return list
@@ -810,7 +814,9 b' class VerboseTB(TBTools):'
              filepath, lnum = records[-1][1:3]
              #print "file:", str(file), "linenb", str(lnum) # dbg
              filepath = os.path.abspath(filepath)
-             __IPYTHON__.hooks.synchronize_with_editor(filepath, lnum, 0)
+             ipinst = ipapi.get()
+             if ipinst is not None:
+                 ipinst.IP.hooks.synchronize_with_editor(filepath, lnum, 0)
         # vds: <<
                 
         # return all our info assembled as a single string

IPython/deathrow/twshell.py

@@ -2,6 +2,9 b''
 
 XXX - This module is missing proper docs.
 """
+# Tell nose to skip this module
+__test__ = {}
+
 import sys
 
 from twisted.internet import reactor, threads

IPython/extensions/ipy_autoreload.py

@@ -1,7 +1,7 b''
 """
 IPython extension: autoreload modules before executing the next line
 
-Try:: 
+Try::
 
     %autoreload?
 
@@ -32,7 +32,7 b' PY_COMPILED_EXT = _get_compiled_ext()'
 class ModuleReloader(object):
     failed = {}
     """Modules that failed to reload: {module: mtime-on-failed-reload, ...}"""
-    
+
     modules = {}
     """Modules specially marked as autoreloadable."""
 
@@ -44,39 +44,39 b' class ModuleReloader(object):'
 
     old_objects = {}
     """(module-name, name) -> weakref, for replacing old code objects"""
-    
+
     def check(self, check_all=False):
         """Check whether some modules need to be reloaded."""
-        
+
         if check_all or self.check_all:
             modules = sys.modules.keys()
         else:
             modules = self.modules.keys()
-        
+
         for modname in modules:
             m = sys.modules.get(modname, None)
 
             if modname in self.skip_modules:
                 continue
-            
+
             if not hasattr(m, '__file__'):
                 continue
-            
+
             if m.__name__ == '__main__':
                 # we cannot reload(__main__)
                 continue
-            
+
             filename = m.__file__
             dirname = os.path.dirname(filename)
             path, ext = os.path.splitext(filename)
-            
+
             if ext.lower() == '.py':
                 ext = PY_COMPILED_EXT
                 filename = os.path.join(dirname, path + PY_COMPILED_EXT)
-            
+
             if ext != PY_COMPILED_EXT:
                 continue
-            
+
             try:
                 pymtime = os.stat(filename[:-1]).st_mtime
                 if pymtime <= os.stat(filename).st_mtime:
@@ -85,7 +85,7 b' class ModuleReloader(object):'
                     continue
             except OSError:
                 continue
-            
+
             try:
                 superreload(m, reload, self.old_objects)
                 if filename[:-1] in self.failed:
@@ -118,12 +118,12 b' def update_class(old, new):'
             new_obj = getattr(new, key)
         except AttributeError:
             # obsolete attribute: remove it
-            try: 
+            try:
                 delattr(old, key)
             except (AttributeError, TypeError):
                 pass
             continue
-        
+
         if update_generic(old_obj, new_obj): continue
 
         try:
@@ -146,9 +146,9 b' UPDATE_RULES = ['
     (lambda a, b: isinstance2(a, b, types.TypeType),
      update_class),
     (lambda a, b: isinstance2(a, b, types.FunctionType),
-     update_function), 
+     update_function),
     (lambda a, b: isinstance2(a, b, property),
-     update_property), 
+     update_property),
     (lambda a, b: isinstance2(a, b, types.MethodType),
      lambda a, b: update_function(a.im_func, b.im_func)),
 ]
@@ -168,15 +168,15 b' class StrongRef(object):'
 
 def superreload(module, reload=reload, old_objects={}):
     """Enhanced version of the builtin reload function.
-   
+
     superreload remembers objects previously in the module, and
 
     - upgrades the class dictionary of every old class in the module
     - upgrades the code object of every old function and method
     - clears the module's namespace before reloading
-    
+
     """
-    
+
     # collect old objects in the module
     for name, obj in module.__dict__.items():
         if not hasattr(obj, '__module__') or obj.__module__ != module.__name__:
@@ -199,7 +199,7 b' def superreload(module, reload=reload, old_objects={}):'
     except (TypeError, AttributeError, KeyError):
         pass
     module = reload(module)
-    
+
     # iterate over all objects and update functions & classes
     for name, new_obj in module.__dict__.items():
         key = (module.__name__, name)
@@ -248,40 +248,46 b' def disable_autoreload():'
 
 def autoreload_f(self, parameter_s=''):
     r""" %autoreload => Reload modules automatically
-    
+
     %autoreload
     Reload all modules (except those excluded by %aimport) automatically now.
-    
+
+    %autoreload 0
+    Disable automatic reloading.
+
     %autoreload 1
     Reload all modules imported with %aimport every time before executing
     the Python code typed.
-    
+
     %autoreload 2
     Reload all modules (except those excluded by %aimport) every time
     before executing the Python code typed.
-    
-    Reloading Python modules in a reliable way is in general difficult,
-    and unexpected things may occur. %autoreload tries to work
-    around common pitfalls by replacing code objects of functions
-    previously in the module with new versions. This makes the following
-    things to work:
+
+    Reloading Python modules in a reliable way is in general
+    difficult, and unexpected things may occur. %autoreload tries to
+    work around common pitfalls by replacing function code objects and
+    parts of classes previously in the module with new versions. This
+    makes the following things to work:
 
     - Functions and classes imported via 'from xxx import foo' are upgraded
       to new versions when 'xxx' is reloaded.
+
     - Methods and properties of classes are upgraded on reload, so that
       calling 'c.foo()' on an object 'c' created before the reload causes
       the new code for 'foo' to be executed.
-    
+
     Some of the known remaining caveats are:
-    
+
     - Replacing code objects does not always succeed: changing a @property
       in a class to an ordinary method or a method to a member variable
       can cause problems (but in old objects only).
+
     - Functions that are removed (eg. via monkey-patching) from a module
       before it is reloaded are not upgraded.
+
     - C extension modules cannot be reloaded, and so cannot be
       autoreloaded.
-    
+
     """
     if parameter_s == '':
         reloader.check(True)
@@ -307,7 +313,7 b" def aimport_f(self, parameter_s=''):"
     Mark module 'foo' to not be autoreloaded for %autoreload 1
 
     """
-    
+
     modname = parameter_s
     if not modname:
         to_reload = reloader.modules.keys()
@@ -329,12 +335,15 b" def aimport_f(self, parameter_s=''):"
         except KeyError: pass
         reloader.modules[modname] = True
 
-        mod = __import__(modname)
-        ip.to_user_ns({modname: mod})
+        # Inject module to user namespace; handle also submodules properly
+        __import__(modname)
+        basename = modname.split('.')[0]
+        mod = sys.modules[basename]
+        ip.to_user_ns({basename: mod})
 
 def init():
     ip.expose_magic('autoreload', autoreload_f)
     ip.expose_magic('aimport', aimport_f)
     ip.set_hook('pre_runcode_hook', runcode_hook)
-    
+
 init()

IPython/frontend/asyncfrontendbase.py

@@ -3,6 +3,9 b' Base front end class for all async frontends.'
 """
 __docformat__ = "restructuredtext en"
 
+# Tell nose to skip this module
+__test__ = {}
+
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
@@ -10,20 +13,25 b' __docformat__ = "restructuredtext en"'
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
-
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
+# Third-party
+from twisted.python.failure import Failure
+from zope.interface import implements, classProvides
+
+# From IPython
 from IPython.external import guid
 
-from zope.interface import Interface, Attribute, implements, classProvides
-from twisted.python.failure import Failure
-from IPython.frontend.frontendbase import (
-    FrontEndBase, IFrontEnd, IFrontEndFactory)
+from IPython.frontend.frontendbase import (FrontEndBase, IFrontEnd,
+                                           IFrontEndFactory)
 from IPython.kernel.core.history import FrontEndHistory
 from IPython.kernel.engineservice import IEngineCore
 
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
 
 class AsyncFrontEndBase(FrontEndBase):
     """
@@ -41,8 +49,7 b' class AsyncFrontEndBase(FrontEndBase):'
                 self.history = FrontEndHistory(input_cache=[''])
         else:
             self.history = history
-    
-    
+        
     def execute(self, block, blockID=None):
         """Execute the block and return the deferred result.
         
@@ -73,5 +80,3 b' class AsyncFrontEndBase(FrontEndBase):'
             errback=self.render_error)
         
         return d
-    
-

IPython/frontend/cocoa/plugin/setup.py

@@ -19,17 +19,17 b' __docformat__ = "restructuredtext en"'
 from setuptools import setup
 
 infoPlist = dict(
-	CFBundleDevelopmentRegion='English',
-	CFBundleIdentifier='org.scipy.ipython.cocoa_frontend',
-	NSPrincipalClass='IPythonCocoaController',
+        CFBundleDevelopmentRegion='English',
+        CFBundleIdentifier='org.scipy.ipython.cocoa_frontend',
+        NSPrincipalClass='IPythonCocoaController',
 )
 
 setup(
-	plugin=['IPythonCocoaFrontendLoader.py'],
+        plugin=['IPythonCocoaFrontendLoader.py'],
     setup_requires=['py2app'],
-	options=dict(py2app=dict(
-		plist=infoPlist,
-		site_packages=True,
-		excludes=['IPython','twisted','PyObjCTools']
-	)),
+        options=dict(py2app=dict(
+                plist=infoPlist,
+                site_packages=True,
+                excludes=['IPython','twisted','PyObjCTools']
+        )),
 )
  No newline at end of file

IPython/frontend/linefrontendbase.py

@@ -97,8 +97,8 b' class LineFrontEndBase(FrontEndBase):'
         ----------
         line : string
         
-        Result
-        ------
+        Returns
+        -------
         The replacement for the line and the list of possible completions.
         """
         completions = self.shell.complete(line)

IPython/frontend/prefilterfrontend.py

@@ -65,8 +65,8 b' class PrefilterFrontEnd(LineFrontEndBase):'
     debug = False
     
     def __init__(self, ipython0=None, argv=None, *args, **kwargs):
-        """ Parameters:
-            -----------
+        """ Parameters
+            ----------
 
             ipython0: an optional ipython0 instance to use for command
             prefiltering and completion.

IPython/frontend/tests/test_asyncfrontendbase.py

@@ -3,6 +3,9 b''
 """This file contains unittests for the asyncfrontendbase module."""
 
 __docformat__ = "restructuredtext en"
+                                                                            
+# Tell nose to skip this module
+__test__ = {}
 
 #---------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team                         
@@ -10,20 +13,21 b' __docformat__ = "restructuredtext en"'
 #  Distributed under the terms of the BSD License.  The full license is in  
 #  the file COPYING, distributed as part of this software.                  
 #---------------------------------------------------------------------------
-                                                                            
+
 #---------------------------------------------------------------------------
 # Imports                                                                   
 #---------------------------------------------------------------------------
 
-# Tell nose to skip this module
-__test__ = {}
-
 from twisted.trial import unittest
+    
 from IPython.frontend.asyncfrontendbase import AsyncFrontEndBase
 from IPython.frontend import frontendbase 
 from IPython.kernel.engineservice import EngineService
 from IPython.testing.parametric import Parametric, parametric
 
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
 
 class FrontEndCallbackChecker(AsyncFrontEndBase):
     """FrontEndBase subclass for checking callbacks"""
@@ -106,4 +110,3 b' class TestAsyncFrontendBase(unittest.TestCase):'
     def test_history_returns_none_at_startup(self):        
         self.assert_(self.fb.get_history_previous("")==None)
         self.assert_(self.fb.get_history_next()==None)
-

IPython/frontend/tests/test_prefilterfrontend.py

@@ -15,6 +15,7 b' __docformat__ = "restructuredtext en"'
 from copy import copy, deepcopy
 from cStringIO import StringIO
 import string
+import sys
 
 from nose.tools import assert_equal
 
@@ -23,22 +24,6 b' 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('')
@@ -72,17 +57,34 b' def isolate_ipython0(func):'
         with arguments.
     """
     def my_func():
-        iplib = get_ipython0()
-        if iplib is None:
+        ip0 = get_ipython0()
+        if ip0 is None:
             return func()
-        ipython0 = iplib.IP
-        global_ns = safe_deepcopy(ipython0.user_global_ns)
-        user_ns = safe_deepcopy(ipython0.user_ns)
+        # We have a real ipython running...
+        user_ns = ip0.IP.user_ns
+        user_global_ns = ip0.IP.user_global_ns
+
+        # Previously the isolation was attempted with a deep copy of the user
+        # dicts, but we found cases where this didn't work correctly. I'm not
+        # quite sure why, but basically it did damage the user namespace, such
+        # that later tests stopped working correctly.  Instead we use a simpler
+        # approach, just computing the list of added keys to the namespace and
+        # eliminating those afterwards.  Existing keys that may have been
+        # modified remain modified.  So far this has proven to be robust.
+
+        # Compute set of old local/global keys
+        old_locals = set(user_ns.keys())
+        old_globals = set(user_global_ns.keys())
         try:
             out = func()
         finally:
-            ipython0.user_ns = user_ns
-            ipython0.user_global_ns = global_ns
+            # Find new keys, and if any, remove them
+            new_locals = set(user_ns.keys()) - old_locals
+            new_globals = set(user_global_ns.keys()) - old_globals
+            for k in new_locals:
+                del user_ns[k]
+            for k in new_globals:
+                del user_global_ns[k]
         # Undo the hack at creation of PrefilterFrontEnd
         from IPython.core import iplib
         iplib.InteractiveShell.isthreaded = False
@@ -97,7 +99,7 b' def test_execution():'
     """ Test execution of a command.
     """
     f = TestPrefilterFrontEnd()
-    f.input_buffer = 'print 1'
+    f.input_buffer = 'print(1)'
     f._on_enter()
     out_value = f.out.getvalue()
     assert_equal(out_value, '1\n')
@@ -228,7 +230,14 b' def test_completion_indexing():'
     f._on_enter()
     f.input_buffer = 'a[0].'
     f.complete_current_input()
-    assert_equal(f.input_buffer, 'a[0].__')
+
+    if sys.version_info[:2] >= (2,6):
+        # In Python 2.6, ints picked up a few non __ methods, so now there are
+        # no completions.
+        assert_equal(f.input_buffer, 'a[0].')
+    else:
+        # Right answer for 2.4/2.5
+        assert_equal(f.input_buffer, 'a[0].__')
 
 
 @isolate_ipython0
@@ -238,8 +247,13 b' def test_completion_equal():'
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'a=1.'
     f.complete_current_input()
-    assert_equal(f.input_buffer, 'a=1.__')
-
+    if sys.version_info[:2] >= (2,6):
+        # In Python 2.6, ints picked up a few non __ methods, so now there are
+        # no completions.
+        assert_equal(f.input_buffer, 'a=1.')
+    else:
+        # Right answer for 2.4/2.5
+        assert_equal(f.input_buffer, 'a=1.__')
 
 
 if __name__ == '__main__':

IPython/frontend/wx/console_widget.py

@@ -447,29 +447,30 b' class ConsoleWidget(editwindow.EditWindow):'
         #  different callbacks share local variables?
 
         # Intercept some specific keys.
-        if event.KeyCode == ord('L') and event.ControlDown() :
+        key_code = event.GetKeyCode()
+        if key_code == ord('L') and event.ControlDown() :
             self.scroll_to_bottom()
-        elif event.KeyCode == ord('K') and event.ControlDown() :
+        elif key_code == ord('K') and event.ControlDown() :
             self.input_buffer = ''
-        elif event.KeyCode == ord('A') and event.ControlDown() :
+        elif key_code == ord('A') and event.ControlDown() :
             self.GotoPos(self.GetLength())
             self.SetSelectionStart(self.current_prompt_pos)
             self.SetSelectionEnd(self.GetCurrentPos())
             catched = True
-        elif event.KeyCode == ord('E') and event.ControlDown() :
+        elif key_code == ord('E') and event.ControlDown() :
             self.GotoPos(self.GetLength())
             catched = True
-        elif event.KeyCode == wx.WXK_PAGEUP:
+        elif key_code == wx.WXK_PAGEUP:
             self.ScrollPages(-1)
-        elif event.KeyCode == wx.WXK_PAGEDOWN:
+        elif key_code == wx.WXK_PAGEDOWN:
             self.ScrollPages(1)
-        elif event.KeyCode == wx.WXK_HOME:
+        elif key_code == wx.WXK_HOME:
             self.GotoPos(self.GetLength())
-        elif event.KeyCode == wx.WXK_END:
+        elif key_code == wx.WXK_END:
             self.GotoPos(self.GetLength())
-        elif event.KeyCode == wx.WXK_UP and event.ShiftDown():
+        elif key_code == wx.WXK_UP and event.ShiftDown():
             self.ScrollLines(-1)
-        elif event.KeyCode == wx.WXK_DOWN and event.ShiftDown():
+        elif key_code == wx.WXK_DOWN and event.ShiftDown():
             self.ScrollLines(1)
         else:
             catched = False
@@ -477,13 +478,12 b' class ConsoleWidget(editwindow.EditWindow):'
         if self.AutoCompActive():
             event.Skip()
         else:
-            if event.KeyCode in (13, wx.WXK_NUMPAD_ENTER) and \
-                                event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN,
-                                                    wx.MOD_SHIFT):
+            if key_code in (13, wx.WXK_NUMPAD_ENTER):
+                # XXX: not catching modifiers, to be wx2.6-compatible
                 catched = True
                 if not self.enter_catched:
                     self.CallTipCancel()
-                    if event.Modifiers == wx.MOD_SHIFT:
+                    if event.ShiftDown():
                         # Try to force execution
                         self.GotoPos(self.GetLength())
                         self.write('\n' + self.continuation_prompt(), 
@@ -493,19 +493,18 b' class ConsoleWidget(editwindow.EditWindow):'
                         self._on_enter()
                     self.enter_catched = True
 
-            elif event.KeyCode == wx.WXK_HOME:
-                if event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN):
+            elif key_code == wx.WXK_HOME:
+                if not event.ShiftDown():
                     self.GotoPos(self.current_prompt_pos)
                     catched = True
-
-                elif event.Modifiers == wx.MOD_SHIFT:
+                else:
                     # FIXME: This behavior is not ideal: if the selection
                     # is already started, it will jump.
                     self.SetSelectionStart(self.current_prompt_pos) 
                     self.SetSelectionEnd(self.GetCurrentPos())
                     catched = True
 
-            elif event.KeyCode == wx.WXK_UP:
+            elif key_code == wx.WXK_UP:
                 if self.GetCurrentLine() > self.current_prompt_line:
                     if self.GetCurrentLine() == self.current_prompt_line + 1 \
                             and self.GetColumn(self.GetCurrentPos()) < \
@@ -515,18 +514,18 b' class ConsoleWidget(editwindow.EditWindow):'
                         event.Skip()
                 catched = True
 
-            elif event.KeyCode in (wx.WXK_LEFT, wx.WXK_BACK):
+            elif key_code in (wx.WXK_LEFT, wx.WXK_BACK):
                 if not self._keep_cursor_in_buffer(self.GetCurrentPos() - 1):
                     event.Skip()
                 catched = True
 
-            elif event.KeyCode == wx.WXK_RIGHT:
+            elif key_code == wx.WXK_RIGHT:
                 if not self._keep_cursor_in_buffer(self.GetCurrentPos() + 1):
                     event.Skip()
                 catched = True
 
 
-            elif event.KeyCode == wx.WXK_DELETE:
+            elif key_code == wx.WXK_DELETE:
                 if not self._keep_cursor_in_buffer(self.GetCurrentPos() - 1):
                     event.Skip()
                 catched = True
@@ -535,7 +534,7 b' class ConsoleWidget(editwindow.EditWindow):'
                 # Put the cursor back in the edit region
                 if not self._keep_cursor_in_buffer():
                     if not (self.GetCurrentPos() == self.GetLength()
-                                and event.KeyCode == wx.WXK_DELETE):
+                                and key_code == wx.WXK_DELETE):
                         event.Skip()
                     catched = True
 

IPython/frontend/wx/wx_frontend.py

@@ -389,7 +389,8 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
         """
         # FIXME: This method needs to be broken down in smaller ones.
         current_line_num = self.GetCurrentLine()
-        if event.KeyCode in (ord('c'), ord('C')) and event.ControlDown():
+        key_code = event.GetKeyCode()
+        if key_code in (ord('c'), ord('C')) and event.ControlDown():
             # Capture Control-C
             if self._input_state == 'subprocess':
                 if self.debug:
@@ -403,40 +404,39 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
                 # XXX: We need to make really sure we
                 # get back to a prompt.
         elif self._input_state == 'subprocess' and (
-                ( event.KeyCode<256 and
-                        not event.ControlDown() )
+                ( key_code <256 and not event.ControlDown() )
                     or 
-                ( event.KeyCode in (ord('d'), ord('D')) and
+                ( key_code in (ord('d'), ord('D')) and
                   event.ControlDown())):
             #  We are running a process, we redirect keys.
             ConsoleWidget._on_key_down(self, event, skip=skip)
-            char = chr(event.KeyCode)
+            char = chr(key_code)
             # Deal with some inconsistency in wx keycodes:
             if char == '\r':
                 char = '\n'
             elif not event.ShiftDown():
                 char = char.lower()
-            if event.ControlDown() and event.KeyCode in (ord('d'), ord('D')):
+            if event.ControlDown() and key_code in (ord('d'), ord('D')):
                 char = '\04'
             self._running_process.process.stdin.write(char)
             self._running_process.process.stdin.flush()
-        elif event.KeyCode in (ord('('), 57, 53):
+        elif key_code in (ord('('), 57, 53):
             # Calltips
             event.Skip()
             self.do_calltip()
-        elif self.AutoCompActive() and not event.KeyCode == ord('\t'):
+        elif self.AutoCompActive() and not key_code == ord('\t'):
             event.Skip()
-            if event.KeyCode in (wx.WXK_BACK, wx.WXK_DELETE): 
+            if key_code in (wx.WXK_BACK, wx.WXK_DELETE): 
                 wx.CallAfter(self._popup_completion, create=True)
-            elif not event.KeyCode in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT,
+            elif not key_code in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT,
                             wx.WXK_RIGHT, wx.WXK_ESCAPE):
                 wx.CallAfter(self._popup_completion)
         else:
             # Up history
-            if event.KeyCode == wx.WXK_UP and (
-                    ( current_line_num == self.current_prompt_line and
-                        event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) 
-                    or event.ControlDown() ):
+            if key_code == wx.WXK_UP and (
+                            event.ControlDown() or
+                            current_line_num == self.current_prompt_line
+                    ):
                 new_buffer = self.get_history_previous(
                                             self.input_buffer)
                 if new_buffer is not None:
@@ -445,23 +445,24 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
                         # Go to first line, for seemless history up.
                         self.GotoPos(self.current_prompt_pos)
             # Down history
-            elif event.KeyCode == wx.WXK_DOWN and (
-                    ( current_line_num == self.LineCount -1 and
-                        event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) 
-                    or event.ControlDown() ):
+            elif key_code == wx.WXK_DOWN and (
+                            event.ControlDown() or
+                            current_line_num == self.LineCount -1
+                    ):
                 new_buffer = self.get_history_next()
                 if new_buffer is not None:
                     self.input_buffer = new_buffer
             # Tab-completion
-            elif event.KeyCode == ord('\t'):
+            elif key_code == ord('\t'):
                 current_line, current_line_num = self.CurLine
-                if not re.match(r'^\s*$', current_line):
+                if not re.match(r'^%s\s*$' % self.continuation_prompt(), 
+                                                            current_line):
                     self.complete_current_input()
                     if self.AutoCompActive():
                         wx.CallAfter(self._popup_completion, create=True)
                 else:
                     event.Skip()
-            elif event.KeyCode == wx.WXK_BACK:
+            elif key_code == wx.WXK_BACK:
                 # If characters where erased, check if we have to
                 # remove a line.
                 # XXX: What about DEL?
@@ -496,7 +497,7 b' class WxController(ConsoleWidget, PrefilterFrontEnd):'
     def _on_key_up(self, event, skip=True):
         """ Called when any key is released.
         """
-        if event.KeyCode in (59, ord('.')):
+        if event.GetKeyCode() in (59, ord('.')):
             # Intercepting '.'
             event.Skip()
             wx.CallAfter(self._popup_completion, create=True)

IPython/gui/wx/ipshell_nonblocking.py

@@ -46,7 +46,7 b' class _Helper(object):'
     
     def __call__(self, *args, **kwds):
         class DummyWriter(object):
-            '''Dumy class to handle help output'''	
+            '''Dumy class to handle help output'''      
             def __init__(self, pager):
                 self._pager = pager
                 

IPython/gui/wx/ipython_view.py

@@ -76,12 +76,12 b' class WxNonBlockingIPShell(NonBlockingIPShell):'
         """ A replacement from python's raw_input.
         """
         self.answer = None
-        if(self._threading == True):			
-			wx.CallAfter(self._yesNoBox,  prompt)
-			while self.answer is None:
-				time.sleep(.1)
+        if(self._threading == True):                    
+                        wx.CallAfter(self._yesNoBox,  prompt)
+                        while self.answer is None:
+                                time.sleep(.1)
         else:
-			self._yesNoBox(prompt)
+                        self._yesNoBox(prompt)
         return self.answer
         
     def _yesNoBox(self, prompt):

IPython/kernel/contexts.py

@@ -26,7 +26,7 b' import sys'
 
 from twisted.internet.error import ConnectionRefusedError
 
-from IPython.ultraTB import _fixed_getinnerframes, findsource
+from IPython.core.ultratb import _fixed_getinnerframes, findsource
 from IPython.core import ipapi
 
 from IPython.kernel import error

IPython/kernel/core/interpreter.py

@@ -29,7 +29,7 b' import sys'
 import traceback
 
 # Local imports.
-from IPython.kernel.core import ultraTB
+from IPython.core import ultratb
 from IPython.kernel.core.display_trap import DisplayTrap
 from IPython.kernel.core.macro import Macro
 from IPython.kernel.core.prompts import CachedOutput
@@ -167,9 +167,9 b' class Interpreter(object):'
             formatters=self.traceback_formatters)
 
         # This is used temporarily for reformating exceptions in certain
-        # cases.  It will go away once the ultraTB stuff is ported
+        # cases.  It will go away once the ultratb stuff is ported
         # to ipython1
-        self.tbHandler = ultraTB.FormattedTB(color_scheme='NoColor',
+        self.tbHandler = ultratb.FormattedTB(color_scheme='NoColor',
                                                  mode='Context',
                                                  tb_offset=2)
 
@@ -729,8 +729,8 b' class Interpreter(object):'
     def error(self, text):
         """ Pass an error message back to the shell.
 
-        Preconditions
-        -------------
+        Notes
+        -----
         This should only be called when self.message is set. In other words,
         when code is being executed.
 

IPython/kernel/core/notification.py

@@ -21,8 +21,8 b' __test__ = {}'
 class NotificationCenter(object):
     """Synchronous notification center
     
-    Example
-    -------
+    Examples
+    --------
     >>> import IPython.kernel.core.notification as notification
     >>> def callback(theType, theSender, args={}):
     ...     print theType,theSender,args
@@ -47,10 +47,10 b' class NotificationCenter(object):'
     
     def post_notification(self, theType, sender, **kwargs):
         """Post notification (type,sender,**kwargs) to all registered
-        observers. 
-        
-        Implementation
-        --------------
+        observers.
+
+        Implementation notes:
+
         * If no registered observers, performance is O(1).
         * Notificaiton order is undefined.
         * Notifications are posted synchronously.
@@ -122,4 +122,4 b' class NotificationCenter(object):'
     
 
 
-sharedCenter = NotificationCenter()
  No newline at end of file
+sharedCenter = NotificationCenter()

IPython/kernel/core/util.py

@@ -106,6 +106,9 b' def make_quoted_expr(s):'
 def system_shell(cmd, verbose=False, debug=False, header=''):
     """ Execute a command in the system shell; always return None.
 
+    This returns None so it can be conveniently used in interactive loops
+    without getting the return value (typically 0) printed many times.
+
     Parameters
     ----------
     cmd : str
@@ -117,11 +120,6 b" def system_shell(cmd, verbose=False, debug=False, header=''):"
     header : str
         Header to print to screen prior to the executed command. No extra
         newlines are added.
-
-    Description
-    -----------
-    This returns None so it can be conveniently used in interactive loops
-    without getting the return value (typically 0) printed many times.
     """
 
     if verbose or debug: 

IPython/kernel/engineservice.py

@@ -23,6 +23,10 b' method that automatically added methods to engines.'
 
 __docformat__ = "restructuredtext en"
 
+# Tell nose to skip this module.  I don't think we need this as nose
+# shouldn't ever be run on this!
+__test__ = {}
+
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
@@ -34,12 +38,9 b' __docformat__ = "restructuredtext en"'
 # Imports
 #-------------------------------------------------------------------------------
 
-# Tell nose to skip the testing of this module
-__test__ = {}
-
-import os, sys, copy
+import copy
+import sys
 import cPickle as pickle
-from new import instancemethod
 
 from twisted.application import service
 from twisted.internet import defer, reactor
@@ -47,11 +48,7 b' from twisted.python import log, failure, components'
 import zope.interface as zi
 
 from IPython.kernel.core.interpreter import Interpreter
-from IPython.kernel import newserialized, error, util
-from IPython.kernel.util import printer
-from IPython.kernel.twistedutil import gatherBoth, DeferredList
-from IPython.kernel import codeutil
-
+from IPython.kernel import newserialized, error
 
 #-------------------------------------------------------------------------------
 # Interface specification for the Engine

IPython/kernel/error.py

@@ -4,6 +4,9 b''
 
 __docformat__ = "restructuredtext en"
 
+# Tell nose to skip this module
+__test__ = {}
+
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
@@ -14,9 +17,9 b' __docformat__ = "restructuredtext en"'
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
+from twisted.python import failure
 
 from IPython.kernel.core import error
-from twisted.python import failure
 
 #-------------------------------------------------------------------------------
 # Error classes

IPython/kernel/multiengineclient.py

@@ -86,14 +86,13 b' class PendingResult(object):'
     
     A user should not create a `PendingResult` instance by hand.
     
-    Methods
-    =======
+    Methods:
     
     * `get_result`
     * `add_callback`
     
-    Properties
-    ==========
+    Properties:
+    
     * `r`
     """
     

IPython/kernel/newserialized.py

@@ -5,6 +5,9 b''
 
 __docformat__ = "restructuredtext en"
 
+# Tell nose to skip this module
+__test__ = {}
+
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
@@ -18,8 +21,8 b' __docformat__ = "restructuredtext en"'
 
 import cPickle as pickle
 
-from zope.interface import Interface, implements
 from twisted.python import components
+from zope.interface import Interface, implements
 
 try:
     import numpy
@@ -28,6 +31,10 b' except ImportError:'
 
 from IPython.kernel.error import SerializationError
 
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
 class ISerialized(Interface):
     
     def getData():

IPython/kernel/task.py

@@ -414,7 +414,7 b' class ResultNS(object):'
     This can be a bad idea, as it may corrupt standard behavior of the
     ns object.
     
-    Example
+    Examples
     --------
     
     >>> ns = ResultNS({'a':17,'foo':range(3)})

IPython/lib/demo.py

@@ -111,6 +111,13 b' has a few useful methods for navigation, like again(), edit(), jump(), seek()'
 and back().  It can be reset for a new run via reset() or reloaded from disk
 (in case you've edited the source) via reload().  See their docstrings below.
 
+Note: To make this simpler to explore, a file called "demo-exercizer.py" has
+been added to the "docs/examples/core" directory.  Just cd to this directory in
+an IPython session, and type::
+
+  %run demo-exercizer.py
+  
+and then follow the directions.
 
 Example
 =======
@@ -125,7 +132,7 b" print 'Hello, welcome to an interactive IPython demo.'"
 # The mark below defines a block boundary, which is a point where IPython will
 # stop execution and return to the interactive prompt. The dashes are actually
 # optional and used only as a visual aid to clearly separate blocks while
-editing the demo code.
+# editing the demo code.
 # <demo> stop
 
 x = 1
@@ -169,7 +176,7 b' import shlex'
 import sys
 
 from IPython.utils.PyColorize import Parser
-from IPython.utils.genutils import marquee, file_read, file_readlines
+from IPython.utils.genutils import marquee, file_read, file_readlines, Term
 
 __all__ = ['Demo','IPythonDemo','LineDemo','IPythonLineDemo','DemoError']
 
@@ -185,7 +192,7 b' class Demo(object):'
     re_auto     = re_mark('auto')
     re_auto_all = re_mark('auto_all')
 
-    def __init__(self,fname,arg_str='',auto_all=None):
+    def __init__(self,src,title='',arg_str='',auto_all=None):
         """Make a new demo object.  To run the demo, simply call the object.
 
         See the module docstring for full details and an example (you can use
@@ -193,9 +200,14 b' class Demo(object):'
 
         Inputs:
         
-          - fname = filename.
+          - src is either a file, or file-like object, or a
+              string that can be resolved to a filename.
 
         Optional inputs:
+        
+          - title: a string to use as the demo name.  Of most use when the demo
+          you are making comes from an object that has no filename, or if you 
+          want an alternate denotation distinct from the filename.
 
           - arg_str(''): a string of arguments, internally converted to a list
           just like sys.argv, so the demo script can see a similar
@@ -207,9 +219,24 b' class Demo(object):'
           can be changed at runtime simply by reassigning it to a boolean
           value.
           """
-        
-        self.fname    = fname
-        self.sys_argv = [fname] + shlex.split(arg_str)
+        if hasattr(src, "read"):
+             # It seems to be a file or a file-like object
+            self.fobj = src
+            self.fname = "from a file-like object"
+            if title == '':
+                self.title = "from a file-like object"
+            else:
+                self.title = title
+        else:
+             # Assume it's a string or something that can be converted to one
+            self.fobj = open(src)
+            self.fname = src
+            if title == '':
+                (filepath, filename) = os.path.split(src)
+                self.title = filename
+            else:
+                self.title = title
+        self.sys_argv = [src] + shlex.split(arg_str)
         self.auto_all = auto_all
         
         # get a few things from ipython.  While it's a bit ugly design-wise,
@@ -228,7 +255,7 b' class Demo(object):'
     def reload(self):
         """Reload source from disk and initialize state."""
         # read data and parse into blocks
-        self.src     = file_read(self.fname)
+        self.src     = self.fobj.read()
         src_b        = [b.strip() for b in self.re_stop.split(self.src) if b]
         self._silent = [bool(self.re_silent.findall(b)) for b in src_b]
         self._auto   = [bool(self.re_auto.findall(b)) for b in src_b]
@@ -277,7 +304,7 b' class Demo(object):'
         
         if index is None:
             if self.finished:
-                print 'Demo finished.  Use reset() if you want to rerun it.'
+                print >>Term.cout, 'Demo finished.  Use <demo_name>.reset() if you want to rerun it.'
                 return None
             index = self.block_index
         else:
@@ -346,26 +373,27 b' class Demo(object):'
         if index is None:
             return
 
-        print self.marquee('<%s> block # %s (%s remaining)' %
-                           (self.fname,index,self.nblocks-index-1))
-        sys.stdout.write(self.src_blocks_colored[index])
+        print >>Term.cout, self.marquee('<%s> block # %s (%s remaining)' %
+                           (self.title,index,self.nblocks-index-1))
+        print >>Term.cout,(self.src_blocks_colored[index])
         sys.stdout.flush()
 
     def show_all(self):
         """Show entire demo on screen, block by block"""
 
-        fname = self.fname
+        fname = self.title
+        title = self.title
         nblocks = self.nblocks
         silent = self._silent
         marquee = self.marquee
         for index,block in enumerate(self.src_blocks_colored):
             if silent[index]:
-                print marquee('<%s> SILENT block # %s (%s remaining)' %
-                              (fname,index,nblocks-index-1))
+                print >>Term.cout, marquee('<%s> SILENT block # %s (%s remaining)' %
+                              (title,index,nblocks-index-1))
             else:
-                print marquee('<%s> block # %s (%s remaining)' %
-                              (fname,index,nblocks-index-1))
-            print block,
+                print >>Term.cout, marquee('<%s> block # %s (%s remaining)' %
+                              (title,index,nblocks-index-1))
+            print >>Term.cout, block,
         sys.stdout.flush()
 
     def runlines(self,source):
@@ -390,18 +418,18 b' class Demo(object):'
             next_block = self.src_blocks[index]
             self.block_index += 1
             if self._silent[index]:
-                print marquee('Executing silent block # %s (%s remaining)' %
+                print >>Term.cout, marquee('Executing silent block # %s (%s remaining)' %
                               (index,self.nblocks-index-1))
             else:
                 self.pre_cmd()
                 self.show(index)
                 if self.auto_all or self._auto[index]:
-                    print marquee('output:')
+                    print >>Term.cout, marquee('output:')
                 else:
-                    print marquee('Press <q> to quit, <Enter> to execute...'),
+                    print >>Term.cout, marquee('Press <q> to quit, <Enter> to execute...'),
                     ans = raw_input().strip()
                     if ans:
-                        print marquee('Block NOT executed')
+                        print >>Term.cout, marquee('Block NOT executed')
                         return
             try:
                 save_argv = sys.argv
@@ -419,10 +447,10 b' class Demo(object):'
         if self.block_index == self.nblocks:
             mq1 = self.marquee('END OF DEMO')
             if mq1:
-                # avoid spurious prints if empty marquees are used
-                print
-                print mq1
-                print self.marquee('Use reset() if you want to rerun it.')
+                # avoid spurious print >>Term.cout,s if empty marquees are used
+                print >>Term.cout
+                print >>Term.cout, mq1
+                print >>Term.cout, self.marquee('Use <demo_name>.reset() if you want to rerun it.')
             self.finished = True
 
     # These methods are meant to be overridden by subclasses who may wish to
@@ -471,9 +499,9 b' class LineDemo(Demo):'
     def reload(self):
         """Reload source from disk and initialize state."""
         # read data and parse into blocks
-        src_b           = [l for l in file_readlines(self.fname) if l.strip()]
+        src_b           = [l for l in self.fobj.readline() if l.strip()]
         nblocks         = len(src_b)
-        self.src        = os.linesep.join(file_readlines(self.fname))
+        self.src        = os.linesep.join(self.fobj.readlines())
         self._silent    = [False]*nblocks
         self._auto      = [True]*nblocks
         self.auto_all   = True
@@ -494,29 +522,29 b' class IPythonLineDemo(IPythonDemo,LineDemo):'
 
 class ClearMixin(object):
     """Use this mixin to make Demo classes with less visual clutter.
-
+    
     Demos using this mixin will clear the screen before every block and use
     blank marquees.
-
+    
     Note that in order for the methods defined here to actually override those
     of the classes it's mixed with, it must go /first/ in the inheritance
     tree.  For example:
-
+    
         class ClearIPDemo(ClearMixin,IPythonDemo): pass
-
+    
     will provide an IPythonDemo class with the mixin's features.
     """
     
     def marquee(self,txt='',width=78,mark='*'):
         """Blank marquee that returns '' no matter what the input."""
         return ''
-
+    
     def pre_cmd(self):
         """Method called before executing each block.
-
+        
         This one simply clears the screen."""
-        os.system('clear')
-
+        from IPython.utils.platutils import term_clear
+        term_clear()
 
 class ClearDemo(ClearMixin,Demo):
     pass

IPython/testing/decorators_numpy.py

@@ -45,10 +45,10 b' def skipif(skip_condition=True, msg=None):'
     Parameters
     ----------
     skip_condition : bool or callable. 
- 	Flag to determine whether to skip test.  If the condition is a 
- 	callable, it is used at runtime to dynamically make the decision.  This 
- 	is useful for tests that may require costly imports, to delay the cost 
- 	until the test suite is actually executed.        
+        Flag to determine whether to skip test.  If the condition is a 
+        callable, it is used at runtime to dynamically make the decision.  This 
+        is useful for tests that may require costly imports, to delay the cost 
+        until the test suite is actually executed.        
     msg : string
         Message to give on raising a SkipTest exception
 

IPython/testing/iptest.py

@@ -24,6 +24,7 b' import os'
 import os.path as path
 import sys
 import subprocess
+import tempfile
 import time
 import warnings
 
@@ -50,6 +51,7 b' def test_for(mod):'
 
 have_curses = test_for('_curses')
 have_wx = test_for('wx')
+have_wx_aui = test_for('wx.aui')
 have_zi = test_for('zope.interface')
 have_twisted = test_for('twisted')
 have_foolscap = test_for('foolscap')
@@ -69,8 +71,9 b' def make_exclude():'
                pjoin('IPython', 'frontend', 'process', 'winprocess.py'),
                pjoin('IPython_doctest_plugin'),
                pjoin('IPython', 'extensions', 'ipy_'),
-               pjoin('IPython', 'extensions', 'clearcmd'),
+               pjoin('IPython', 'extensions', 'PhysicalQInput'),
                pjoin('IPython', 'extensions', 'PhysicalQInteractive'),
+               pjoin('IPython', 'extensions', 'InterpreterPasteInput'),
                pjoin('IPython', 'extensions', 'scitedirector'),
                pjoin('IPython', 'extensions', 'numeric_formats'),
                pjoin('IPython', 'testing', 'attic'),
@@ -88,6 +91,9 b' def make_exclude():'
     if not have_gtk or not have_gobject:
         EXCLUDE.append(pjoin('IPython', 'lib', 'inputhookgtk'))
 
+    if not have_wx_aui:
+        EXCLUDE.append(pjoin('IPython', 'gui', 'wx', 'wxIPython'))
+
     if not have_objc:
         EXCLUDE.append(pjoin('IPython', 'frontend', 'cocoa'))
 
@@ -109,6 +115,27 b' def make_exclude():'
     if not have_pexpect:
         EXCLUDE.append(pjoin('IPython', 'scripts', 'irunner'))
 
+    # This is scary.  We still have things in frontend and testing that
+    # are being tested by nose that use twisted.  We need to rethink
+    # how we are isolating dependencies in testing.
+    if not (have_twisted and have_zi and have_foolscap):
+        EXCLUDE.append(pjoin('IPython', 'frontend', 'asyncfrontendbase'))
+        EXCLUDE.append(pjoin('IPython', 'frontend', 'prefilterfrontend'))
+        EXCLUDE.append(pjoin('IPython', 'frontend', 'frontendbase'))
+        EXCLUDE.append(pjoin('IPython', 'frontend', 'linefrontendbase'))
+        EXCLUDE.append(pjoin('IPython', 'frontend', 'tests',
+                             'test_linefrontend'))
+        EXCLUDE.append(pjoin('IPython', 'frontend', 'tests', 
+                             'test_frontendbase'))
+        EXCLUDE.append(pjoin('IPython', 'frontend', 'tests',
+                             'test_prefilterfrontend'))
+        EXCLUDE.append(pjoin('IPython', 'frontend', 'tests',
+                             'test_asyncfrontendbase')),
+        EXCLUDE.append(pjoin('IPython', 'testing', 'parametric'))
+        EXCLUDE.append(pjoin('IPython', 'testing', 'util'))
+        EXCLUDE.append(pjoin('IPython', 'testing', 'tests', 
+                             'test_decorators_trial'))
+
     # Skip shell always because of a bug in FakeModule.
     EXCLUDE.append(pjoin('IPython', 'core', 'shell'))
 
@@ -118,6 +145,7 b' def make_exclude():'
 
     return EXCLUDE
 
+
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
@@ -196,9 +224,29 b' class IPTester(object):'
         # Assemble call
         self.call_args = self.runner+self.params
 
-    def run(self):
-        """Run the stored commands"""
-        return subprocess.call(self.call_args)
+    if sys.platform == 'win32':
+        def run(self):
+            """Run the stored commands"""
+            # On Windows, cd to temporary directory to run tests.  Otherwise,
+            # Twisted's trial may not be able to execute 'trial IPython', since
+            # it will confuse the IPython module name with the ipython
+            # execution scripts, because the windows file system isn't case
+            # sensitive.
+            # We also use os.system instead of subprocess.call, because I was
+            # having problems with subprocess and I just don't know enough
+            # about win32 to debug this reliably.  Os.system may be the 'old
+            # fashioned' way to do it, but it works just fine.  If someone
+            # later can clean this up that's fine, as long as the tests run
+            # reliably in win32.
+            curdir = os.getcwd()
+            os.chdir(tempfile.gettempdir())
+            stat = os.system(' '.join(self.call_args))
+            os.chdir(curdir)
+            return stat
+    else:
+        def run(self):
+            """Run the stored commands"""
+            return subprocess.call(self.call_args)
 
 
 def make_runners():
@@ -244,7 +292,7 b' def run_iptestall():'
     t_start = time.time()
     for name,runner in runners.iteritems():
         print '*'*77
-        print 'IPython test set:', name
+        print 'IPython test group:',name
         res = runner.run()
         if res:
             failed[name] = res
@@ -255,14 +303,14 b' def run_iptestall():'
     # summarize results
     print
     print '*'*77
-    print 'Ran %s test sets in %.3fs' % (nrunners, t_tests)
+    print 'Ran %s test groups in %.3fs' % (nrunners, t_tests)
     print
     if not failed:
         print 'OK'
     else:
         # If anything went wrong, point out what command to rerun manually to
         # see the actual errors and individual summary
-        print 'ERROR - %s out of %s test sets failed.' % (nfail, nrunners)
+        print 'ERROR - %s out of %s test groups failed.' % (nfail, nrunners)
         for name in failed:
             failed_runner = runners[name]
             print '-'*40
@@ -283,4 +331,4 b' def main():'
 
 
 if __name__ == '__main__':
-    main()
  No newline at end of file
+    main()

IPython/testing/plugin/ipdoctest.py

@@ -208,6 +208,15 b' def start_ipython():'
     _ip.IP.magic_run_ori = _ip.IP.magic_run
     _ip.IP.magic_run = im
 
+    # XXX - For some very bizarre reason, the loading of %history by default is
+    # failing.  This needs to be fixed later, but for now at least this ensures
+    # that tests that use %hist run to completion.
+    from IPython.core import history
+    history.init_ipython(_ip)
+    if not hasattr(_ip.IP,'magic_history'):
+        raise RuntimeError("Can't load magics, aborting")
+
+
 # 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.
@@ -431,7 +440,29 b' class DocTestCase(doctests.DocTestCase):'
             _ip.IP.user_ns.update(self._dt_test.globs)
             self._dt_test.globs = _ip.IP.user_ns
 
-        doctests.DocTestCase.setUp(self)
+        super(DocTestCase, self).setUp()
+
+    def tearDown(self):
+        # XXX - fperez: I am not sure if this is truly a bug in nose 0.11, but
+        # it does look like one to me: its tearDown method tries to run
+        #
+        # delattr(__builtin__, self._result_var)
+        #
+        # without checking that the attribute really is there; it implicitly
+        # assumes it should have been set via displayhook.  But if the
+        # displayhook was never called, this doesn't necessarily happen.  I
+        # haven't been able to find a little self-contained example outside of
+        # ipython that would show the problem so I can report it to the nose
+        # team, but it does happen a lot in our code.
+        #
+        # So here, we just protect as narrowly as possible by trapping an
+        # attribute error whose message would be the name of self._result_var,
+        # and letting any other error propagate.
+        try:
+            super(DocTestCase, self).tearDown()
+        except AttributeError, exc:
+            if exc.args[0] != self._result_var:
+                raise
 
 
 # A simple subclassing of the original with a different class name, so we can

IPython/testing/plugin/show_refs.py

@@ -10,9 +10,10 b' class C(object):'
       pass
       #print 'deleting object...'  # dbg
 
-c = C()
+if __name__ == '__main__':
+   c = C()
 
-c_refs = gc.get_referrers(c)
-ref_ids = map(id,c_refs)
+   c_refs = gc.get_referrers(c)
+   ref_ids = map(id,c_refs)
 
-print 'c referrers:',map(type,c_refs)
+   print 'c referrers:',map(type,c_refs)

IPython/testing/util.py

@@ -21,7 +21,7 b' from twisted.internet import defer'
 class DeferredTestCase(unittest.TestCase):
     
     def assertDeferredEquals(self, deferred, expectedResult,
-	                              chainDeferred=None):
+                                      chainDeferred=None):
         """Calls assertEquals on the result of the deferred and expectedResult.
         
         chainDeferred can be used to pass in previous Deferred objects that
@@ -32,7 +32,7 b' class DeferredTestCase(unittest.TestCase):'
         
         if chainDeferred is None:
             chainDeferred = defer.succeed(None)
-	       
+               
         def gotResult(actualResult):
             self.assertEquals(actualResult, expectedResult)
         
@@ -41,7 +41,7 b' class DeferredTestCase(unittest.TestCase):'
         return chainDeferred.addCallback(lambda _: deferred)
     
     def assertDeferredRaises(self, deferred, expectedException,
-	                              chainDeferred=None):
+                                      chainDeferred=None):
         """Calls assertRaises on the Failure of the deferred and expectedException.
         
         chainDeferred can be used to pass in previous Deferred objects that

IPython/utils/genutils.py

@@ -881,7 +881,7 b' def doctest_reload():'
 
     This routine:
 
-      - reloads doctest
+      - imports doctest but does NOT reload it (see below).
 
       - resets its global 'master' attribute to None, so that multiple uses of
       the module interactively don't produce cumulative reports.
@@ -890,20 +890,20 b' def doctest_reload():'
       modified displayhook.  Doctest expects the default displayhook behavior
       deep down, so our modification breaks it completely.  For this reason, a
       hard monkeypatch seems like a reasonable solution rather than asking
-      users to manually use a different doctest runner when under IPython."""
+      users to manually use a different doctest runner when under IPython.
 
-    import doctest
-    reload(doctest)
-    doctest.master=None
+    Notes
+    -----
 
-    try:
-        doctest.DocTestRunner
-    except AttributeError:
-        # This is only for python 2.3 compatibility, remove once we move to
-        # 2.4 only.
-        pass
-    else:
-        doctest.DocTestRunner.run = dhook_wrap(doctest.DocTestRunner.run)
+    This function *used to* reload doctest, but this has been disabled because
+    reloading doctest unconditionally can cause massive breakage of other
+    doctest-dependent modules already in memory, such as those for IPython's
+    own testing system.  The name wasn't changed to avoid breaking people's
+    code, but the reload call isn't actually made anymore."""
+
+    import doctest
+    doctest.master = None
+    doctest.DocTestRunner.run = dhook_wrap(doctest.DocTestRunner.run)
 
 #----------------------------------------------------------------------------
 class HomeDirError(Error):

IPython/utils/platutils.py

@@ -23,11 +23,6 b" elif sys.platform == 'win32':"
     import platutils_win32 as _platutils
 else:
     import platutils_dummy as _platutils
-    import warnings
-    warnings.warn("Platutils not available for platform '%s', some features may be missing" %
-        os.name)
-    del warnings
-
 
 # Functionality that's logically common to all platforms goes here, each
 # platform-specific module only provides the bits that are OS-dependent.
@@ -36,6 +31,9 b' else:'
 # there is a public, cross-platform way of toggling the term title control on
 # and off.  We should make this a stateful object later on so that each user
 # can have its own instance if needed.
+def term_clear():
+    _platutils.term_clear()
+
 def toggle_set_term_title(val):
     """Control whether set_term_title is active or not.
 
@@ -103,4 +101,3 b' def get_long_path_name(path):'
 def freeze_term_title():
     warnings.warn("This function is deprecated, use toggle_set_term_title()")
     _platutils.ignore_termtitle = True
-

IPython/utils/platutils_posix.py

@@ -20,6 +20,7 b' ignore_termtitle = True'
 def _dummy_op(*a, **b):
     """ A no-op function """
 
+
 def _set_term_title_xterm(title):
     """ Change virtual terminal title in xterm-workalikes """
 
@@ -31,10 +32,16 b" if os.environ.get('TERM','') == 'xterm':"
 else:
     set_term_title = _dummy_op
 
+
 def find_cmd(cmd):
     """Find the full path to a command using which."""
     return os.popen('which %s' % cmd).read().strip()
 
+
 def get_long_path_name(path):
     """Dummy no-op."""
     return path
+
+
+def term_clear():
+    os.system('clear')

IPython/utils/platutils_win32.py

@@ -42,18 +42,26 b' except ImportError:'
             # non-zero return code signals error, don't try again
             ignore_termtitle = True
 
+
 def find_cmd(cmd):
     """Find the full path to a .bat or .exe using the win32api module."""
     try:
-        import win32api
+        from win32api import SearchPath
     except ImportError:
         raise ImportError('you need to have pywin32 installed for this to work')
     else:
-        try:
-            (path, offest) = win32api.SearchPath(os.environ['PATH'],cmd + '.exe')
-        except:
-            (path, offset) = win32api.SearchPath(os.environ['PATH'],cmd + '.bat')
-    return path
+        PATH = os.environ['PATH']
+        extensions = ['.exe', '.com', '.bat', '.py']
+        path = None
+        for ext in extensions:
+            try:
+                path = SearchPath(PATH,cmd + ext)[0]
+            except:
+                pass
+        if path is None:
+            raise OSError("command %r not found" % cmd)
+        else:
+            return path
 
 
 def get_long_path_name(path):
@@ -80,3 +88,7 b' def get_long_path_name(path):'
         return path
     else:
         return buf.value
+
+
+def term_clear():
+    os.system('cls')

docs/examples/kernel/task2.py

@@ -3,6 +3,8 b''
 
 from IPython.kernel import client
 import time
+import sys
+flush = sys.stdout.flush
 
 tc = client.TaskClient()
 mec = client.MultiEngineClient()
@@ -16,6 +18,7 b' for i in range(6):'
     time.sleep(1.0)
     print "Queue status (vebose=False)"
     print tc.queue_status()
+    flush()
     
 for i in range(24):
     tc.run(client.StringTask('time.sleep(1)'))
@@ -24,12 +27,14 b' for i in range(6):'
     time.sleep(1.0)
     print "Queue status (vebose=True)"
     print tc.queue_status(True)
+    flush()
 
 for i in range(12):
     tc.run(client.StringTask('time.sleep(2)'))
 
 print "Queue status (vebose=True)"
 print tc.queue_status(True)
+flush()
 
 qs = tc.queue_status(True)
 sched = qs['scheduled']
@@ -41,4 +46,5 b' for i in range(6):'
     time.sleep(1.0)
     print "Queue status (vebose=True)"
     print tc.queue_status(True)
+    flush()
 

docs/source/changes.txt

@@ -1,3 +1,11 b''
+.. Developers should add in this file, during each release cycle, information
+.. about important changes they've made, in a summary format that's meant for
+.. end users.  For each release we normally have three sections: features,  bug
+.. fixes and api breakage.
+.. Please remember to credit the authors of the contributions by name,
+.. especially when they are new users or developers who do not regularly
+.. participate  in IPython's development.
+
 .. _changes:
 
 ==========
@@ -6,19 +14,27 b" What's new"
 
 .. contents::
 ..
-    1  Release 0.9.1
-    2  Release 0.9
+    1  Release dev
+      1.1  New features
+      1.2  Bug fixes
+      1.3  Backwards incompatible changes
+    2  Release 0.10
       2.1  New features
       2.2  Bug fixes
       2.3  Backwards incompatible changes
-      2.4  Changes merged in from IPython1
-        2.4.1  New features
-        2.4.2  Bug fixes
-        2.4.3  Backwards incompatible changes
-    3  Release 0.8.4
-    4  Release 0.8.3
-    5  Release 0.8.2
-    6  Older releases
+    3  Release 0.9.1
+    4  Release 0.9
+      4.1  New features
+      4.2  Bug fixes
+      4.3  Backwards incompatible changes
+      4.4  Changes merged in from IPython1
+        4.4.1  New features
+        4.4.2  Bug fixes
+        4.4.3  Backwards incompatible changes
+    5  Release 0.8.4
+    6  Release 0.8.3
+    7  Release 0.8.2
+    8  Older releases
 ..
 
 Release dev
@@ -27,25 +43,139 b' Release dev'
 New features
 ------------
 
+Bug fixes
+---------
+
+Backwards incompatible changes
+------------------------------
+
+
+Release 0.10
+============
+
+This release brings months of slow but steady development, and will be the last
+before a major restructuring and cleanup of IPython's internals that is already
+under way.  For this reason, we hope that 0.10 will be a stable and robust
+release so that while users adapt to some of the API changes that will come
+with the refactoring that will become IPython 0.11, they can safely use 0.10 in
+all existing projects with minimal changes (if any).
+
+IPython 0.10 is now a medium-sized project, with roughly (as reported by David
+Wheeler's :command:`sloccount` utility) 40750 lines of Python code, and a diff
+between 0.9.1 and this release that contains almost 28000 lines of code and
+documentation.  Our documentation, in PDF format, is a 495-page long PDF
+document (also available in HTML format, both generated from the same sources).
+
+Many users and developers contributed code, features, bug reports and ideas to
+this release.  Please do not hesitate in contacting us if we've failed to
+acknowledge your contribution here.  In particular, for this release we have
+contribution from the following people, a mix of new and regular names (in
+alphabetical order by first name):
+
+* Alexander Clausen: fix #341726.
+* Brian Granger: lots of work everywhere (features, bug fixes, etc).
+* Daniel Ashbrook: bug report on MemoryError during compilation, now fixed.
+* Darren Dale: improvements to documentation build system, feedback, design
+  ideas.
+* Fernando Perez: various places.
+* Gaël Varoquaux: core code, ipythonx GUI, design discussions, etc. Lots...
+* John Hunter: suggestions, bug fixes, feedback.
+* Jorgen Stenarson: work on many fronts, tests, fixes, win32 support, etc.
+* Laurent Dufréchou: many improvements to ipython-wx standalone app.
+* Lukasz Pankowski: prefilter, `%edit`, demo improvements.
+* Matt Foster: TextMate support in `%edit`.
+* Nathaniel Smith: fix #237073.
+* Pauli Virtanen: fixes and improvements to extensions, documentation.
+* Prabhu Ramachandran: improvements to `%timeit`.
+* Robert Kern: several extensions.
+* Sameer D'Costa: help on critical bug #269966.
+* Stephan Peijnik: feedback on Debian compliance and many man pages.
+* Tom Fetherston: many improvements to :mod:`IPython.demo` module.
+* Ville Vainio: lots of work everywhere (features, bug fixes, etc).
+* Vishal Vasta: ssh support in ipcluster.
+* Walter Doerwald: work on the :mod:`IPython.ipipe` system.
+
+Below we give an overview of new features, bug fixes and backwards-incompatible
+changes.  For a detailed account of every change made, feel free to view the
+project log with :command:`bzr log`.
+
+New features
+------------
+
+* New `%paste` magic automatically extracts current contents of clipboard and
+  pastes it directly, while correctly handling code that is indented or
+  prepended with `>>>` or `...` python prompt markers.  A very useful new
+  feature contributed by Robert Kern.
+
+* IPython 'demos', created with the :mod:`IPython.demo` module, can now be
+  created from files on disk or strings in memory.  Other fixes and
+  improvements to the demo system, by Tom Fetherston.
+
+* Added :func:`find_cmd` function to :mod:`IPython.platutils` module, to find
+  commands in a cross-platform manner.
+
+* Many improvements and fixes to Gaël Varoquaux's :command:`ipythonx`, a
+  WX-based lightweight IPython instance that can be easily embedded in other WX
+  applications.  These improvements have made it possible to now have an
+  embedded IPython in Mayavi and other tools.
+
+* :class:`MultiengineClient` objects now have a :meth:`benchmark` method.
+
+* The manual now includes a full set of auto-generated API documents from the
+  code sources, using Sphinx and some of our own support code.  We are now
+  using the `Numpy Documentation Standard`_  for all docstrings, and we have
+  tried to update as many existing ones as possible to this format.
+
+.. _Numpy Documentation Standard: http://projects.scipy.org/numpy/wiki/CodingStyleGuidelines#docstring-standard
+
+* The new :mod:`IPython.Extensions.ipy_pretty` extension by Robert Kern
+  provides configurable pretty-printing.
+
+* Many improvements to the :command:`ipython-wx` standalone WX-based IPython
+  application by Laurent Dufréchou.  It can optionally run in a thread, and
+  this can be toggled at runtime (allowing the loading of Matplotlib in a
+  running session without ill effects).
+
+* IPython includes a copy of Steven Bethard's argparse_ in the
+  :mod:`IPython.external` package, so we can use it internally and it is also
+  available to any IPython user.  By installing it in this manner, we ensure
+  zero conflicts with any system-wide installation you may already have while
+  minimizing external dependencies for new users.
+
+* An improved and much more robust test suite, that runs groups of tests in
+  separate subprocesses using either Nose or Twisted's :command:`trial` runner
+  to ensure proper management of Twisted-using code.  The test suite degrades
+  gracefully if optional dependencies are not available, so that the
+  :command:`iptest` command can be run with only Nose installed and nothing
+  else.  We also have more and cleaner test decorators to better select tests
+  depending on runtime conditions, do setup/teardown, etc.
+
 * The new ipcluster now has a fully working ssh mode that should work on
   Linux, Unix and OS X.  Thanks to Vishal Vatsa for implementing this!
 
 * The wonderful TextMate editor can now be used with %edit on OS X.  Thanks
   to Matt Foster for this patch.
 
+* The documentation regarding parallel uses of IPython, including MPI and PBS,
+  has been significantly updated and improved.
+
+* The developer guidelines in the documentation have been updated to explain
+  our workflow using :command:`bzr` and Launchpad.
+  
 * Fully refactored :command:`ipcluster` command line program for starting
   IPython clusters.  This new version is a complete rewrite and 1) is fully
   cross platform (we now use Twisted's process management), 2) has much
-  improved performance, 3) uses subcommands for different types of clusters, 
-  4) uses argparse for parsing command line options, 5) has better support
-  for starting clusters using :command:`mpirun`, 6) has experimental support
-  for starting engines using PBS.  However, this new version of ipcluster
-  should be considered a technology preview.  We plan on changing the API
-  in significant ways before it is final.
+  improved performance, 3) uses subcommands for different types of clusters, 4)
+  uses argparse for parsing command line options, 5) has better support for
+  starting clusters using :command:`mpirun`, 6) has experimental support for
+  starting engines using PBS.  It can also reuse FURL files, by appropriately
+  passing options to its subcommands.  However, this new version of ipcluster
+  should be considered a technology preview.  We plan on changing the API in
+  significant ways before it is final.
 
 * The :mod:`argparse` module has been added to :mod:`IPython.external`.
 
-* Fully description of the security model added to the docs.
+* Full description of the security model added to the docs.
 
 * cd completer: show bookmarks if no other completions are available.
 
@@ -55,13 +185,45 b' New features'
         [~]|1> _prompt_title = 'sudo!'
         sudo![~]|2>
 
-* %edit: If you do '%edit pasted_block', pasted_block
-  variable gets updated with new data (so repeated 
-  editing makes sense)
+* %edit: If you do '%edit pasted_block', pasted_block variable gets updated
+  with new data (so repeated editing makes sense)
 
 Bug fixes
 ---------
 
+* Fix #368719, removed top-level debian/ directory to make the job of Debian
+  packagers easier.
+  
+* Fix #291143 by including man pages contributed by Stephan Peijnik from the
+  Debian project.
+
+* Fix #358202, effectively a race condition, by properly synchronizing file
+  creation at cluster startup time.
+
+* `%timeit` now handles correctly functions that take a long time to execute
+  even the first time, by not repeating them.
+
+* Fix #239054, releasing of references after exiting.
+
+* Fix #341726, thanks to Alexander Clausen.
+
+* Fix #269966.  This long-standing and very difficult bug (which is actually a
+  problem in Python itself) meant long-running sessions would inevitably grow
+  in memory size, often with catastrophic consequences if users had large
+  objects in their scripts.  Now, using `%run` repeatedly should not cause any
+  memory leaks.  Special thanks to John Hunter and Sameer D'Costa for their
+  help with this bug.
+
+* Fix #295371, bug in `%history`.
+
+* Improved support for py2exe.
+
+* Fix #270856: IPython hangs with PyGTK
+
+* Fix #270998: A magic with no docstring breaks the '%magic magic'
+
+* fix #271684: -c startup commands screw up raw vs. native history
+
 * Numerous bugs on Windows with the new ipcluster have been fixed.
 
 * The ipengine and ipcontroller scripts now handle missing furl files
@@ -81,12 +243,26 b' Bug fixes'
 Backwards incompatible changes
 ------------------------------
 
+* `ipykit` and related files were unmaintained and have been removed.
+
+* The :func:`IPython.genutils.doctest_reload` does not actually call
+  `reload(doctest)` anymore, as this was causing many problems with the test
+  suite.  It still resets `doctest.master` to None.
+
+* While we have not deliberately broken Python 2.4 compatibility, only minor
+  testing was done with Python 2.4, while 2.5 and 2.6 were fully tested.  But
+  if you encounter problems with 2.4, please do report them as bugs.
+
+* The :command:`ipcluster` now requires a mode argument; for example to start a
+  cluster on the local machine with 4 engines, you must now type::
+
+    $ ipcluster local -n 4
+
 * The controller now has a ``-r`` flag that needs to be used if you want to
   reuse existing furl files.  Otherwise they are deleted (the default).
 
-* Remove ipy_leo.py. "easy_install ipython-extension" to get it.
-  (done to decouple it from ipython release cycle)
-
+* Remove ipy_leo.py. You can use :command:`easy_install ipython-extension` to
+  get it.  (done to decouple it from ipython release cycle)
 
 
 Release 0.9.1

docs/source/config/initial_config.txt

@@ -175,11 +175,16 b' In order to configure less as your default pager, do the following:'
       properly interpret control sequences, which is how color
       information is given to your terminal.
 
+For the bash shell, add to your ~/.bashrc file the lines::
+
+    export PAGER=less
+    export LESS=-r
+
 For the csh or tcsh shells, add to your ~/.cshrc file the lines::
 
     setenv PAGER less
     setenv LESS -r
-
+    
 There is similar syntax for other Unix shells, look at your system
 documentation for details.
 

docs/source/development/overview.txt

@@ -476,8 +476,17 b' if we want to have a codebase that works directly on both 2.x and 3.x.'
 
 	1. The syntax for exceptions changed (PEP 3110). The old 
 	   `except exc, var` changed to `except exc as var`. At last
-	   count there was 78 occurences of this usage in the codebase
-	   
+	   count there was 78 occurences of this usage in the codebase.  This
+	   is  a particularly problematic issue, because it's not easy to
+	   implement it in a 2.5-compatible way.
+
+Because it is quite difficult to support simultaneously Python 2.5 and 3.x, we
+will likely at some point put out a release that requires strictly 2.6 and
+abandons 2.5 compatibility.  This will then allow us to port the code to using
+:func:`print` as a function, `except exc as var` syntax, etc.  But as of
+version 0.11 at least, we will retain Python 2.5 compatibility.
+
+
 .. [Bazaar] Bazaar. http://bazaar-vcs.org/
 .. [Launchpad] Launchpad. http://www.launchpad.net/ipython
 .. [reStructuredText] reStructuredText.  http://docutils.sourceforge.net/rst.html

docs/source/install/install.txt

@@ -9,14 +9,16 b' install all of its dependencies.'
 
 
 Please let us know if you have problems installing IPython or any of its
-dependencies. IPython requires Python version 2.4 or greater.  Light testing
-has been done on version 2.6, and so far everything looks fine.  We have *not*
-yet started to port IPython to Python 3.0, where the language changes are much
-more significant.
+dependencies. Officially, IPython requires Python version 2.5 or 2.6.  We
+have *not* yet started to port IPython to Python 3.0.
 
 .. warning::
 
-	IPython will not work with Python 2.4 or below.
+    Officially, IPython supports Python versions 2.5 and 2.6.
+
+    IPython 0.10 has only been well tested with Python 2.5 and 2.6.  Parts of
+    it may work with Python 2.4, but we do not officially support Python 2.4
+    anymore.  If you need to use 2.4, you can still run IPython 0.9.
 
 Some of the installation approaches use the :mod:`setuptools` package and its
 :command:`easy_install` command line program.  In many scenarios, this provides
@@ -85,8 +87,8 b' Windows'
 
 There are a few caveats for Windows users.  The main issue is that a basic
 ``python setup.py install`` approach won't create ``.bat`` file or Start Menu
-shortcuts, which most users want.  To get an installation with these, there are
-two choices:
+shortcuts, which most users want.  To get an installation with these, you can
+use any of the following alternatives:
 
 1. Install using :command:`easy_install`.
 
@@ -96,6 +98,16 b' two choices:'
 3. Install from source, but using :mod:`setuptools` (``python setupegg.py
    install``).
 
+IPython by default runs in a termninal window, but the normal terminal
+application supplied by Microsoft Windows is very primitive.  You may want to
+download the excellent and free Console_ application instead, which is a far
+superior tool.  You can even configure Console to give you by default an
+IPython tab, which is very convenient to create new IPython sessions directly
+from the working terminal.
+
+.. _Console:  http://sourceforge.net/projects/console
+
+   
 Installing the development version
 ----------------------------------
 

docs/source/interactive/reference.txt

@@ -1329,8 +1329,9 b' For stand-alone use of the feature in your programs which do not use'
 IPython at all, put the following lines toward the top of your 'main'
 routine::
 
-    import sys,IPython.ultraTB  
-    sys.excepthook = IPython.ultraTB.FormattedTB(mode='Verbose',
+    import sys
+    from IPython.core import ultratb
+    sys.excepthook = ultratb.FormattedTB(mode='Verbose',
     color_scheme='Linux', call_pdb=1)
 
 The mode keyword can be either 'Verbose' or 'Plain', giving either very

docs/source/parallel/parallel_mpi.txt

@@ -38,7 +38,7 b' To use code that calls MPI, there are typically two things that MPI requires.'
 There are a couple of ways that you can start the IPython engines and get these things to happen.
 
 Automatic starting using :command:`mpiexec` and :command:`ipcluster`
--------------------------------------------------------------------
+--------------------------------------------------------------------
 
 The easiest approach is to use the `mpiexec` mode of :command:`ipcluster`, which will first start a controller and then a set of engines using :command:`mpiexec`::
 
@@ -48,7 +48,7 b' This approach is best as interrupting :command:`ipcluster` will automatically'
 stop and clean up the controller and engines.
 
 Manual starting using :command:`mpiexec`
----------------------------------------
+----------------------------------------
 
 If you want to start the IPython engines using the :command:`mpiexec`, just do::
 
@@ -154,4 +154,4 b' compiled C, C++ and Fortran libraries that have been exposed to Python.'
 .. [MPI] Message Passing Interface.  http://www-unix.mcs.anl.gov/mpi/
 .. [mpi4py] MPI for Python. mpi4py: http://mpi4py.scipy.org/
 .. [OpenMPI] Open MPI. http://www.open-mpi.org/
-.. [PyTrilinos] PyTrilinos. http://trilinos.sandia.gov/packages/pytrilinos/
  No newline at end of file
+.. [PyTrilinos] PyTrilinos. http://trilinos.sandia.gov/packages/pytrilinos/

scripts/ipython_win_post_install.py

@@ -65,11 +65,7 b' def install():'
     link = pjoin(ip_start_menu, 'scipy.lnk')
     cmd = '"%s" -p scipy' % ipybase
     mkshortcut(python,'IPython (scipy profile)',link,cmd)
-    
-    link = pjoin(ip_start_menu, 'IPython test suite.lnk')
-    cmd = '"%s" -vv' % pjoin(scripts, 'iptest')
-    mkshortcut(python,'Run the IPython test suite',link,cmd)
-    
+        
     link = pjoin(ip_start_menu, 'ipcontroller.lnk')
     cmd = '"%s" -xy' % pjoin(scripts, 'ipcontroller')
     mkshortcut(python,'IPython controller',link,cmd)

setup.py

@@ -78,14 +78,38 b" if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):"
                   #('docs/magic.tex',
                   #['IPython/Magic.py'],
                   #"cd doc && ./update_magic.sh" ),
-                 
+
+                 ('docs/man/ipcluster.1.gz',
+                  ['docs/man/ipcluster.1'],
+                  'cd docs/man && gzip -9c ipcluster.1 > ipcluster.1.gz'),
+
+                 ('docs/man/ipcontroller.1.gz',
+                  ['docs/man/ipcontroller.1'],
+                  'cd docs/man && gzip -9c ipcontroller.1 > ipcontroller.1.gz'),
+
+                 ('docs/man/ipengine.1.gz',
+                  ['docs/man/ipengine.1'],
+                  'cd docs/man && gzip -9c ipengine.1 > ipengine.1.gz'),
+
                  ('docs/man/ipython.1.gz',
                   ['docs/man/ipython.1'],
-                  "cd docs/man && gzip -9c ipython.1 > ipython.1.gz"),
+                  'cd docs/man && gzip -9c ipython.1 > ipython.1.gz'),
+
+                 ('docs/man/ipython-wx.1.gz',
+                  ['docs/man/ipython-wx.1'],
+                  'cd docs/man && gzip -9c ipython-wx.1 > ipython-wx.1.gz'),
+
+                 ('docs/man/ipythonx.1.gz',
+                  ['docs/man/ipythonx.1'],
+                  'cd docs/man && gzip -9c ipythonx.1 > ipythonx.1.gz'),
+
+                 ('docs/man/irunner.1.gz',
+                  ['docs/man/irunner.1'],
+                  'cd docs/man && gzip -9c irunner.1 > irunner.1.gz'),
 
                  ('docs/man/pycolor.1.gz',
                   ['docs/man/pycolor.1'],
-                  "cd docs/man && gzip -9c pycolor.1 > pycolor.1.gz"),
+                  'cd docs/man && gzip -9c pycolor.1 > pycolor.1.gz'),
                  ]
 
     # Only build the docs if sphinx is present

setupbase.py

@@ -57,7 +57,7 b' def file_doesnt_endwith(test,endings):'
 # Basic project information
 #---------------------------------------------------------------------------
 
-# Release.py contains version, authors, license, url, keywords, etc.
+# release.py contains version, authors, license, url, keywords, etc.
 execfile(pjoin('IPython','core','release.py'))
 
 # Create a dict with the basic information
@@ -227,6 +227,31 b' def find_data_files():'
     
     return data_files
 
+
+def make_man_update_target(manpage):
+    """Return a target_update-compliant tuple for the given manpage.
+
+    Parameters
+    ----------
+    manpage : string
+      Name of the manpage, must include the section number (trailing number).
+
+    Example
+    -------
+
+    >>> make_man_update_target('ipython.1') #doctest: +NORMALIZE_WHITESPACE
+    ('docs/man/ipython.1.gz',
+     ['docs/man/ipython.1'],
+     'cd docs/man && gzip -9c ipython.1 > ipython.1.gz')
+    """
+    man_dir = pjoin('docs', 'man')
+    manpage_gz = manpage + '.gz'
+    manpath = pjoin(man_dir, manpage)
+    manpath_gz = pjoin(man_dir, manpage_gz)
+    gz_cmd = ( "cd %(man_dir)s && gzip -9c %(manpage)s > %(manpage_gz)s" %
+               locals() )
+    return (manpath_gz, [manpath], gz_cmd)
+    
 #---------------------------------------------------------------------------
 # Find scripts
 #---------------------------------------------------------------------------

setupegg.py

@@ -5,8 +5,6 b' import sys'
 
 # now, import setuptools and call the actual setup
 import setuptools
-# print sys.argv
-#sys.argv=['','bdist_egg']
 execfile('setup.py')
 
 # clean up the junk left around by setuptools

tools/check_sources.py

@@ -1,15 +1,54 b''
+#!/usr/bin/env python
+"""Utility to look for hard tabs and \r characters in all sources.
+
+Usage:
+
+./check_sources.py
+
+It prints summaries and if chosen, line-by-line info of where \\t or \\r
+characters can be found in our source tree.
+"""
+
+# Config
+# If true, all lines that have tabs are printed, with line number
+full_report_tabs = True
+# If true, all lines that have tabs are printed, with line number
+full_report_rets = False
+
+# Code begins
 from IPython.external.path import path
-fs = path('..').walkfiles('*.py')
 
-for f in fs:
+rets = []
+tabs = []
+
+for f in path('..').walkfiles('*.py'):
     errs = ''
     cont = f.bytes()
     if '\t' in cont:
         errs+='t'
+        tabs.append(f)
 
     if '\r' in cont:
         errs+='r'
+        rets.append(f)
         
     if errs:
         print "%3s" % errs, f
-    
+
+    if 't' in errs and full_report_tabs:
+        for ln,line in enumerate(f.lines()):
+            if '\t' in line:
+                print 'TAB:',ln,':',line,
+
+    if 'r' in errs and full_report_rets:
+        for ln,line in enumerate(open(f.abspath(),'rb')):
+            if '\r' in line:
+                print 'RET:',ln,':',line,
+
+# Summary at the end, to call cleanup tools if necessary
+if tabs:
+    print 'Hard tabs found. These can be cleaned with untabify:'
+    for f in tabs: print f,
+if rets:
+    print 'Carriage returns (\\r) found in:'
+    for f in rets: print f,

tools/compile.py

@@ -1,20 +1,19 b''
 #!/usr/bin/env python
-"""Call the compile script to check that all code we ship compiles correctly.
-"""
+"""Script to check that all code in a directory compiles correctly.
 
-import os
-import sys
+Usage:
 
+  compile.py
 
-vstr = '.'.join(map(str,sys.version_info[:2]))
+This script verifies that all Python files in the directory where run, and all
+of its subdirectories, compile correctly.
 
-stat = os.system('python %s/lib/python%s/compileall.py .' % (sys.prefix,vstr))
+Before a release, call this script from the top-level directory.
+"""
+
+import sys
 
-print
-if stat:
-    print '*** THERE WAS AN ERROR! ***'
-    print 'See messages above for the actual file that produced it.'
-else:
-    print 'OK'
+from toollib import compile_tree
 
-sys.exit(stat)
+if __name__ == '__main__':
+    compile_tree()

tools/make_tarball.py

@@ -2,35 +2,22 b''
 """Simple script to create a tarball with proper bzr version info.
 """
 
-import os,sys,shutil
+import os
+import sys
+import shutil
 
-basever = '0.9.0'
+from  toollib import *
 
-def oscmd(c):
-    print ">",c
-    s = os.system(c)
-    if s:
-        print "Error",s
-        sys.exit(s)
+c('python update_revnum.py')
 
-def verinfo():
-    
-    out = os.popen('bzr version-info')
-    pairs = (l.split(':',1) for l in out)
-    d = dict(((k,v.strip()) for (k,v) in pairs)) 
-    return d
-
-basename = 'ipython'
-
-#tarname = '%s.r%s.tgz' % (basename, ver)
-oscmd('python update_revnum.py')
+execfile('../IPython/core/release.py')  # defines version_base
 
-ver = verinfo()
+ver = version_info()
 
 if ver['branch-nick'] == 'ipython':
-    tarname = 'ipython-%s.bzr.r%s.tgz' % (basever, ver['revno'])
+    tarname = 'ipython-%s.bzr.r%s.tgz' % (version_base, ver['revno'])
 else:
-    tarname = 'ipython-%s.bzr.r%s.%s.tgz' % (basever, ver['revno'],
+    tarname = 'ipython-%s.bzr.r%s.%s.tgz' % (version_base, ver['revno'],
                                              ver['branch-nick'])
     
-oscmd('bzr export ' + tarname)
+c('bzr export ' + tarname)

tools/release

@@ -1,58 +1,43 b''
-#!/bin/sh
-# IPython release script
+#!/usr/bin/env python
+"""IPython release script.
 
-PYVER=`python -V 2>&1 | awk '{print $2}' | awk -F '.' '{print $1$2}' `
-version=`ipython -Version`
-ipdir=~/ipython/ipython
-ipbackupdir=~/ipython/backup
+This should only be run at real release time.
+"""
 
-echo
-echo "Releasing IPython version $version"
-echo "=================================="
+from toollib import *
 
-# Perform local backup
-cd $ipdir/tools
-./make_tarball.py
-mv ipython-*.tgz $ipbackupdir
-
-# Clean up build/dist directories
-rm -rf $ipdir/build/*
-rm -rf $ipdir/dist/*
+# Get main ipython dir, this will raise if it doesn't pass some checks
+ipdir = get_ipdir()
+cd(ipdir)
 
-# Build source and binary distros
-cd $ipdir
-./setup.py sdist --formats=gztar
+# Load release info
+execfile(pjoin('IPython','core','release.py'))
 
-# Build version-specific RPMs, where we must use the --python option to ensure
-# that the resulting RPM is really built with the requested python version (so
-# things go to lib/python2.X/...)
-#python2.4 ./setup.py bdist_rpm --binary-only --release=py24 --python=/usr/bin/python2.4
-#python2.5 ./setup.py bdist_rpm --binary-only --release=py25 --python=/usr/bin/python2.5
+# Where I keep static backups of each release
+ipbackupdir = os.path.expanduser('~/ipython/backup')
 
-# Build eggs
-python2.4 ./setup_bdist_egg.py
-python2.5 ./setup_bdist_egg.py
+print
+print "Releasing IPython version $version"
+print "=================================="
 
-# Call the windows build separately, so that the extra Windows scripts don't
-# get pulled into Unix builds (setup.py has code which checks for
-# bdist_wininst)
-./setup.py bdist_wininst --install-script=ipython_win_post_install.py
+# Perform local backup
+c('./make_tarball.py')
+c('mv ipython-*.tgz %s' % ipbackupdir)
 
-# Change name so retarded Vista runs the installer correctly
-rename 's/win32/win32-setup/' $ipdir/dist/*.exe
+# Build release files
+c('./mkrel.py %s' % ipdir)
 
 # Register with the Python Package Index (PyPI)
-echo "Registering with PyPI..."
-cd $ipdir
-./setup.py register
+print "Registering with PyPI..."
+c('./setup.py register')
 
 # Upload all files
-cd $ipdir/dist
-echo "Uploading distribution files..."
-scp * [e-mail]:www/dist/
+cd('dist')
+print "Uploading distribution files..."
+c('scp * [e-mail]:www/dist/')
 
-echo "Uploading backup files..."
-cd $ipbackupdir
-scp `ls -1tr *tgz | tail -1` [e-mail]:www/backup/
+print "Uploading backup files..."
+cd(ipbackupdir)
+c('scp `ls -1tr *tgz | tail -1` [e-mail]:www/backup/')
 
-echo "Done!"
+print "Done!"

tools/run_ipy_in_profiler.py

@@ -1,3 +1,9 b''
+"""XXX - What exactly is the use of this script?
+
+I (fperez) tried it quickly and it doesn't work in its current form.  Either it
+needs to be fixed and documented or removed.
+"""
+
 import cProfile as profile
 import sys
 #import profile

tools/testupload

@@ -1,5 +1,5 b''
 #!/bin/sh
-
+# Simple upload script to push up into the testing directory a local build
 ipdir=$PWD/..
 
 cd $ipdir/dist

tools/update_revnum.py

@@ -1,23 +1,32 b''
 #!/usr/bin/env python
-""" Change the revision number in Release.py """
+"""Change the revision number in release.py
+
+This edits in-place release.py to update the revision number from bzr info. 
+
+Usage:
+
+./update_revnum.py"""
 
 import os
-import re,pprint
+import pprint
+import re
 
-def verinfo():
-    
-    out = os.popen('bzr version-info')
-    pairs = (l.split(':',1) for l in out)
-    d = dict(((k,v.strip()) for (k,v) in pairs)) 
-    return d
+from toollib import *
 
-ver = verinfo()
+if __name__ == '__main__':
+    ver = version_info()
 
-pprint.pprint(ver)
+    pprint.pprint(ver)
 
-rfile = open('../IPython/core/release.py','rb').read()
-newcont = re.sub(r'revision\s*=.*', "revision = '%s'" % ver['revno'], rfile)
+    rfile = open('../IPython/core/release.py','rb').read()
+    newcont = re.sub(r'revision\s*=.*',
+                     "revision = '%s'" % ver['revno'],
+                     rfile)
 
-newcont = re.sub(r'^branch\s*=[^=].*', "branch = '%s'"  % ver['branch-nick'], newcont )
+    newcont = re.sub(r'^branch\s*=[^=].*',
+                     "branch = '%s'"  % ver['branch-nick'],
+                     newcont)
 
-open('../IPython/core/release.py','wb').write(newcont)
+    f = open('../IPython/core/release.py','wb')
+    f.write(newcont)
+    f.close()