Releasing version 0.10.1.

A few last-minute fixes in various places for docs to build and full
test suite to pass, as well as documenting the release in the docs.

IPython/Release.py

@@ -1,120 +1,120 b''
 # -*- coding: utf-8 -*-
 """Release data for the IPython project."""
 
 #*****************************************************************************
-#       Copyright (C) 2008-2009  The IPython Development Team
+#       Copyright (C) 2008-2010  The IPython Development Team
 #       Copyright (C) 2001-2008 Fernando Perez <[e-mail]>
 #       Copyright (c) 2001 Janko Hauser <[e-mail]> and Nathaniel Gray
 #       <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 # Name of the package for release purposes.  This is the name which labels
 # the tarballs and RPMs made by distutils, so it's best to lowercase it.
 name = 'ipython'
 
 # For versions with substrings (like 0.6.16.svn), use an extra . to separate
 # the new substring.  We have to avoid using either dashes or underscores,
 # because bdist_rpm does not accept dashes (an RPM) convention, and
 # bdist_deb does not accept underscores (a Debian convention).
 
 development = False    # change this to False to do a release
 version_base = '0.10.1'
 branch = 'ipython'
 
 if development:
     if branch == 'ipython':
         version = '%s.git' % (version_base)
     else:
         version = '%s.git.%s' % (version_base, branch)
 else:
     version = version_base
 
 
 description = "An interactive computing environment for Python"
 
 long_description = \
 """
 The goal of IPython is to create a comprehensive environment for
 interactive and exploratory computing.  To support this goal, IPython
 has two main components:
 
 * An enhanced interactive Python shell.
 
 * An architecture for interactive parallel computing.
 
 The enhanced interactive Python shell has the following main features:
 
 * Comprehensive object introspection.
 
 * Input history, persistent across sessions.
 
 * Caching of output results during a session with automatically generated
   references.
 
 * Readline based name completion.
 
 * Extensible system of 'magic' commands for controlling the environment and
   performing many tasks related either to IPython or the operating system.
 
 * Configuration system with easy switching between different setups (simpler
   than changing $PYTHONSTARTUP environment variables every time).
 
 * Session logging and reloading.
 
 * Extensible syntax processing for special purpose situations.
 
 * Access to the system shell with user-extensible alias system.
 
 * Easily embeddable in other Python programs and wxPython GUIs.
 
 * Integrated access to the pdb debugger and the Python profiler. 
 
 The parallel computing architecture has the following main features:
 
 * Quickly parallelize Python code from an interactive Python/IPython session.
 
 * A flexible and dynamic process model that be deployed on anything from 
   multicore workstations to supercomputers.
 
 * An architecture that supports many different styles of parallelism, from
   message passing to task farming.
 
 * Both blocking and fully asynchronous interfaces.
 
 * High level APIs that enable many things to be parallelized in a few lines
   of code.
 
 * Share live parallel jobs with other users securely.  
 
 * Dynamically load balanced task farming system.
 
 * Robust error handling in parallel code.
 
 The latest development version is always available from IPython's `Launchpad 
 site <http://launchpad.net/ipython>`_.
 """
 
 license = 'BSD'
 
 authors = {'Fernando' : ('Fernando Perez','[e-mail]'),
            'Janko'    : ('Janko Hauser','[e-mail]'),
            'Nathan'   : ('Nathaniel Gray','[e-mail]'),
            'Ville'    : ('Ville Vainio','[e-mail]'),
            'Brian'    : ('Brian E Granger', '[e-mail]'),
            'Min'      : ('Min Ragan-Kelley', '[e-mail]')
            }
 
 author = 'The IPython Development Team'
 
 author_email = '[e-mail]'
 
 url = 'http://ipython.scipy.org'
 
 download_url = 'http://ipython.scipy.org/dist'
 
 platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME']
 
 keywords = ['Interactive','Interpreter','Shell','Parallel','Distributed']

IPython/__init__.py

@@ -1,71 +1,71 b''
 # -*- coding: utf-8 -*-
 """
 IPython -- An enhanced Interactive Python
 
 One of Python's nicest features is its interactive interpreter. This allows
 very fast testing of ideas without the overhead of creating test files as is
 typical in most programming languages. However, the interpreter supplied with
 the standard Python distribution is fairly primitive (and IDLE isn't really
 much better).
 
 IPython tries to:
 
   i - provide an efficient environment for interactive work in Python
   programming. It tries to address what we see as shortcomings of the standard
   Python prompt, and adds many features to make interactive work much more
   efficient.
 
   ii - offer a flexible framework so that it can be used as the base
   environment for other projects and problems where Python can be the
   underlying language. Specifically scientific environments like Mathematica,
   IDL and Mathcad inspired its design, but similar ideas can be useful in many
   fields. Python is a fabulous language for implementing this kind of system
   (due to its dynamic and introspective features), and with suitable libraries
   entire systems could be built leveraging Python's power.
 
   iii - serve as an embeddable, ready to go interpreter for your own programs.
 
 IPython requires Python 2.4 or newer.
 """
 
 #*****************************************************************************
-#       Copyright (C) 2008-2009 The IPython Development Team
+#       Copyright (C) 2008-2010 The IPython Development Team
 #       Copyright (C) 2001-2007 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 # Enforce proper version requirements
 import sys
 
 if sys.version[0:3] < '2.4':
     raise ImportError('Python Version 2.4 or above is required for IPython.')
 
 # Make it easy to import extensions - they are always directly on pythonpath.
 # Therefore, non-IPython modules can be added to Extensions directory
 import os
 sys.path.append(os.path.dirname(__file__) + "/Extensions")
 
 # Define what gets imported with a 'from IPython import *'
 __all__ = ['ipapi','generics','ipstruct','Release','Shell']
 
 # Load __all__ in IPython namespace so that a simple 'import IPython' gives
 # access to them via IPython.<name>
 glob,loc = globals(),locals()
 for name in __all__:
     #print 'Importing: ',name # dbg
     __import__(name,glob,loc,[])
 
 import Shell
 
 # Release data
 from IPython import Release # do it explicitly so pydoc can see it - pydoc bug
 __author__   = '%s <%s>\n%s <%s>\n%s <%s>' % \
                ( Release.authors['Fernando'] + Release.authors['Janko'] + \
                  Release.authors['Nathan'] )
 __license__  = Release.license
 __version__  = Release.version
 
 # Namespace cleanup
 del name,glob,loc

IPython/testing/iptest.py

@@ -1,346 +1,346 b''
 # -*- coding: utf-8 -*-
 """IPython Test Suite Runner.
 
 This module provides a main entry point to a user script to test IPython
 itself from the command line. There are two ways of running this script:
 
 1. With the syntax `iptest all`.  This runs our entire test suite by
    calling this script (with different arguments) or trial recursively.  This
    causes modules and package to be tested in different processes, using nose
    or trial where appropriate.
 2. With the regular nose syntax, like `iptest -vvs IPython`.  In this form
    the script simply calls nose, but with special command line flags and
    plugins loaded.
 
 For now, this script requires that both nose and twisted are installed.  This
 will change in the future.
 """
 
 #-----------------------------------------------------------------------------
 # Module imports
 #-----------------------------------------------------------------------------
 
 import os
 import os.path as path
 import sys
 import subprocess
 import tempfile
 import time
 import warnings
 
 import nose.plugins.builtin
 from nose.core import TestProgram
 
 from IPython.platutils import find_cmd
 from IPython.testing.plugin.ipdoctest import IPythonDoctest
 
 pjoin = path.join
 
 #-----------------------------------------------------------------------------
 # Logic for skipping doctests
 #-----------------------------------------------------------------------------
 
 def test_for(mod):
     """Test to see if mod is importable."""
     try:
         __import__(mod)
     except ImportError:
         return False
     else:
         return True
 
 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')
 have_objc = test_for('objc')
 have_pexpect = test_for('pexpect')
 
 # For the IPythonDoctest plugin, we need to exclude certain patterns that cause
 # testing problems.  We should strive to minimize the number of skipped
 # modules, since this means untested code.  As the testing machinery
 # solidifies, this list should eventually become empty.
 EXCLUDE = [pjoin('IPython', 'external'),
            pjoin('IPython', 'frontend', 'process', 'winprocess.py'),
            pjoin('IPython_doctest_plugin'),
            pjoin('IPython', 'Gnuplot'),
            pjoin('IPython', 'Extensions', 'ipy_'),
            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'),
            pjoin('IPython', 'testing', 'tutils'),
            pjoin('IPython', 'testing', 'tools'),
            pjoin('IPython', 'testing', 'mkdoctests'),
+           pjoin('IPython', 'gui'),
            ]
 
 if not have_wx:
     EXCLUDE.append(pjoin('IPython', 'Extensions', 'igrid'))
-    EXCLUDE.append(pjoin('IPython', 'gui'))
     EXCLUDE.append(pjoin('IPython', 'frontend', 'wx'))
 
 if not have_wx_aui:
     EXCLUDE.append(pjoin('IPython', 'gui', 'wx', 'wxIPython'))
 
 if not have_objc:
     EXCLUDE.append(pjoin('IPython', 'frontend', 'cocoa'))
 
 if not have_curses:
     EXCLUDE.append(pjoin('IPython', 'Extensions', 'ibrowse'))
 
 if not sys.platform == 'win32':
     EXCLUDE.append(pjoin('IPython', 'platutils_win32'))
 
 # These have to be skipped on win32 because the use echo, rm, cd, etc.
 # See ticket https://bugs.launchpad.net/bugs/366982
 if sys.platform == 'win32':
     EXCLUDE.append(pjoin('IPython', 'testing', 'plugin', 'test_exampleip'))
     EXCLUDE.append(pjoin('IPython', 'testing', 'plugin', 'dtexample'))
 
 if not os.name == 'posix':
     EXCLUDE.append(pjoin('IPython', 'platutils_posix'))
 
 if not have_pexpect:
     EXCLUDE.append(pjoin('IPython', 'irunner'))
 
 if not have_twisted:
     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', 'kernel', 'error'))
     EXCLUDE.append(pjoin('IPython', 'testing', 'parametric'))
     EXCLUDE.append(pjoin('IPython', 'testing', 'util'))
     EXCLUDE.append(pjoin('IPython', 'testing', 'tests', 'test_decorators_trial'))
 
 
 # This is needed for the reg-exp to match on win32 in the ipdoctest plugin.
 if sys.platform == 'win32':
     EXCLUDE = [s.replace('\\','\\\\') for s in EXCLUDE]
 
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
 
 def run_iptest():
     """Run the IPython test suite using nose.
     
     This function is called when this script is **not** called with the form
     `iptest all`.  It simply calls nose with appropriate command line flags
     and accepts all of the standard nose arguments.
     """
 
     warnings.filterwarnings('ignore', 
         'This will be removed soon.  Use IPython.testing.util instead')
 
     argv = sys.argv + [ 
                         # Loading ipdoctest causes problems with Twisted.
                         # I am removing this as a temporary fix to get the 
                         # test suite back into working shape.  Our nose
                         # plugin needs to be gone through with a fine
                         # toothed comb to find what is causing the problem.
                         '--with-ipdoctest',
                         '--ipdoctest-tests','--ipdoctest-extension=txt',
                         '--detailed-errors',
                        
                         # We add --exe because of setuptools' imbecility (it
                         # blindly does chmod +x on ALL files).  Nose does the
                         # right thing and it tries to avoid executables,
                         # setuptools unfortunately forces our hand here.  This
                         # has been discussed on the distutils list and the
                         # setuptools devs refuse to fix this problem!
                         '--exe',
                         ]
 
     # Detect if any tests were required by explicitly calling an IPython
     # submodule or giving a specific path
     has_tests = False
     for arg in sys.argv:
         if 'IPython' in arg or arg.endswith('.py') or \
            (':' in arg and  '.py' in arg):
             has_tests = True
             break
         
     # If nothing was specifically requested, test full IPython
     if not has_tests:
         argv.append('IPython')
 
     # Construct list of plugins, omitting the existing doctest plugin, which
     # ours replaces (and extends).
     plugins = [IPythonDoctest(EXCLUDE)]
     for p in nose.plugins.builtin.plugins:
         plug = p()
         if plug.name == 'doctest':
             continue
 
         #print '*** adding plugin:',plug.name  # dbg
         plugins.append(plug)
 
     TestProgram(argv=argv,plugins=plugins)
 
 
 class IPTester(object):
     """Call that calls iptest or trial in a subprocess.
     """
     def __init__(self,runner='iptest',params=None):
         """ """
         if runner == 'iptest':
             self.runner = ['iptest','-v']
         else:
             self.runner = [find_cmd('trial')]
         if params is None:
             params = []
         if isinstance(params,str):
             params = [params]
         self.params = params
 
         # Assemble call
         self.call_args = self.runner+self.params
 
     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():
     """Define the modules and packages that need to be tested.
     """
     
     # This omits additional top-level modules that should not be doctested.
     # XXX: Shell.py is also ommited because of a bug in the skip_doctest
     # decorator.  See ticket https://bugs.launchpad.net/bugs/366209
     top_mod = \
       ['background_jobs.py', 'ColorANSI.py', 'completer.py', 'ConfigLoader.py',
        'CrashHandler.py', 'Debugger.py', 'deep_reload.py', 'demo.py',
        'DPyGetOpt.py', 'dtutils.py', 'excolors.py', 'FakeModule.py',
        'generics.py', 'genutils.py', 'history.py', 'hooks.py', 'ipapi.py',
        'iplib.py', 'ipmaker.py', 'ipstruct.py', 'Itpl.py',
        'Logger.py', 'macro.py', 'Magic.py', 'OInspect.py',
        'OutputTrap.py', 'platutils.py', 'prefilter.py', 'Prompts.py',
        'PyColorize.py', 'Release.py', 'rlineimpl.py', 'shadowns.py',
        'shellglobals.py', 'strdispatch.py', 
        'ultraTB.py', 'upgrade_dir.py', 'usage.py', 'wildcard.py',
        # See note above for why this is skipped
        # 'Shell.py',
        'winconsole.py']
 
     if have_twisted:
         top_mod.append('twshell.py')
 
     if have_pexpect:
         top_mod.append('irunner.py')
 
     if sys.platform == 'win32':
         top_mod.append('platutils_win32.py')
     elif os.name == 'posix':
         top_mod.append('platutils_posix.py')
     else:
         top_mod.append('platutils_dummy.py')
 
     # These are tested by nose, so skip IPython.kernel
     top_pack = ['config','Extensions','frontend',
                 'testing','tests','tools','UserConfig']
 
     if have_wx:
         top_pack.append('gui')
 
     modules  = ['IPython.%s' % m[:-3] for m in top_mod ]
     packages = ['IPython.%s' % m for m in top_pack ]
 
     # Make runners
     runners = dict(zip(top_pack, [IPTester(params=v) for v in packages]))
     
     # Test IPython.kernel using trial if twisted is installed
     if have_zi and have_twisted and have_foolscap:
         runners['trial'] = IPTester('trial',['IPython'])
 
     runners['modules'] = IPTester(params=modules)
 
     return runners
 
 
 def run_iptestall():
     """Run the entire IPython test suite by calling nose and trial.
     
     This function constructs :class:`IPTester` instances for all IPython
     modules and package and then runs each of them.  This causes the modules
     and packages of IPython to be tested each in their own subprocess using
     nose or twisted.trial appropriately.
     """
     runners = make_runners()
     # Run all test runners, tracking execution time
     failed = {}
     t_start = time.time()
     for name,runner in runners.iteritems():
         print '*'*77
         print 'IPython test group:',name
         res = runner.run()
         if res:
             failed[name] = res
     t_end = time.time()
     t_tests = t_end - t_start
     nrunners = len(runners)
     nfail = len(failed)
     # summarize results
     print
     print '*'*77
     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 groups failed.' % (nfail, nrunners)
         for name in failed:
             failed_runner = runners[name]
             print '-'*40
             print 'Runner failed:',name
             print 'You may wish to rerun this one individually, with:'
             print ' '.join(failed_runner.call_args)
             print
 
 
 def main():
     if len(sys.argv) == 1:
         run_iptestall()
     else:
         if sys.argv[1] == 'all':
             run_iptestall()
         else:
             run_iptest()
 
 
 if __name__ == '__main__':
     main()

docs/source/changes.txt

@@ -1,544 +1,640 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:
 
 ==========
 What's new
 ==========
 
+Release 0.10.1
+==============
+
+IPython 0.10.1 was released October 11, 2010, over a year after version 0.10.
+This is mostly a bugfix release, since after version 0.10 was released, the
+development team's energy has been focused on the 0.11 series.  We have
+nonetheless tried to backport what fixes we could into 0.10.1, as it remains
+the stable series that many users have in production systems they rely on.
+
+Since the 0.11 series changes many APIs in backwards-incompatible ways, we are
+willing to continue maintaining the 0.10.x series.  We don't really have time
+to actively write new code for 0.10.x, but we are happy to accept patches and
+pull requests on the IPython `github site`_.  If sufficient contributions are
+made that improve 0.10.1, we will roll them into future releases.  For this
+purpose, we will have a branch called 0.10.2 on github, on which you can base
+your contributions.
+
+.. _github site: http://github.com/ipython
+
+For this release, we applied approximately 60 commits totaling a diff of over
+7000 lines::
+
+    (0.10.1)amirbar[dist]> git diff --oneline rel-0.10.. | wc -l
+    7296
+
+Highlights of this release:
+
+- The only significant new feature is that IPython's parallel computing
+  machinery now supports natively the Sun Grid Engine and LSF schedulers.  This
+  work was a joint contribution from Justin Riley, Satra Ghosh and Matthieu
+  Brucher, who put a lot of work into it.  We also improved traceback handling
+  in remote tasks, as well as providing better control for remote task IDs.
+
+- New IPython Sphinx directive.  You can use this directive to mark blocks in
+  reSructuredText documents as containig IPython syntax (including figures) and
+  the will be executed during the build::
+
+  .. ipython::
+
+      In [2]: plt.figure()  # ensure a fresh figure
+
+      @savefig psimple.png width=4in
+      In [3]: plt.plot([1,2,3])
+      Out[3]: [<matplotlib.lines.Line2D object at 0x9b74d8c>]
+
+- Various fixes to the standalone ipython-wx application.
+
+- We now ship internally the excellent argparse library, graciously licensed
+  under BSD terms by Steven Bethard.  Now (2010) that argparse has become part
+  of Python 2.7 this will be less of an issue, but Steven's relicensing allowed
+  us to start updating IPython to using argparse well before Python 2.7.  Many
+  thanks!
+
+- Robustness improvements so that IPython doesn't crash if the readline library
+  is absent (though obviously a lot of functionality that requires readline
+  will not be available).
+  
+- Improvements to tab completion in Emacs with Python 2.6.
+
+- Logging now supports timestamps (see ``%logstart?`` for full details).
+
+- A long-standing and quite annoying bug where parentheses would be added to
+  ``print`` statements, under Python 2.5 and 2.6, was finally fixed.
+
+- Improved handling of libreadline on Apple OSX.
+
+- Fix ``reload`` method of IPython demos, which was broken.
+
+- Fixes for the ipipe/ibrowse system on OSX.
+
+- Fixes for Zope profile.
+
+- Fix %timeit reporting when the time is longer than 1000s.
+
+- Avoid lockups with ? or ?? in SunOS, due to a bug in termios.
+  
+- The usual assortment of miscellaneous bug fixes and small improvements.
+      
+The following people contributed to this release (please let us know if we
+ommitted your name and we'll gladly fix this in the notes for the future):
+
+* Beni Cherniavsky
+* Boyd Waters.
+* David Warde-Farley
+* Fernando Perez
+* Gökhan Sever
+* Justin Riley
+* Kiorky
+* Laurent Dufrechou
+* Mark E. Smith
+* Matthieu Brucher
+* Satrajit Ghosh
+* Sebastian Busch
+* Václav Šmilauer
+    
+
 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.
 * Steven Bethard: we are now shipping his :mod:`argparse` module.
 * 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.
 
 * 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.  In IPython 0.10, We ship
   argparse version 1.0.
 
 * 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.  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.
 
 * Full description of the security model added to the docs.
 
 * cd completer: show bookmarks if no other completions are available.
 
 * sh profile: easy way to give 'title' to prompt: assign to variable
   '_prompt_title'. It looks like this::
       
         [~]|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)
 
 .. _Numpy Documentation Standard: http://projects.scipy.org/numpy/wiki/CodingStyleGuidelines#docstring-standard
 
 .. _argparse: http://code.google.com/p/argparse/
 
 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
   more gracefully by giving better error messages.
 
 * %rehashx: Aliases no longer contain dots. python3.0 binary
   will create alias python30. Fixes:
   #259716 "commands with dots in them don't work"
 
 * %cpaste: %cpaste -r repeats the last pasted block.
   The block is assigned to pasted_block even if code
   raises exception.
 
 * Bug #274067 'The code in get_home_dir is broken for py2exe' was
   fixed.
 
 * Many other small bug fixes not listed here by number (see the bzr log for
   more info).
   
 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. You can use :command:`easy_install ipython-extension` to
   get it.  (done to decouple it from ipython release cycle)
 
 
 Release 0.9.1
 =============
 
 This release was quickly made to restore compatibility with Python 2.4, which
 version 0.9 accidentally broke.  No new features were introduced, other than
 some additional testing support for internal use.
 
 
 Release 0.9
 ===========
 
 New features
 ------------
 
 * All furl files and security certificates are now put in a read-only
   directory named ~./ipython/security.
 
 * A single function :func:`get_ipython_dir`, in :mod:`IPython.genutils` that
   determines the user's IPython directory in a robust manner.
 
 * Laurent's WX application has been given a top-level script called
   ipython-wx, and it has received numerous fixes. We expect this code to be
   architecturally better integrated with Gael's WX 'ipython widget' over the
   next few releases.
 
 * The Editor synchronization work by Vivian De Smedt has been merged in.  This
   code adds a number of new editor hooks to synchronize with editors under
   Windows.
 
 * A new, still experimental but highly functional, WX shell by Gael Varoquaux.
   This work was sponsored by Enthought, and while it's still very new, it is
   based on a more cleanly organized arhictecture of the various IPython
   components. We will continue to develop this over the next few releases as a
   model for GUI components that use IPython.
 
 * Another GUI frontend, Cocoa based (Cocoa is the OSX native GUI framework),
   authored by Barry Wark.  Currently the WX and the Cocoa ones have slightly
   different internal organizations, but the whole team is working on finding
   what the right abstraction points are for a unified codebase.
 
 * As part of the frontend work, Barry Wark also implemented an experimental
   event notification system that various ipython components can use.  In the
   next release the implications and use patterns of this system regarding the
   various GUI options will be worked out.
 
 * IPython finally has a full test system, that can test docstrings with
   IPython-specific functionality.  There are still a few pieces missing for it
   to be widely accessible to all users (so they can run the test suite at any
   time and report problems), but it now works for the developers.  We are
   working hard on continuing to improve it, as this was probably IPython's
   major Achilles heel (the lack of proper test coverage made it effectively
   impossible to do large-scale refactoring).  The full test suite can now
   be run using the :command:`iptest` command line program.
 
 * The notion of a task has been completely reworked.  An `ITask` interface has
   been created.  This interface defines the methods that tasks need to
   implement.  These methods are now responsible for things like submitting
   tasks and processing results.  There are two basic task types:
   :class:`IPython.kernel.task.StringTask` (this is the old `Task` object, but
   renamed) and the new :class:`IPython.kernel.task.MapTask`, which is based on
   a function.
 
 * A new interface, :class:`IPython.kernel.mapper.IMapper` has been defined to
   standardize the idea of a `map` method.  This interface has a single `map`
   method that has the same syntax as the built-in `map`.  We have also defined
   a `mapper` factory interface that creates objects that implement
   :class:`IPython.kernel.mapper.IMapper` for different controllers.  Both the
   multiengine and task controller now have mapping capabilties.
 
 * The parallel function capabilities have been reworks.  The major changes are
   that i) there is now an `@parallel` magic that creates parallel functions,
   ii) the syntax for mulitple variable follows that of `map`, iii) both the
   multiengine and task controller now have a parallel function implementation.
 
 * All of the parallel computing capabilities from `ipython1-dev` have been
   merged into IPython proper.  This resulted in the following new subpackages:
   :mod:`IPython.kernel`, :mod:`IPython.kernel.core`, :mod:`IPython.config`,
   :mod:`IPython.tools` and :mod:`IPython.testing`.
 
 * As part of merging in the `ipython1-dev` stuff, the `setup.py` script and
   friends have been completely refactored.  Now we are checking for
   dependencies using the approach that matplotlib uses.
 
 * The documentation has been completely reorganized to accept the 
   documentation from `ipython1-dev`.
 
 * We have switched to using Foolscap for all of our network protocols in
   :mod:`IPython.kernel`.  This gives us secure connections that are both
   encrypted and authenticated.
 
 * We have a brand new `COPYING.txt` files that describes the IPython license
   and copyright. The biggest change is that we are putting "The IPython
   Development Team" as the copyright holder. We give more details about
   exactly what this means in this file. All developer should read this and use
   the new banner in all IPython source code files.
 
 * sh profile: ./foo runs foo as system command, no need to do !./foo anymore
 
 * String lists now support ``sort(field, nums = True)`` method (to easily sort
   system command output). Try it with ``a = !ls -l ; a.sort(1, nums=1)``.
 
 * '%cpaste foo' now assigns the pasted block as string list, instead of string
 
 * The ipcluster script now run by default with no security.  This is done
   because the main usage of the script is for starting things on localhost.
   Eventually when ipcluster is able to start things on other hosts, we will put
   security back.
 
 * 'cd --foo' searches directory history for string foo, and jumps to that dir.
   Last part of dir name is checked first. If no matches for that are found,
   look at the whole path.
 
   
 Bug fixes
 ---------
 
 * The Windows installer has been fixed.  Now all IPython scripts have ``.bat``
   versions created.  Also, the Start Menu shortcuts have been updated.
 
 * The colors escapes in the multiengine client are now turned off on win32 as
   they don't print correctly.
 
 * The :mod:`IPython.kernel.scripts.ipengine` script was exec'ing
   mpi_import_statement incorrectly, which was leading the engine to crash when
   mpi was enabled.
 
 * A few subpackages had missing ``__init__.py`` files.
 
 * The documentation is only created if Sphinx is found.  Previously, the
   ``setup.py`` script would fail if it was missing.
 
 * Greedy ``cd`` completion has been disabled again (it was enabled in 0.8.4) as
   it caused problems on certain platforms.
           
 
 Backwards incompatible changes
 ------------------------------
 
 * The ``clusterfile`` options of the :command:`ipcluster` command has been
   removed as it was not working and it will be replaced soon by something much
   more robust.
 
 * The :mod:`IPython.kernel` configuration now properly find the user's
   IPython directory.
 
 * In ipapi, the :func:`make_user_ns` function has been replaced with
   :func:`make_user_namespaces`, to support dict subclasses in namespace
   creation.
 
 * :class:`IPython.kernel.client.Task` has been renamed
   :class:`IPython.kernel.client.StringTask` to make way for new task types.
 
 * The keyword argument `style` has been renamed `dist` in `scatter`, `gather`
   and `map`.
 
 * Renamed the values that the rename `dist` keyword argument can have from
   `'basic'` to `'b'`.
 
 * IPython has a larger set of dependencies if you want all of its capabilities.
   See the `setup.py` script for details.
 
 * The constructors for :class:`IPython.kernel.client.MultiEngineClient` and 
   :class:`IPython.kernel.client.TaskClient` no longer take the (ip,port) tuple.
   Instead they take the filename of a file that contains the FURL for that
   client.  If the FURL file is in your IPYTHONDIR, it will be found automatically
   and the constructor can be left empty.
 
 * The asynchronous clients in :mod:`IPython.kernel.asyncclient` are now created 
   using the factory functions :func:`get_multiengine_client` and 
   :func:`get_task_client`.  These return a `Deferred` to the actual client.
 
 * The command line options to `ipcontroller` and `ipengine` have changed to
   reflect the new Foolscap network protocol and the FURL files.  Please see the
   help for these scripts for details.
 
 * The configuration files for the kernel have changed because of the Foolscap
   stuff.  If you were using custom config files before, you should delete them
   and regenerate new ones.
 
 Changes merged in from IPython1
 -------------------------------
 
 New features
 ............
 
 * Much improved ``setup.py`` and ``setupegg.py`` scripts.  Because Twisted and
   zope.interface are now easy installable, we can declare them as dependencies
   in our setupegg.py script.
 
 * IPython is now compatible with Twisted 2.5.0 and 8.x.
 
 * Added a new example of how to use :mod:`ipython1.kernel.asynclient`.
 
 * Initial draft of a process daemon in :mod:`ipython1.daemon`.  This has not
   been merged into IPython and is still in `ipython1-dev`.
   
 * The ``TaskController`` now has methods for getting the queue status.
 
 * The ``TaskResult`` objects not have information about how long the task
   took to run.
   
 * We are attaching additional attributes to exceptions ``(_ipython_*)`` that 
   we use to carry additional info around.
   
 * New top-level module :mod:`asyncclient` that has asynchronous versions (that
   return deferreds) of the client classes.  This is designed to users who want
   to run their own Twisted reactor.
   
 * All the clients in :mod:`client` are now based on Twisted.  This is done by 
   running the Twisted reactor in a separate thread and using the
   :func:`blockingCallFromThread` function that is in recent versions of Twisted.
 
 * Functions can now be pushed/pulled to/from engines using
   :meth:`MultiEngineClient.push_function` and
   :meth:`MultiEngineClient.pull_function`.
 
 * Gather/scatter are now implemented in the client to reduce the work load
   of the controller and improve performance.
 
 * Complete rewrite of the IPython docuementation.  All of the documentation
   from the IPython website has been moved into docs/source as restructured
   text documents.  PDF and HTML documentation are being generated using 
   Sphinx.
 
 * New developer oriented documentation: development guidelines and roadmap. 
 
 * Traditional ``ChangeLog`` has been changed to a more useful ``changes.txt``
   file that is organized by release and is meant to provide something more
   relevant for users.
 
 Bug fixes
 .........
 
 * Created a proper ``MANIFEST.in`` file to create source distributions.
 
 * Fixed a bug in the ``MultiEngine`` interface.  Previously, multi-engine 
   actions were being collected with a :class:`DeferredList` with 
   ``fireononeerrback=1``.  This meant that methods were returning 
   before all engines had given their results.  This was causing extremely odd 
   bugs in certain cases. To fix this problem, we have 1) set 
   ``fireononeerrback=0`` to make sure all results (or exceptions) are in 
   before returning and 2) introduced a :exc:`CompositeError` exception 
   that wraps all of the engine exceptions.  This is a huge change as it means 
   that users will have to catch :exc:`CompositeError` rather than the actual
   exception.
 
 Backwards incompatible changes
 ..............................
 
 * All names have been renamed to conform to the lowercase_with_underscore
   convention.  This will require users to change references to all names like
   ``queueStatus`` to ``queue_status``.
 
 * Previously, methods like :meth:`MultiEngineClient.push` and
   :meth:`MultiEngineClient.push` used ``*args`` and ``**kwargs``.  This was
   becoming a problem as we weren't able to introduce new keyword arguments into
   the API.  Now these methods simple take a dict or sequence.  This has also
   allowed us to get rid of the ``*All`` methods like :meth:`pushAll` and
   :meth:`pullAll`.  These things are now handled with the ``targets`` keyword
   argument that defaults to ``'all'``.
 
 * The :attr:`MultiEngineClient.magicTargets` has been renamed to
   :attr:`MultiEngineClient.targets`. 
 
 * All methods in the MultiEngine interface now accept the optional keyword
   argument ``block``.
 
 * Renamed :class:`RemoteController` to :class:`MultiEngineClient` and 
   :class:`TaskController` to :class:`TaskClient`.
 
 * Renamed the top-level module from :mod:`api` to :mod:`client`.
 
 * Most methods in the multiengine interface now raise a :exc:`CompositeError`
   exception that wraps the user's exceptions, rather than just raising the raw
   user's exception.
 
 * Changed the ``setupNS`` and ``resultNames`` in the ``Task`` class to ``push`` 
   and ``pull``.
 
   
 Release 0.8.4
 =============
 
 This was a quick release to fix an unfortunate bug that slipped into the 0.8.3
 release.  The ``--twisted`` option was disabled, as it turned out to be broken
 across several platforms.
 
 
 Release 0.8.3
 =============
   
 * pydb is now disabled by default (due to %run -d problems). You can enable
   it by passing -pydb command line argument to IPython. Note that setting
   it in config file won't work.
 
   
 Release 0.8.2
 =============
 
 * %pushd/%popd behave differently; now "pushd /foo" pushes CURRENT directory 
   and jumps to /foo. The current behaviour is closer to the documented 
   behaviour, and should not trip anyone.
 
   
 Older releases
 ==============
 
 Changes in earlier releases of IPython are described in the older file
 ``ChangeLog``.  Please refer to this document for details.
 

docs/source/history.txt

@@ -1,38 +1,38 b''
 .. _history:
 
 =======
 History
 =======
 
 Origins
 =======
 
-IPython was starting in 2001 by Fernando Perez.  IPython as we know it
+IPython was started in 2001 by Fernando Perez.  IPython as we know it
 today grew out of the following three projects:
 
 * ipython by Fernando Pérez. I was working on adding
   Mathematica-type prompts and a flexible configuration system
   (something better than $PYTHONSTARTUP) to the standard Python
   interactive interpreter.
 * IPP by Janko Hauser. Very well organized, great usability. Had
   an old help system. IPP was used as the 'container' code into
   which I added the functionality from ipython and LazyPython.
 * LazyPython by Nathan Gray. Simple but very powerful. The quick
   syntax (auto parens, auto quotes) and verbose/colored tracebacks
   were all taken from here.
 
 Here is how Fernando describes it:
 
     When I found out about IPP and LazyPython I tried to join all three
     into a unified system. I thought this could provide a very nice
     working environment, both for regular programming and scientific
     computing: shell-like features, IDL/Matlab numerics, Mathematica-type
     prompt history and great object introspection and help facilities. I
     think it worked reasonably well, though it was a lot more work than I
     had initially planned.
 
 Today and how we got here
 =========================
 
 This needs to be filled in.
 

docs/sphinxext/numpydoc.py

@@ -1,116 +1,117 b''
 """
 ========
 numpydoc
 ========
 
 Sphinx extension that handles docstrings in the Numpy standard format. [1]
 
 It will:
 
 - Convert Parameters etc. sections to field lists.
 - Convert See Also section to a See also entry.
 - Renumber references.
 - Extract the signature from the docstring, if it can't be determined otherwise.
 
 .. [1] http://projects.scipy.org/scipy/numpy/wiki/CodingStyleGuidelines#docstring-standard
 
 """
 
 import os, re, pydoc
 from docscrape_sphinx import get_doc_object, SphinxDocString
 import inspect
 
 def mangle_docstrings(app, what, name, obj, options, lines,
                       reference_offset=[0]):
     if what == 'module':
         # Strip top title
         title_re = re.compile(r'^\s*[#*=]{4,}\n[a-z0-9 -]+\n[#*=]{4,}\s*',
                               re.I|re.S)
         lines[:] = title_re.sub('', "\n".join(lines)).split("\n")
     else:
         doc = get_doc_object(obj, what, "\n".join(lines))
         lines[:] = str(doc).split("\n")
 
     if app.config.numpydoc_edit_link and hasattr(obj, '__name__') and \
            obj.__name__:
         if hasattr(obj, '__module__'):
             v = dict(full_name="%s.%s" % (obj.__module__, obj.__name__))
         else:
             v = dict(full_name=obj.__name__)
         lines += ['', '.. htmlonly::', '']
         lines += ['    %s' % x for x in
                   (app.config.numpydoc_edit_link % v).split("\n")]
 
     # replace reference numbers so that there are no duplicates
     references = []
     for l in lines:
         l = l.strip()
         if l.startswith('.. ['):
             try:
                 references.append(int(l[len('.. ['):l.index(']')]))
             except ValueError:
                 print "WARNING: invalid reference in %s docstring" % name
 
     # Start renaming from the biggest number, otherwise we may
     # overwrite references.
     references.sort()
     if references:
         for i, line in enumerate(lines):
             for r in references:
                 new_r = reference_offset[0] + r
                 lines[i] = lines[i].replace('[%d]_' % r,
                                             '[%d]_' % new_r)
                 lines[i] = lines[i].replace('.. [%d]' % r,
                                             '.. [%d]' % new_r)
 
     reference_offset[0] += len(references)
 
 def mangle_signature(app, what, name, obj, options, sig, retann):
     # Do not try to inspect classes that don't define `__init__`
-    if (inspect.isclass(obj) and
-        'initializes x; see ' in pydoc.getdoc(obj.__init__)):
+    init = getattr(obj, '__init__', None)
+    if (init is not None and
+        'initializes x; see ' in pydoc.getdoc(init)):
         return '', ''
 
     if not (callable(obj) or hasattr(obj, '__argspec_is_invalid_')): return
     if not hasattr(obj, '__doc__'): return
 
     doc = SphinxDocString(pydoc.getdoc(obj))
     if doc['Signature']:
         sig = re.sub("^[^(]*", "", doc['Signature'])
         return sig, ''
 
 def initialize(app):
     try:
         app.connect('autodoc-process-signature', mangle_signature)
     except:
         monkeypatch_sphinx_ext_autodoc()
 
 def setup(app, get_doc_object_=get_doc_object):
     global get_doc_object
     get_doc_object = get_doc_object_
     
     app.connect('autodoc-process-docstring', mangle_docstrings)
     app.connect('builder-inited', initialize)
     app.add_config_value('numpydoc_edit_link', None, True)
 
 #------------------------------------------------------------------------------
 # Monkeypatch sphinx.ext.autodoc to accept argspecless autodocs (Sphinx < 0.5)
 #------------------------------------------------------------------------------
 
 def monkeypatch_sphinx_ext_autodoc():
     global _original_format_signature
     import sphinx.ext.autodoc
 
     if sphinx.ext.autodoc.format_signature is our_format_signature:
         return
 
     print "[numpydoc] Monkeypatching sphinx.ext.autodoc ..."
     _original_format_signature = sphinx.ext.autodoc.format_signature
     sphinx.ext.autodoc.format_signature = our_format_signature
 
 def our_format_signature(what, obj):
     r = mangle_signature(None, what, None, obj, None, None, None)
     if r is not None:
         return r[0]
     else:
         return _original_format_signature(what, obj)

tools/build_release

@@ -1,35 +1,37 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','Release.py'))
 
 # Check that everything compiles
 compile_tree()
 
 # Cleanup
-for d in ['build','dist',pjoin('docs','build'),pjoin('docs','dist')]:
+for d in ['build','dist',pjoin('docs','build'),pjoin('docs','dist'),
+          pjoin('docs','source','api','generated')]:
     if os.path.isdir(d):
         remove_tree(d)
 
 # Build source and binary distros
 c('./setup.py sdist --formats=gztar,zip')
 
+
 # Build eggs
-c('python2.5 ./setupegg.py bdist_egg')
+#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")
 c("rename 's/linux-x86_64/win32-setup/' dist/*.exe")

tools/make_tarball.py

@@ -1,21 +1,25 b''
 #!/usr/bin/env python
-"""Simple script to create a tarball with proper bzr version info.
+"""Simple script to create a tarball with proper git info.
 """
 
+import commands
 import os
 import sys
 import shutil
 
 from  toollib import *
 
-execfile('../IPython/Release.py')  # defines version_base
+tag = commands.getoutput('git describe')
+base_name = 'ipython-%s' % tag
+tar_name = '%s.tgz' % base_name
 
-ver = version_info()
+# git archive is weird:  Even if I give it a specific path, it still won't
+# archive the whole tree.  It seems the only way to get the whole tree is to cd
+# to the top of the tree.  There are long threads (since 2007) on the git list
+# about this and it still doesn't work in a sensible way...
 
-if ver['branch-nick'] == 'ipython':
-    tarname = 'ipython-%s.bzr.r%s.tgz' % (version_base, ver['revno'])
-else:
-    tarname = 'ipython-%s.bzr.r%s.%s.tgz' % (version_base, ver['revno'],
-                                             ver['branch-nick'])
-    
-c('bzr export ' + tarname)
+start_dir = os.getcwd()
+cd('..')
+git_tpl = 'git archive --format=tar --prefix={0}/ HEAD | gzip > {1}'
+c(git_tpl.format(base_name, tar_name))
+c('mv {0} tools/'.format(tar_name))

tools/release

@@ -1,51 +1,52 b''
 #!/usr/bin/env python
 """IPython release script.
 
 This should only be run at real release time.
 """
 
 from toollib import *
 
 # Get main ipython dir, this will raise if it doesn't pass some checks
 ipdir = get_ipdir()
 tooldir = pjoin(ipdir,'tools')
 distdir = pjoin(ipdir,'dist')
 # Where I keep static backups of each release
 ipbackupdir = os.path.expanduser('~/ipython/backup')
 
 # Start in main IPython dir
 cd(ipdir)
 
 # Load release info
 execfile(pjoin('IPython','Release.py'))
 
 print
 print "Releasing IPython version $version"
 print "=================================="
 print
 print 'Source IPython directory:', ipdir
 print
 
 # Perform local backup, go to tools dir to run it.
 cd(tooldir)
 c('./make_tarball.py')
 c('mv ipython-*.tgz %s' % ipbackupdir)
 
 # Build release files
 c('./build_release %s' % ipdir)
 
 # Register with the Python Package Index (PyPI)
 print "Registering with PyPI..."
 cd(ipdir)
 c('./setup.py register')
 
 # Upload all files
+c('./setup.py sdist --formats=gztar,zip upload')
 cd(distdir)
 print "Uploading distribution files..."
 c('scp * [e-mail]:www/dist/')
 
 print "Uploading backup files..."
 cd(ipbackupdir)
 c('scp `ls -1tr *tgz | tail -1` [e-mail]:www/backup/')
 
 print "Done!"

tools/toollib.py

@@ -1,55 +1,48 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))