Track upstream

IPython/frontend/cocoa/plugin/CocoaFrontendPlugin.xcodeproj/project.pbxproj

@@ -0,0 +1,256 b''
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 42;
+	objects = {
+
+/* Begin PBXContainerItemProxy section */
+		4C5B7ADB0E1A0BCD006CB905 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 4C96F4FE0E199AB500B03430 /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 4C96F50C0E199AF100B03430;
+			remoteInfo = "Cocoa Frontend Plugin";
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXFileReference section */
+		4C5B7A8D0E1A0B4C006CB905 /* Plugin-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "Plugin-Info.plist"; sourceTree = "<group>"; };
+		4C5B7AD30E1A0BC8006CB905 /* Placeholder (Do Not Use).bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "Placeholder (Do Not Use).bundle"; sourceTree = BUILT_PRODUCTS_DIR; };
+		4C5B7AD40E1A0BC8006CB905 /* Placeholder (Do Not Use)-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "Placeholder (Do Not Use)-Info.plist"; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		4C5B7AD10E1A0BC8006CB905 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		4C5B7A8C0E1A0B4C006CB905 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				4C5B7AD30E1A0BC8006CB905 /* Placeholder (Do Not Use).bundle */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		4C96F4FC0E199AB500B03430 = {
+			isa = PBXGroup;
+			children = (
+				4C5B7A8C0E1A0B4C006CB905 /* Products */,
+				4C5B7A8D0E1A0B4C006CB905 /* Plugin-Info.plist */,
+				4C5B7AD40E1A0BC8006CB905 /* Placeholder (Do Not Use)-Info.plist */,
+			);
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXLegacyTarget section */
+		4C96F50C0E199AF100B03430 /* Cocoa Frontend Plugin */ = {
+			isa = PBXLegacyTarget;
+			buildArgumentsString = "$(ACTION)";
+			buildConfigurationList = 4C96F5110E199B3300B03430 /* Build configuration list for PBXLegacyTarget "Cocoa Frontend Plugin" */;
+			buildPhases = (
+			);
+			buildToolPath = /usr/bin/make;
+			buildWorkingDirectory = "";
+			dependencies = (
+			);
+			name = "Cocoa Frontend Plugin";
+			passBuildSettingsInEnvironment = 1;
+			productName = "Cocoa Frontend Plugin";
+		};
+/* End PBXLegacyTarget section */
+
+/* Begin PBXNativeTarget section */
+		4C5B7AD20E1A0BC8006CB905 /* Placeholder (Do Not Use) */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 4C5B7ADA0E1A0BC9006CB905 /* Build configuration list for PBXNativeTarget "Placeholder (Do Not Use)" */;
+			buildPhases = (
+				4C5B7ACF0E1A0BC8006CB905 /* Resources */,
+				4C5B7AD00E1A0BC8006CB905 /* Sources */,
+				4C5B7AD10E1A0BC8006CB905 /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				4C5B7ADC0E1A0BCD006CB905 /* PBXTargetDependency */,
+			);
+			name = "Placeholder (Do Not Use)";
+			productName = "Placeholder (Do Not Use)";
+			productReference = 4C5B7AD30E1A0BC8006CB905 /* Placeholder (Do Not Use).bundle */;
+			productType = "com.apple.product-type.bundle";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		4C96F4FE0E199AB500B03430 /* Project object */ = {
+			isa = PBXProject;
+			buildConfigurationList = 4C96F5010E199AB500B03430 /* Build configuration list for PBXProject "CocoaFrontendPlugin" */;
+			compatibilityVersion = "Xcode 2.4";
+			hasScannedForEncodings = 0;
+			mainGroup = 4C96F4FC0E199AB500B03430;
+			productRefGroup = 4C5B7A8C0E1A0B4C006CB905 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				4C96F50C0E199AF100B03430 /* Cocoa Frontend Plugin */,
+				4C5B7AD20E1A0BC8006CB905 /* Placeholder (Do Not Use) */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		4C5B7ACF0E1A0BC8006CB905 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		4C5B7AD00E1A0BC8006CB905 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		4C5B7ADC0E1A0BCD006CB905 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 4C96F50C0E199AF100B03430 /* Cocoa Frontend Plugin */;
+			targetProxy = 4C5B7ADB0E1A0BCD006CB905 /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin XCBuildConfiguration section */
+		4C5B7AD50E1A0BC9006CB905 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = NO;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_ENABLE_FIX_AND_CONTINUE = YES;
+				GCC_MODEL_TUNING = G5;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PRECOMPILE_PREFIX_HEADER = YES;
+				GCC_PREFIX_HEADER = "$(SYSTEM_LIBRARY_DIR)/Frameworks/AppKit.framework/Headers/AppKit.h";
+				INFOPLIST_FILE = "Placeholder (Do Not Use)-Info.plist";
+				INSTALL_PATH = "$(HOME)/Library/Bundles";
+				OTHER_LDFLAGS = (
+					"-framework",
+					Foundation,
+					"-framework",
+					AppKit,
+				);
+				PREBINDING = NO;
+				PRODUCT_NAME = "Placeholder (Do Not Use)";
+				WRAPPER_EXTENSION = bundle;
+				ZERO_LINK = YES;
+			};
+			name = Debug;
+		};
+		4C5B7AD60E1A0BC9006CB905 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = YES;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_ENABLE_FIX_AND_CONTINUE = NO;
+				GCC_MODEL_TUNING = G5;
+				GCC_PRECOMPILE_PREFIX_HEADER = YES;
+				GCC_PREFIX_HEADER = "$(SYSTEM_LIBRARY_DIR)/Frameworks/AppKit.framework/Headers/AppKit.h";
+				INFOPLIST_FILE = "Placeholder (Do Not Use)-Info.plist";
+				INSTALL_PATH = "$(HOME)/Library/Bundles";
+				OTHER_LDFLAGS = (
+					"-framework",
+					Foundation,
+					"-framework",
+					AppKit,
+				);
+				PREBINDING = NO;
+				PRODUCT_NAME = "Placeholder (Do Not Use)";
+				WRAPPER_EXTENSION = bundle;
+				ZERO_LINK = NO;
+			};
+			name = Release;
+		};
+		4C96F4FF0E199AB500B03430 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = NO;
+			};
+			name = Debug;
+		};
+		4C96F5000E199AB500B03430 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = YES;
+			};
+			name = Release;
+		};
+		4C96F50D0E199AF100B03430 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = NO;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				PRODUCT_NAME = "Cocoa Frontend Plugin";
+			};
+			name = Debug;
+		};
+		4C96F50E0E199AF100B03430 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = YES;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_ENABLE_FIX_AND_CONTINUE = NO;
+				PRODUCT_NAME = "Cocoa Frontend Plugin";
+				ZERO_LINK = NO;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		4C5B7ADA0E1A0BC9006CB905 /* Build configuration list for PBXNativeTarget "Placeholder (Do Not Use)" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4C5B7AD50E1A0BC9006CB905 /* Debug */,
+				4C5B7AD60E1A0BC9006CB905 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4C96F5010E199AB500B03430 /* Build configuration list for PBXProject "CocoaFrontendPlugin" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4C96F4FF0E199AB500B03430 /* Debug */,
+				4C96F5000E199AB500B03430 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4C96F5110E199B3300B03430 /* Build configuration list for PBXLegacyTarget "Cocoa Frontend Plugin" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4C96F50D0E199AF100B03430 /* Debug */,
+				4C96F50E0E199AF100B03430 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 4C96F4FE0E199AB500B03430 /* Project object */;
+}

IPython/frontend/cocoa/plugin/IPythonCocoaFrontendLoader.py

@@ -0,0 +1,25 b''
+# encoding: utf-8
+"""
+Provides a namespace for loading the Cocoa frontend via a Cocoa plugin.
+
+Author: Barry Wark
+"""
+__docformat__ = "restructuredtext en"
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+from PyObjCTools import AppHelper
+from twisted.internet import _threadedselect
+
+#make sure _threadedselect is installed first
+reactor = _threadedselect.install()
+
+# load the Cocoa frontend controller
+from IPython.frontend.cocoa.cocoa_frontend import IPythonCocoaController
+reactor.interleave(AppHelper.callAfter)
+assert(reactor.running)

IPython/frontend/cocoa/plugin/Makefile

@@ -0,0 +1,6 b''
+include ./plugins.mk
+
+all : dist/IPythonCocoaController.plugin
+
+dist/IPythonCocoaController.plugin : ./IPythonCocoaFrontendLoader.py\
+ ./setup.py
  No newline at end of file

IPython/frontend/cocoa/plugin/Placeholder (Do Not Use)-Info.plist

@@ -0,0 +1,20 b''
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.yourcompany.Placeholder (Do Not Use)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundlePackageType</key>
+	<string>BNDL</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

IPython/frontend/cocoa/plugin/plugins.mk

@@ -0,0 +1,21 b''
+%.plugin::
+	rm -rf dist/$(notdir $@)
+	rm -rf build dist && \
+	python setup.py py2app -s
+
+%.py:
+	@echo "test -f $@"
+	@test -f %@
+
+%.nib:
+	@echo "test -f $@"
+	@test -f %@
+
+.DEFAULT_GOAL := all
+
+.PHONY : all clean
+
+clean :
+	rm -rf build dist
+
+

IPython/frontend/cocoa/plugin/setup.py

@@ -0,0 +1,35 b''
+# encoding: utf-8
+"""
+setup.py
+
+Setuptools installer script for generating a Cocoa plugin for the 
+IPython cocoa frontend
+
+Author: Barry Wark
+"""
+__docformat__ = "restructuredtext en"
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+from setuptools import setup
+
+infoPlist = dict(
+	CFBundleDevelopmentRegion='English',
+	CFBundleIdentifier='org.scipy.ipython.cocoa_frontend',
+	NSPrincipalClass='IPythonCocoaController',
+)
+
+setup(
+	plugin=['IPythonCocoaFrontendLoader.py'],
+    setup_requires=['py2app'],
+	options=dict(py2app=dict(
+		plist=infoPlist,
+		site_packages=True,
+		excludes=['IPython','twisted','PyObjCTools']
+	)),
+)
  No newline at end of file

IPython/testing/plugin/Makefile

@@ -0,0 +1,20 b''
+# Set this prefix to where you want to install the plugin
+PREFIX=~/usr/local
+PREFIX=~/tmp/local
+
+plugin: IPython_doctest_plugin.egg-info
+
+test: plugin dtexample.py
+	nosetests -s --with-ipdoctest --doctest-tests --doctest-extension=txt \
+	dtexample.py test*.txt
+
+deb: plugin dtexample.py
+	nosetests -vs --with-ipdoctest --doctest-tests --doctest-extension=txt \
+        test_combo.txt
+
+IPython_doctest_plugin.egg-info: ipdoctest.py setup.py
+	python setup.py install --prefix=$(PREFIX)
+	touch $@
+
+clean:
+	rm -rf IPython_doctest_plugin.egg-info *~ *pyc build/ dist/

IPython/testing/plugin/README.txt

@@ -0,0 +1,39 b''
+=======================================================
+ Nose plugin with IPython and extension module support
+=======================================================
+
+This directory provides the key functionality for test support that IPython
+needs as a nose plugin, which can be installed for use in projects other than
+IPython.
+
+The presence of a Makefile here is mostly for development and debugging
+purposes as it only provides a few shorthand commands.  You can manually
+install the plugin by using standard Python procedures (``setup.py install``
+with appropriate arguments).
+
+To install the plugin using the Makefile, edit its first line to reflect where
+you'd like the installation.  If you want it system-wide, you may want to edit
+the install line in the plugin target to use sudo and no prefix::
+
+  sudo python setup.py install
+
+instead of the code using `--prefix` that's in there.
+
+Once you've set the prefix, simply build/install the plugin with::
+
+  make
+
+and run the tests with::
+
+  make test
+
+You should see output similar to::
+
+  maqroll[plugin]> make test
+  nosetests -s --with-ipdoctest --doctest-tests dtexample.py
+  ..
+  ----------------------------------------------------------------------
+  Ran 2 tests in 0.016s
+
+  OK
+

IPython/testing/plugin/dtexample.py

@@ -0,0 +1,72 b''
+"""Simple example using doctests.
+
+This file just contains doctests both using plain python and IPython prompts.
+All tests should be loaded by nose.
+"""
+
+def pyfunc():
+    """Some pure python tests...
+
+    >>> pyfunc()
+    'pyfunc'
+
+    >>> import os
+
+    >>> 2+3
+    5
+
+    >>> for i in range(3):
+    ...     print i,
+    ...     print i+1,
+    ...
+    0 1 1 2 2 3
+    """
+
+    return 'pyfunc'
+
+def ipfunc():
+    """Some ipython tests...
+
+    In [1]: import os
+
+    In [2]: cd /
+    /
+
+    In [3]: 2+3
+    Out[3]: 5
+
+    In [26]: for i in range(3):
+       ....:     print i,
+       ....:     print i+1,
+       ....:
+    0 1 1 2 2 3
+
+
+    Examples that access the operating system work:
+
+    In [1]: !echo hello
+    hello
+
+    In [2]: !echo hello > /tmp/foo
+
+    In [3]: !cat /tmp/foo
+    hello
+
+    In [4]: rm -f /tmp/foo
+
+    It's OK to use '_' for the last result, but do NOT try to use IPython's
+    numbered history of _NN outputs, since those won't exist under the
+    doctest environment:
+
+    In [7]: 3+4
+    Out[7]: 7
+
+    In [8]: _+3
+    Out[8]: 10
+
+    In [9]: ipfunc()
+    Out[9]: 'ipfunc'
+    """
+
+    return 'ipfunc'
+

IPython/testing/plugin/ipdoctest.py

@@ -0,0 +1,587 b''
+"""Nose Plugin that supports IPython doctests.
+
+Limitations:
+
+- When generating examples for use as doctests, make sure that you have
+  pretty-printing OFF.  This can be done either by starting ipython with the
+  flag '--nopprint', by setting pprint to 0 in your ipythonrc file, or by
+  interactively disabling it with %Pprint.  This is required so that IPython
+  output matches that of normal Python, which is used by doctest for internal
+  execution.
+
+- Do not rely on specific prompt numbers for results (such as using
+  '_34==True', for example).  For IPython tests run via an external process the
+  prompt numbers may be different, and IPython tests run as normal python code
+  won't even have these special _NN variables set at all.
+
+- IPython functions that produce output as a side-effect of calling a system
+  process (e.g. 'ls') can be doc-tested, but they must be handled in an
+  external IPython process.  Such doctests must be tagged with:
+
+        # ipdoctest: EXTERNAL
+
+  so that the testing machinery handles them differently.  Since these are run
+  via pexpect in an external process, they can't deal with exceptions or other
+  fancy featurs of regular doctests.  You must limit such tests to simple
+  matching of the output.  For this reason, I recommend you limit these kinds
+  of doctests to features that truly require a separate process, and use the
+  normal IPython ones (which have all the features of normal doctests) for
+  everything else.  See the examples at the bottom of this file for a
+  comparison of what can be done with both types.
+"""
+
+
+#-----------------------------------------------------------------------------
+# Module imports
+
+# From the standard library
+import __builtin__
+import commands
+import doctest
+import inspect
+import logging
+import os
+import re
+import sys
+import unittest
+
+from inspect import getmodule
+
+# Third-party modules
+import nose.core
+
+from nose.plugins import doctests, Plugin
+from nose.util import anyp, getpackage, test_address, resolve_name, tolist
+
+# Our own imports
+#from extdoctest import ExtensionDoctest, DocTestFinder
+#from dttools import DocTestFinder, DocTestCase
+#-----------------------------------------------------------------------------
+# Module globals and other constants
+
+log = logging.getLogger(__name__)
+
+###########################################################################
+# *** HACK ***
+# We must start our own ipython object and heavily muck with it so that all the
+# modifications IPython makes to system behavior don't send the doctest
+# machinery into a fit.  This code should be considered a gross hack, but it
+# gets the job done.
+
+def start_ipython():
+    """Start a global IPython shell, which we need for IPython-specific syntax.
+    """
+    import IPython
+
+    def xsys(cmd):
+        """Execute a command and print its output.
+
+        This is just a convenience function to replace the IPython system call
+        with one that is more doctest-friendly.
+        """
+        cmd = _ip.IP.var_expand(cmd,depth=1)
+        sys.stdout.write(commands.getoutput(cmd))
+        sys.stdout.flush()
+
+    # Store certain global objects that IPython modifies
+    _displayhook = sys.displayhook
+    _excepthook = sys.excepthook
+    _main = sys.modules.get('__main__')
+
+    # Start IPython instance
+    IPython.Shell.IPShell(['--classic','--noterm_title'])
+
+    # Deactivate the various python system hooks added by ipython for
+    # interactive convenience so we don't confuse the doctest system
+    sys.modules['__main__'] = _main
+    sys.displayhook = _displayhook
+    sys.excepthook = _excepthook
+
+    # So that ipython magics and aliases can be doctested (they work by making
+    # a call into a global _ip object)
+    _ip = IPython.ipapi.get()
+    __builtin__._ip = _ip
+
+    # Modify the IPython system call with one that uses getoutput, so that we
+    # can capture subcommands and print them to Python's stdout, otherwise the
+    # doctest machinery would miss them.
+    _ip.system = xsys
+
+# The start call MUST be made here.  I'm not sure yet why it doesn't work if
+# it is made later, at plugin initialization time, but in all my tests, that's
+# the case.
+start_ipython()
+
+# *** END HACK ***
+###########################################################################
+
+#-----------------------------------------------------------------------------
+# Modified version of the one in the stdlib, that fixes a python bug (doctests
+# not found in extension modules, http://bugs.python.org/issue3158)
+class DocTestFinder(doctest.DocTestFinder):
+
+    def _from_module(self, module, object):
+        """
+        Return true if the given object is defined in the given
+        module.
+        """
+        if module is None:
+            #print '_fm C1'  # dbg
+            return True
+        elif inspect.isfunction(object):
+            #print '_fm C2'  # dbg
+            return module.__dict__ is object.func_globals
+        elif inspect.isbuiltin(object):
+            #print '_fm C2-1'  # dbg
+            return module.__name__ == object.__module__
+        elif inspect.isclass(object):
+            #print '_fm C3'  # dbg
+            return module.__name__ == object.__module__
+        elif inspect.ismethod(object):
+            # This one may be a bug in cython that fails to correctly set the
+            # __module__ attribute of methods, but since the same error is easy
+            # to make by extension code writers, having this safety in place
+            # isn't such a bad idea
+            #print '_fm C3-1'  # dbg
+            return module.__name__ == object.im_class.__module__
+        elif inspect.getmodule(object) is not None:
+            #print '_fm C4'  # dbg
+            #print 'C4 mod',module,'obj',object # dbg
+            return module is inspect.getmodule(object)
+        elif hasattr(object, '__module__'):
+            #print '_fm C5'  # dbg
+            return module.__name__ == object.__module__
+        elif isinstance(object, property):
+            #print '_fm C6'  # dbg
+            return True # [XX] no way not be sure.
+        else:
+            raise ValueError("object must be a class or function")
+
+
+
+    def _find(self, tests, obj, name, module, source_lines, globs, seen):
+        """
+        Find tests for the given object and any contained objects, and
+        add them to `tests`.
+        """
+
+        doctest.DocTestFinder._find(self,tests, obj, name, module,
+                                    source_lines, globs, seen)
+
+        # Below we re-run pieces of the above method with manual modifications,
+        # because the original code is buggy and fails to correctly identify
+        # doctests in extension modules.
+
+        # Local shorthands
+        from inspect import isroutine, isclass, ismodule
+
+        # Look for tests in a module's contained objects.
+        if inspect.ismodule(obj) and self._recurse:
+            for valname, val in obj.__dict__.items():
+                valname1 = '%s.%s' % (name, valname)
+                if ( (isroutine(val) or isclass(val))
+                     and self._from_module(module, val) ):
+
+                    self._find(tests, val, valname1, module, source_lines,
+                               globs, seen)
+
+
+        # Look for tests in a class's contained objects.
+        if inspect.isclass(obj) and self._recurse:
+            #print 'RECURSE into class:',obj  # dbg
+            for valname, val in obj.__dict__.items():
+                #valname1 = '%s.%s' % (name, valname)  # dbg
+                #print 'N',name,'VN:',valname,'val:',str(val)[:77] # dbg
+                # Special handling for staticmethod/classmethod.
+                if isinstance(val, staticmethod):
+                    val = getattr(obj, valname)
+                if isinstance(val, classmethod):
+                    val = getattr(obj, valname).im_func
+
+                # Recurse to methods, properties, and nested classes.
+                if ((inspect.isfunction(val) or inspect.isclass(val) or
+                     inspect.ismethod(val) or
+                      isinstance(val, property)) and
+                      self._from_module(module, val)):
+                    valname = '%s.%s' % (name, valname)
+                    self._find(tests, val, valname, module, source_lines,
+                               globs, seen)
+
+
+class DocTestCase(doctests.DocTestCase):
+    """Proxy for DocTestCase: provides an address() method that
+    returns the correct address for the doctest case. Otherwise
+    acts as a proxy to the test case. To provide hints for address(),
+    an obj may also be passed -- this will be used as the test object
+    for purposes of determining the test address, if it is provided.
+    """
+
+    # doctests loaded via find(obj) omit the module name
+    # so we need to override id, __repr__ and shortDescription
+    # bonus: this will squash a 2.3 vs 2.4 incompatiblity
+    def id(self):
+        name = self._dt_test.name
+        filename = self._dt_test.filename
+        if filename is not None:
+            pk = getpackage(filename)
+            if pk is not None and not name.startswith(pk):
+                name = "%s.%s" % (pk, name)
+        return name
+
+
+# Classes and functions
+
+def is_extension_module(filename):
+    """Return whether the given filename is an extension module.
+
+    This simply checks that the extension is either .so or .pyd.
+    """
+    return os.path.splitext(filename)[1].lower() in ('.so','.pyd')
+
+
+# A simple subclassing of the original with a different class name, so we can
+# distinguish and treat differently IPython examples from pure python ones.
+class IPExample(doctest.Example): pass
+
+class IPExternalExample(doctest.Example):
+    """Doctest examples to be run in an external process."""
+
+    def __init__(self, source, want, exc_msg=None, lineno=0, indent=0,
+                 options=None):
+        # Parent constructor
+        doctest.Example.__init__(self,source,want,exc_msg,lineno,indent,options)
+
+        # An EXTRA newline is needed to prevent pexpect hangs
+        self.source += '\n'
+
+class IPDocTestParser(doctest.DocTestParser):
+    """
+    A class used to parse strings containing doctest examples.
+
+    Note: This is a version modified to properly recognize IPython input and
+    convert any IPython examples into valid Python ones.
+    """
+    # This regular expression is used to find doctest examples in a
+    # string.  It defines three groups: `source` is the source code
+    # (including leading indentation and prompts); `indent` is the
+    # indentation of the first (PS1) line of the source code; and
+    # `want` is the expected output (including leading indentation).
+
+    # Classic Python prompts or default IPython ones
+    _PS1_PY = r'>>>'
+    _PS2_PY = r'\.\.\.'
+
+    _PS1_IP = r'In\ \[\d+\]:'
+    _PS2_IP = r'\ \ \ \.\.\.+:'
+
+    _RE_TPL = r'''
+        # Source consists of a PS1 line followed by zero or more PS2 lines.
+        (?P<source>
+            (?:^(?P<indent> [ ]*) (?P<ps1> %s) .*)    # PS1 line
+            (?:\n           [ ]*  (?P<ps2> %s) .*)*)  # PS2 lines
+        \n? # a newline
+        # Want consists of any non-blank lines that do not start with PS1.
+        (?P<want> (?:(?![ ]*$)    # Not a blank line
+                     (?![ ]*%s)   # Not a line starting with PS1
+                     (?![ ]*%s)   # Not a line starting with PS2
+                     .*$\n?       # But any other line
+                  )*)
+                  '''
+
+    _EXAMPLE_RE_PY = re.compile( _RE_TPL % (_PS1_PY,_PS2_PY,_PS1_PY,_PS2_PY),
+                                 re.MULTILINE | re.VERBOSE)
+
+    _EXAMPLE_RE_IP = re.compile( _RE_TPL % (_PS1_IP,_PS2_IP,_PS1_IP,_PS2_IP),
+                                 re.MULTILINE | re.VERBOSE)
+
+    def ip2py(self,source):
+        """Convert input IPython source into valid Python."""
+        out = []
+        newline = out.append
+        for line in source.splitlines():
+            #newline(_ip.IPipython.prefilter(line,True))
+            newline(_ip.IP.prefilter(line,True))
+        newline('')  # ensure a closing newline, needed by doctest
+        return '\n'.join(out)
+
+    def parse(self, string, name='<string>'):
+        """
+        Divide the given string into examples and intervening text,
+        and return them as a list of alternating Examples and strings.
+        Line numbers for the Examples are 0-based.  The optional
+        argument `name` is a name identifying this string, and is only
+        used for error messages.
+        """
+
+        #print 'Parse string:\n',string # dbg
+
+        string = string.expandtabs()
+        # If all lines begin with the same indentation, then strip it.
+        min_indent = self._min_indent(string)
+        if min_indent > 0:
+            string = '\n'.join([l[min_indent:] for l in string.split('\n')])
+
+        output = []
+        charno, lineno = 0, 0
+
+        # Whether to convert the input from ipython to python syntax
+        ip2py = False
+        # Find all doctest examples in the string.  First, try them as Python
+        # examples, then as IPython ones
+        terms = list(self._EXAMPLE_RE_PY.finditer(string))
+        if terms:
+            # Normal Python example
+            #print '-'*70  # dbg
+            #print 'PyExample, Source:\n',string  # dbg
+            #print '-'*70  # dbg
+            Example = doctest.Example
+        else:
+            # It's an ipython example.  Note that IPExamples are run
+            # in-process, so their syntax must be turned into valid python.
+            # IPExternalExamples are run out-of-process (via pexpect) so they
+            # don't need any filtering (a real ipython will be executing them).
+            terms = list(self._EXAMPLE_RE_IP.finditer(string))
+            if re.search(r'#\s*ipdoctest:\s*EXTERNAL',string):
+                #print '-'*70  # dbg
+                #print 'IPExternalExample, Source:\n',string  # dbg
+                #print '-'*70  # dbg
+                Example = IPExternalExample
+            else:
+                #print '-'*70  # dbg
+                #print 'IPExample, Source:\n',string  # dbg
+                #print '-'*70  # dbg
+                Example = IPExample
+                ip2py = True
+
+        for m in terms:
+            # Add the pre-example text to `output`.
+            output.append(string[charno:m.start()])
+            # Update lineno (lines before this example)
+            lineno += string.count('\n', charno, m.start())
+            # Extract info from the regexp match.
+            (source, options, want, exc_msg) = \
+                     self._parse_example(m, name, lineno,ip2py)
+            if Example is IPExternalExample:
+                options[doctest.NORMALIZE_WHITESPACE] = True
+                want += '\n'
+            # Create an Example, and add it to the list.
+            if not self._IS_BLANK_OR_COMMENT(source):
+                #print 'Example source:', source # dbg
+                output.append(Example(source, want, exc_msg,
+                                      lineno=lineno,
+                                      indent=min_indent+len(m.group('indent')),
+                                      options=options))
+            # Update lineno (lines inside this example)
+            lineno += string.count('\n', m.start(), m.end())
+            # Update charno.
+            charno = m.end()
+        # Add any remaining post-example text to `output`.
+        output.append(string[charno:])
+
+        return output
+
+    def _parse_example(self, m, name, lineno,ip2py=False):
+        """
+        Given a regular expression match from `_EXAMPLE_RE` (`m`),
+        return a pair `(source, want)`, where `source` is the matched
+        example's source code (with prompts and indentation stripped);
+        and `want` is the example's expected output (with indentation
+        stripped).
+
+        `name` is the string's name, and `lineno` is the line number
+        where the example starts; both are used for error messages.
+
+        Optional:
+        `ip2py`: if true, filter the input via IPython to convert the syntax
+        into valid python.
+        """
+
+        # Get the example's indentation level.
+        indent = len(m.group('indent'))
+
+        # Divide source into lines; check that they're properly
+        # indented; and then strip their indentation & prompts.
+        source_lines = m.group('source').split('\n')
+
+        # We're using variable-length input prompts
+        ps1 = m.group('ps1')
+        ps2 = m.group('ps2')
+        ps1_len = len(ps1)
+
+        self._check_prompt_blank(source_lines, indent, name, lineno,ps1_len)
+        if ps2:
+            self._check_prefix(source_lines[1:], ' '*indent + ps2, name, lineno)
+
+        source = '\n'.join([sl[indent+ps1_len+1:] for sl in source_lines])
+
+        if ip2py:
+            # Convert source input from IPython into valid Python syntax
+            source = self.ip2py(source)
+
+        # Divide want into lines; check that it's properly indented; and
+        # then strip the indentation.  Spaces before the last newline should
+        # be preserved, so plain rstrip() isn't good enough.
+        want = m.group('want')
+        want_lines = want.split('\n')
+        if len(want_lines) > 1 and re.match(r' *$', want_lines[-1]):
+            del want_lines[-1]  # forget final newline & spaces after it
+        self._check_prefix(want_lines, ' '*indent, name,
+                           lineno + len(source_lines))
+
+        # Remove ipython output prompt that might be present in the first line
+        want_lines[0] = re.sub(r'Out\[\d+\]: \s*?\n?','',want_lines[0])
+
+        want = '\n'.join([wl[indent:] for wl in want_lines])
+
+        # If `want` contains a traceback message, then extract it.
+        m = self._EXCEPTION_RE.match(want)
+        if m:
+            exc_msg = m.group('msg')
+        else:
+            exc_msg = None
+
+        # Extract options from the source.
+        options = self._find_options(source, name, lineno)
+
+        return source, options, want, exc_msg
+
+    def _check_prompt_blank(self, lines, indent, name, lineno, ps1_len):
+        """
+        Given the lines of a source string (including prompts and
+        leading indentation), check to make sure that every prompt is
+        followed by a space character.  If any line is not followed by
+        a space character, then raise ValueError.
+
+        Note: IPython-modified version which takes the input prompt length as a
+        parameter, so that prompts of variable length can be dealt with.
+        """
+        space_idx = indent+ps1_len
+        min_len = space_idx+1
+        for i, line in enumerate(lines):
+            if len(line) >=  min_len and line[space_idx] != ' ':
+                raise ValueError('line %r of the docstring for %s '
+                                 'lacks blank after %s: %r' %
+                                 (lineno+i+1, name,
+                                  line[indent:space_idx], line))
+
+SKIP = doctest.register_optionflag('SKIP')
+
+###########################################################################
+
+class DocFileCase(doctest.DocFileCase):
+    """Overrides to provide filename
+    """
+    def address(self):
+        return (self._dt_test.filename, None, None)
+
+
+class ExtensionDoctest(doctests.Doctest):
+    """Nose Plugin that supports doctests in extension modules.
+    """
+    name = 'extdoctest'   # call nosetests with --with-extdoctest
+    enabled = True
+
+    def options(self, parser, env=os.environ):
+        Plugin.options(self, parser, env)
+
+    def configure(self, options, config):
+        Plugin.configure(self, options, config)
+        self.doctest_tests = options.doctest_tests
+        self.extension = tolist(options.doctestExtension)
+        self.finder = DocTestFinder()
+        self.parser = doctest.DocTestParser()
+
+
+    def loadTestsFromExtensionModule(self,filename):
+        bpath,mod = os.path.split(filename)
+        modname = os.path.splitext(mod)[0]
+        try:
+            sys.path.append(bpath)
+            module = __import__(modname)
+            tests = list(self.loadTestsFromModule(module))
+        finally:
+            sys.path.pop()
+        return tests
+
+    def loadTestsFromFile(self, filename):
+        if is_extension_module(filename):
+            for t in self.loadTestsFromExtensionModule(filename):
+                yield t
+        else:
+            ## for t in list(doctests.Doctest.loadTestsFromFile(self,filename)):
+            ##     yield t
+            pass
+
+        if self.extension and anyp(filename.endswith, self.extension):
+            #print 'lTF',filename  # dbg
+            name = os.path.basename(filename)
+            dh = open(filename)
+            try:
+                doc = dh.read()
+            finally:
+                dh.close()
+            test = self.parser.get_doctest(
+                doc, globs={'__file__': filename}, name=name,
+                filename=filename, lineno=0)
+            if test.examples:
+                #print 'FileCase:',test.examples  # dbg
+                yield DocFileCase(test)
+            else:
+                yield False # no tests to load
+
+
+    def wantFile(self,filename):
+        """Return whether the given filename should be scanned for tests.
+
+        Modified version that accepts extension modules as valid containers for
+        doctests.
+        """
+        #print 'Filename:',filename  # dbg
+
+        if is_extension_module(filename):
+            return True
+        else:
+            return doctests.Doctest.wantFile(self,filename)
+
+    # NOTE: the method below is a *copy* of the one in the nose doctests
+    # plugin, but we have to replicate it here in order to have it resolve the
+    # DocTestCase (last line) to our local copy, since the nose plugin doesn't
+    # provide a public hook for what TestCase class to use.  The alternative
+    # would be to monkeypatch doctest in the stdlib, but that's ugly and
+    # brittle, since a change in plugin load order can break it.  So for now,
+    # we just paste this in here, inelegant as this may be.
+
+    def loadTestsFromModule(self, module):
+        #print 'lTM',module  # dbg
+
+        if not self.matches(module.__name__):
+            log.debug("Doctest doesn't want module %s", module)
+            return
+        tests = self.finder.find(module)
+        if not tests:
+            return
+        tests.sort()
+        module_file = module.__file__
+        if module_file[-4:] in ('.pyc', '.pyo'):
+            module_file = module_file[:-1]
+        for test in tests:
+            if not test.examples:
+                continue
+            if not test.filename:
+                test.filename = module_file
+            yield DocTestCase(test)
+
+class IPythonDoctest(ExtensionDoctest):
+    """Nose Plugin that supports doctests in extension modules.
+    """
+    name = 'ipdoctest'   # call nosetests with --with-ipdoctest
+    enabled = True
+
+    def configure(self, options, config):
+
+        Plugin.configure(self, options, config)
+        self.doctest_tests = options.doctest_tests
+        self.extension = tolist(options.doctestExtension)
+        self.parser = IPDocTestParser()
+        #self.finder = DocTestFinder(parser=IPDocTestParser())
+        self.finder = DocTestFinder(parser=self.parser)

IPython/testing/plugin/iptest.py

@@ -0,0 +1,18 b''
+#!/usr/bin/env python
+"""Nose-based test runner.
+"""
+
+from nose.core import main
+from nose.plugins.builtin import plugins
+from nose.plugins.doctests import Doctest
+
+import ipdoctest
+from ipdoctest import IPDocTestRunner
+
+if __name__ == '__main__':
+    print 'WARNING: this code is incomplete!'
+    print
+
+    pp = [x() for x in plugins]  # activate all builtin plugins first
+    main(testRunner=IPDocTestRunner(),
+         plugins=pp+[ipdoctest.IPythonDoctest(),Doctest()])

IPython/testing/plugin/setup.py

@@ -0,0 +1,18 b''
+#!/usr/bin/env python
+"""A Nose plugin to support IPython doctests.
+"""
+
+from setuptools import setup
+
+setup(name='IPython doctest plugin',
+      version='0.1',
+      author='The IPython Team',
+      description = 'Nose plugin to load IPython-extended doctests',
+      license = 'LGPL',
+      py_modules = ['ipdoctest'],
+      entry_points = {
+        'nose.plugins.0.10': ['ipdoctest = ipdoctest:IPythonDoctest',
+                              'extdoctest = ipdoctest:ExtensionDoctest',
+                              ],
+        },
+      )

IPython/testing/plugin/test_combo.txt

@@ -0,0 +1,36 b''
+=======================
+ Combo testing example
+=======================
+
+This is a simple example that mixes ipython doctests::
+
+    In [1]: import code
+
+    In [2]: 2**12
+    Out[2]: 4096
+
+with command-line example information that does *not* get executed::
+
+    $ mpirun -n 4 ipengine --controller-port=10000 --controller-ip=host0
+
+and with literal examples of Python source code::
+
+    controller = dict(host='myhost',
+		      engine_port=None, # default is 10105
+		      control_port=None,
+		      )
+
+    # keys are hostnames, values are the number of engine on that host
+    engines = dict(node1=2,
+		   node2=2,
+		   node3=2,
+		   node3=2,
+		   )
+
+    # Force failure to detect that this test is being run.
+    1/0
+
+These source code examples are executed but no output is compared at all.  An
+error or failure is reported only if an exception is raised.
+
+NOTE: the execution of pure python blocks is not yet working!

IPython/testing/plugin/test_example.txt

@@ -0,0 +1,24 b''
+=====================================
+ Tests in example form - pure python
+=====================================
+
+This file contains doctest examples embedded as code blocks, using normal
+Python prompts.  See the accompanying file for similar examples using IPython
+prompts (you can't mix both types within one file). The following will be run
+as a test::
+
+    >>> 1+1
+    2
+    >>> print "hello"
+    hello
+
+More than one example works::
+
+    >>> s="Hello World"
+
+    >>> s.upper()
+    'HELLO WORLD'
+
+but you should note that the *entire* test file is considered to be a single
+test.  Individual code blocks that fail are printed separately as ``example
+failures``, but the whole file is still counted and reported as one test.

IPython/testing/plugin/test_exampleip.txt

@@ -0,0 +1,30 b''
+=================================
+ Tests in example form - IPython
+=================================
+
+You can write text files with examples that use IPython prompts (as long as you
+use the nose ipython doctest plugin), but you can not mix and match prompt
+styles in a single file.  That is, you either use all ``>>>`` prompts or all
+IPython-style prompts.  Your test suite *can* have both types, you just need to
+put each type of example in a separate. Using IPython prompts, you can paste
+directly from your session::
+
+    In [5]: s="Hello World"
+
+    In [6]: s.upper()
+    Out[6]: 'HELLO WORLD'
+
+Another example::
+
+    In [8]: 1+3
+    Out[8]: 4
+
+Just like in IPython docstrings, you can use all IPython syntax and features::
+
+    In [9]: !echo "hello"
+    hello
+
+    In [10]: a='hi'
+
+    In [11]: !echo $a
+    hi

docs/examples/kernel/asyncmultiengine1.py

@@ -0,0 +1,23 b''
+#!/usr/bin/env python
+# encoding: utf-8
+
+# A super simple example showing how to use all of this in a fully
+# asynchronous manner.  The TaskClient also works in this mode.
+
+from twisted.internet import reactor, defer
+from IPython.kernel import asyncclient
+
+def printer(r):
+    print r
+    return r
+
+def submit(client):
+    d = client.push(dict(a=5, b='asdf', c=[1,2,3]),targets=0,block=True)
+    d.addCallback(lambda _: client.pull(('a','b','c'),targets=0,block=True))
+    d.addBoth(printer)
+    d.addCallback(lambda _: reactor.stop())
+
+d = asyncclient.get_multiengine_client()
+d.addCallback(submit)
+
+reactor.run()
  No newline at end of file

docs/examples/kernel/asynctask1.py

@@ -0,0 +1,32 b''
+#!/usr/bin/env python
+# encoding: utf-8
+
+# This example shows how the AsynTaskClient can be used
+# This example is currently broken
+
+from twisted.internet import reactor, defer
+from IPython.kernel import asyncclient
+
+mec = asyncclient.AsyncMultiEngineClient(('localhost', 10105))
+tc = asyncclient.AsyncTaskClient(('localhost',10113))
+
+cmd1 = """\
+a = 5
+b = 10*d
+c = a*b*d
+"""
+
+t1 = asyncclient.Task(cmd1, clear_before=False, clear_after=True, pull=['a','b','c'])
+
+d = mec.push(dict(d=30))
+
+def raise_and_print(tr):
+    tr.raiseException()
+    print "a, b: ", tr.ns.a, tr.ns.b
+    return tr
+
+d.addCallback(lambda _: tc.run(t1))
+d.addCallback(lambda tid: tc.get_task_result(tid,block=True))
+d.addCallback(raise_and_print)
+d.addCallback(lambda _: reactor.stop())
+reactor.run()

IPython/Magic.py

@@ -2728,8 +2728,7 b' Defaulting color scheme to \'NoColor\'"""'
                 os.chdir(os.path.expanduser(ps))
                 if self.shell.rc.term_title:
                     #print 'set term title:',self.shell.rc.term_title  # dbg
-                    ttitle = 'IPy ' + abbrev_cwd()
-                    platutils.set_term_title(ttitle)
+                    platutils.set_term_title('IPy ' + abbrev_cwd())
             except OSError:
                 print sys.exc_info()[1]
             else:
@@ -3195,7 +3194,7 b' Defaulting color scheme to \'NoColor\'"""'
             exec b in self.user_ns            
             self.user_ns['pasted_block'] = b
         else:
-            self.user_ns[par] = block
+            self.user_ns[par] = SList(block.splitlines())
             print "Block assigned to '%s'" % par
             
     def magic_quickref(self,arg):

IPython/Release.py

@@ -22,15 +22,19 b" name = 'ipython'"
 # because bdist_rpm does not accept dashes (an RPM) convention, and
 # bdist_deb does not accept underscores (a Debian convention).
 
-revision = '1016'
+development = True    # change this to False to do a release
+version_base = '0.9.0'
 branch = 'ipython'
+revision = '1016'
 
-if branch == 'ipython':
-    version = '0.9.0.bzr.r' + revision
+if development:
+    if branch == 'ipython':
+        version = '%s.bzr.r%s' % (version_base, revision)
+    else:
+        version = '%s.bzr.r%s.%s' % (version_base, revision, branch)
 else:
-    version = '0.9.0.bzr.r%s.%s'  % (revision,branch)
+    version = version_base
 
-# version = '0.8.4'
 
 description = "Tools for interactive development in Python."
 

IPython/external/mglob.py

@@ -53,7 +53,7 b' globsyntax = """\\'
          - readme*, exclude files ending with .bak
      !.svn/ !.hg/ !*_Data/ rec:.
          - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
-           Trailing / is the key, \ does not work!
+           Trailing / is the key, \ does not work! Use !.*/ for all hidden.
      dir:foo                       
          - the directory foo if it exists (not files in foo)
      dir:*                         
@@ -63,13 +63,16 b' globsyntax = """\\'
            foo.py is *not* included twice.
      @filelist.txt
          - All files listed in 'filelist.txt' file, on separate lines.
+     "cont:class \wak:" rec:*.py
+         - Match files containing regexp. Applies to subsequent files.
+           note quotes because of whitespace.
  """
 
 
 __version__ = "0.2"
 
 
-import os,glob,fnmatch,sys
+import os,glob,fnmatch,sys,re
 from sets import Set as set
 
                 
@@ -84,21 +87,34 b' def expand(flist,exp_dirs = False):'
     
     """
     if isinstance(flist, basestring):
-        flist = flist.split()
+        import shlex
+        flist = shlex.split(flist)
     done_set = set()
     denied_set = set()
-
+    cont_set = set()
+    cur_rejected_dirs = set()
+    
     def recfind(p, pats = ["*"]):
-        denied_dirs = ["*" + d+"*" for d in denied_set if d.endswith("/")]
-        #print "de", denied_dirs
+        denied_dirs = [os.path.dirname(d) for d in denied_set if d.endswith("/")]
         for (dp,dnames,fnames) in os.walk(p):
             # see if we should ignore the whole directory
             dp_norm = dp.replace("\\","/") + "/"
             deny = False
+            # do not traverse under already rejected dirs
+            for d in cur_rejected_dirs:
+                if dp.startswith(d):
+                    deny = True
+                    break
+            if deny:
+                continue
+            
+
             #print "dp",dp
+            bname = os.path.basename(dp)
             for deny_pat in denied_dirs:
-                if fnmatch.fnmatch( dp_norm, deny_pat):
+                if fnmatch.fnmatch( bname, deny_pat):
                     deny = True
+                    cur_rejected_dirs.add(dp)
                     break
             if deny:
                 continue
@@ -124,6 +140,17 b' def expand(flist,exp_dirs = False):'
                 if fnmatch.fnmatch(os.path.basename(p), deny_pat):
                     deny = True
                     break
+            if cont_set:
+                try:
+                    cont = open(p).read()
+                except IOError:
+                    # deny
+                    continue
+                for pat in cont_set:
+                    if not re.search(pat,cont, re.IGNORECASE):
+                        deny = True
+                        break
+                    
             if not deny:
                 yield it
         return
@@ -158,7 +185,8 b' def expand(flist,exp_dirs = False):'
         # glob only dirs
         elif ent.lower().startswith('dir:'):
             res.extend(once_filter(filter(os.path.isdir,glob.glob(ent[4:]))))
-            
+        elif ent.lower().startswith('cont:'):
+            cont_set.add(ent[5:])
         # get all files in the specified dir
         elif os.path.isdir(ent) and exp_dirs:
             res.extend(once_filter(filter(os.path.isfile,glob.glob(ent + os.sep+"*"))))

IPython/frontend/cocoa/cocoa_frontend.py

@@ -24,12 +24,14 b' __docformat__ = "restructuredtext en"'
 # Imports
 #-----------------------------------------------------------------------------
 
+import sys
 import objc
 import uuid
 
 from Foundation import NSObject, NSMutableArray, NSMutableDictionary,\
                         NSLog, NSNotificationCenter, NSMakeRange,\
-                        NSLocalizedString, NSIntersectionRange
+                        NSLocalizedString, NSIntersectionRange,\
+                        NSString, NSAutoreleasePool
                         
 from AppKit import NSApplicationWillTerminateNotification, NSBeep,\
                     NSTextView, NSRulerView, NSVerticalRuler
@@ -38,7 +40,7 b' from pprint import saferepr'
 
 import IPython
 from IPython.kernel.engineservice import ThreadedEngineService
-from IPython.frontend.frontendbase import FrontEndBase
+from IPython.frontend.frontendbase import AsyncFrontEndBase
 
 from twisted.internet.threads import blockingCallFromThread
 from twisted.python.failure import Failure
@@ -52,17 +54,57 b' from twisted.python.failure import Failure'
 #       ThreadedEngineService?
 #   2. integrate Xgrid launching of engines
         
+class AutoreleasePoolWrappedThreadedEngineService(ThreadedEngineService):
+    """Wrap all blocks in an NSAutoreleasePool"""
     
+    def wrapped_execute(self, msg, lines):
+        """wrapped_execute"""
+        try:
+            p = NSAutoreleasePool.alloc().init()
+            result = self.shell.execute(lines)
+        except Exception,e:
+            # This gives the following:
+            # et=exception class
+            # ev=exception class instance
+            # tb=traceback object
+            et,ev,tb = sys.exc_info()
+            # This call adds attributes to the exception value
+            et,ev,tb = self.shell.formatTraceback(et,ev,tb,msg)
+            # Add another attribute
+            
+            # Create a new exception with the new attributes
+            e = et(ev._ipython_traceback_text)
+            e._ipython_engine_info = msg
+            
+            # Re-raise
+            raise e
+        finally:
+            p.drain()
+        
+        return result
+    
+    def execute(self, lines):
+        # Only import this if we are going to use this class
+        from twisted.internet import threads
+        
+        msg = {'engineid':self.id,
+               'method':'execute',
+               'args':[lines]}
+        
+        d = threads.deferToThread(self.wrapped_execute, msg, lines)
+        d.addCallback(self.addIDToResult)
+        return d
 
 
-class IPythonCocoaController(NSObject, FrontEndBase):
+class IPythonCocoaController(NSObject, AsyncFrontEndBase):
     userNS = objc.ivar() #mirror of engine.user_ns (key=>str(value))
     waitingForEngine = objc.ivar().bool()
     textView = objc.IBOutlet()
     
     def init(self):
         self = super(IPythonCocoaController, self).init()
-        FrontEndBase.__init__(self, engine=ThreadedEngineService())
+        AsyncFrontEndBase.__init__(self,
+                    engine=AutoreleasePoolWrappedThreadedEngineService())
         if(self != None):
             self._common_init()
         
@@ -133,13 +175,43 b' class IPythonCocoaController(NSObject, FrontEndBase):'
     def execute(self, block, blockID=None):
         self.waitingForEngine = True
         self.willChangeValueForKey_('commandHistory')
-        d = super(IPythonCocoaController, self).execute(block, blockID)
+        d = super(IPythonCocoaController, self).execute(block,
+                                                        blockID)
         d.addBoth(self._engine_done)
         d.addCallback(self._update_user_ns)
         
         return d
     
+    
+    def push_(self, namespace):
+        """Push dictionary of key=>values to python namespace"""
         
+        self.waitingForEngine = True
+        self.willChangeValueForKey_('commandHistory')
+        d = self.engine.push(namespace)
+        d.addBoth(self._engine_done)
+        d.addCallback(self._update_user_ns)
+    
+    
+    def pull_(self, keys):
+        """Pull keys from python namespace"""
+        
+        self.waitingForEngine = True
+        result = blockingCallFromThread(self.engine.pull, keys)
+        self.waitingForEngine = False
+    
+    @objc.signature('v@:@I')
+    def executeFileAtPath_encoding_(self, path, encoding):
+        """Execute file at path in an empty namespace. Update the engine
+        user_ns with the resulting locals."""
+        
+        lines,err = NSString.stringWithContentsOfFile_encoding_error_(
+            path,
+            encoding,
+            None)
+        self.engine.execute(lines)
+    
+    
     def _engine_done(self, x):
         self.waitingForEngine = False
         self.didChangeValueForKey_('commandHistory')
@@ -166,14 +238,14 b' class IPythonCocoaController(NSObject, FrontEndBase):'
         self.didChangeValueForKey_('userNS')
     
     
-    def update_cell_prompt(self, result):
+    def update_cell_prompt(self, result, blockID=None):
         if(isinstance(result, Failure)):
-            blockID = result.blockID
+            self.insert_text(self.input_prompt(),
+                textRange=NSMakeRange(self.blockRanges[blockID].location,0),
+                scrollToVisible=False
+                )
         else:
-            blockID = result['blockID']
-        
-        
-        self.insert_text(self.input_prompt(result=result),
+            self.insert_text(self.input_prompt(number=result['number']),
                 textRange=NSMakeRange(self.blockRanges[blockID].location,0),
                 scrollToVisible=False
                 )
@@ -188,7 +260,7 b' class IPythonCocoaController(NSObject, FrontEndBase):'
         
         #print inputRange,self.current_block_range()
         self.insert_text('\n' +
-                self.output_prompt(result) +
+                self.output_prompt(number=result['number']) +
                 result.get('display',{}).get('pprint','') +
                 '\n\n',
                 textRange=NSMakeRange(inputRange.location+inputRange.length,
@@ -197,7 +269,11 b' class IPythonCocoaController(NSObject, FrontEndBase):'
     
         
     def render_error(self, failure):
-        self.insert_text('\n\n'+str(failure)+'\n\n')
+        self.insert_text('\n' +
+                        self.output_prompt() +
+                        '\n' +
+                        failure.getErrorMessage() +
+                        '\n\n')
         self.start_new_block()
         return failure
     
@@ -288,9 +364,13 b' class IPythonCocoaController(NSObject, FrontEndBase):'
     def current_indent_string(self):
         """returns string for indent or None if no indent"""
         
-        if(len(self.current_block()) > 0):
-            lines = self.current_block().split('\n')
-            currentIndent = len(lines[-1]) - len(lines[-1])
+        return self._indent_for_block(self.current_block())
+    
+    
+    def _indent_for_block(self, block):
+        lines = block.split('\n')
+        if(len(lines) > 1):
+            currentIndent = len(lines[-1]) - len(lines[-1].lstrip())
             if(currentIndent == 0):
                 currentIndent = self.tabSpaces
         

IPython/frontend/cocoa/tests/test_cocoa_frontend.py

@@ -70,3 +70,22 b' class TestIPythonCocoaControler(DeferredTestCase):'
         
         self.controller.execute(code).addCallback(testCompletes)
     
+    
+    def testCurrentIndent(self):
+        """test that current_indent_string returns current indent or None.
+        Uses _indent_for_block for direct unit testing.
+        """
+        
+        self.controller.tabUsesSpaces = True
+        self.assert_(self.controller._indent_for_block("""a=3""") == None)
+        self.assert_(self.controller._indent_for_block("") == None)
+        block = """def test():\n    a=3"""
+        self.assert_(self.controller._indent_for_block(block) == \
+                    ' ' * self.controller.tabSpaces)
+        
+        block = """if(True):\n%sif(False):\n%spass""" % \
+                    (' '*self.controller.tabSpaces,
+                     2*' '*self.controller.tabSpaces)
+        self.assert_(self.controller._indent_for_block(block) == \
+                    2*(' '*self.controller.tabSpaces))
+    

IPython/frontend/frontendbase.py

@@ -24,13 +24,24 b' import string'
 import uuid
 import _ast
 
-import zope.interface as zi
+try:
+    from zope.interface import Interface, Attribute, implements, classProvides
+except ImportError:
+    #zope.interface is not available
+    Interface = object
+    def Attribute(name, doc): pass
+    def implements(interface): pass
+    def classProvides(interface): pass
 
 from IPython.kernel.core.history import FrontEndHistory
 from IPython.kernel.core.util import Bunch
 from IPython.kernel.engineservice import IEngineCore
 
-from twisted.python.failure import Failure
+try:
+    from twisted.python.failure import Failure
+except ImportError:
+    #Twisted not available
+    Failure = Exception
 
 ##############################################################################
 # TEMPORARY!!! fake configuration, while we decide whether to use tconfig or
@@ -43,7 +54,7 b" rc.prompt_out = r'Out [$number]: '"
 
 ##############################################################################
 
-class IFrontEndFactory(zi.Interface):
+class IFrontEndFactory(Interface):
     """Factory interface for frontends."""
     
     def __call__(engine=None, history=None):
@@ -56,33 +67,30 b' class IFrontEndFactory(zi.Interface):'
 
 
 
-class IFrontEnd(zi.Interface):
+class IFrontEnd(Interface):
     """Interface for frontends. All methods return t.i.d.Deferred"""
     
-    zi.Attribute("input_prompt_template", "string.Template instance\
+    Attribute("input_prompt_template", "string.Template instance\
                 substituteable with execute result.")
-    zi.Attribute("output_prompt_template", "string.Template instance\
+    Attribute("output_prompt_template", "string.Template instance\
                 substituteable with execute result.")
-    zi.Attribute("continuation_prompt_template", "string.Template instance\
+    Attribute("continuation_prompt_template", "string.Template instance\
                 substituteable with execute result.")
     
-    def update_cell_prompt(self, result):
+    def update_cell_prompt(result, blockID=None):
         """Subclass may override to update the input prompt for a block. 
         Since this method will be called as a 
-        twisted.internet.defer.Deferred's callback,
+        twisted.internet.defer.Deferred's callback/errback,
         implementations should return result when finished.
         
-        NB: result is a failure if the execute returned a failre. 
-        To get the blockID, you should do something like::
-            if(isinstance(result, twisted.python.failure.Failure)):
-                blockID = result.blockID
-            else:
-                blockID = result['blockID']
+        Result is a result dict in case of success, and a
+        twisted.python.util.failure.Failure in case of an error
         """
         
         pass
     
-    def render_result(self, result):
+    
+    def render_result(result):
         """Render the result of an execute call. Implementors may choose the
          method of rendering.
         For example, a notebook-style frontend might render a Chaco plot 
@@ -90,6 +98,7 b' class IFrontEnd(zi.Interface):'
         
         Parameters:
             result : dict (result of IEngineBase.execute )
+                blockID = result['blockID']
         
         Result:
             Output of frontend rendering
@@ -97,22 +106,24 b' class IFrontEnd(zi.Interface):'
         
         pass
     
-    def render_error(self, failure):
+    def render_error(failure):
         """Subclasses must override to render the failure. Since this method 
-        ill be called as a twisted.internet.defer.Deferred's callback, 
+        will be called as a twisted.internet.defer.Deferred's callback, 
         implementations should return result when finished.
+        
+        blockID = failure.blockID
         """
         
         pass
     
     
-    def input_prompt(result={}):
+    def input_prompt(number=''):
         """Returns the input prompt by subsituting into 
         self.input_prompt_template
         """
         pass
     
-    def output_prompt(result):
+    def output_prompt(number=''):
         """Returns the output prompt by subsituting into 
         self.output_prompt_template
         """
@@ -159,9 +170,6 b' class FrontEndBase(object):'
         - How do we handle completions?
     """
     
-    zi.implements(IFrontEnd)
-    zi.classProvides(IFrontEndFactory)
-    
     history_cursor = 0
     
     current_indent_level = 0
@@ -171,24 +179,20 b' class FrontEndBase(object):'
     output_prompt_template = string.Template(rc.prompt_out)
     continuation_prompt_template = string.Template(rc.prompt_in2)
     
-    def __init__(self, engine=None, history=None):
-        assert(engine==None or IEngineCore.providedBy(engine))
-        self.engine = IEngineCore(engine)
+    def __init__(self, shell=None, history=None):
+        self.shell = shell
         if history is None:
                 self.history = FrontEndHistory(input_cache=[''])
         else:
             self.history = history
         
     
-    def input_prompt(self, result={}):
+    def input_prompt(self, number=''):
         """Returns the current input prompt
         
         It would be great to use ipython1.core.prompts.Prompt1 here
         """
-        
-        result.setdefault('number','')
-        
-        return self.input_prompt_template.safe_substitute(result)
+        return self.input_prompt_template.safe_substitute({'number':number})
     
     
     def continuation_prompt(self):
@@ -196,10 +200,10 b' class FrontEndBase(object):'
         
         return self.continuation_prompt_template.safe_substitute()
     
-    def output_prompt(self, result):
+    def output_prompt(self, number=''):
         """Returns the output prompt for result"""
         
-        return self.output_prompt_template.safe_substitute(result)
+        return self.output_prompt_template.safe_substitute({'number':number})
     
     
     def is_complete(self, block):
@@ -239,7 +243,7 b' class FrontEndBase(object):'
     
     
     def execute(self, block, blockID=None):
-        """Execute the block and return result.
+        """Execute the block and return the result.
         
         Parameters:
             block : {str, AST}
@@ -252,32 +256,41 b' class FrontEndBase(object):'
         """
         
         if(not self.is_complete(block)):
-            return Failure(Exception("Block is not compilable"))
+            raise Exception("Block is not compilable")
         
         if(blockID == None):
             blockID = uuid.uuid4() #random UUID
         
-        d = self.engine.execute(block)
-        d.addCallback(self._add_history, block=block)
-        d.addBoth(self._add_block_id, blockID)
-        d.addBoth(self.update_cell_prompt)
-        d.addCallbacks(self.render_result, errback=self.render_error)
+        try:
+            result = self.shell.execute(block)
+        except Exception,e:
+            e = self._add_block_id_for_failure(e, blockID=blockID)
+            e = self.update_cell_prompt(e, blockID=blockID)
+            e = self.render_error(e)
+        else:
+            result = self._add_block_id_for_result(result, blockID=blockID)
+            result = self.update_cell_prompt(result, blockID=blockID)
+            result = self.render_result(result)
         
-        return d
+        return result
     
     
-    def _add_block_id(self, result, blockID):
+    def _add_block_id_for_result(self, result, blockID):
         """Add the blockID to result or failure. Unfortunatley, we have to 
         treat failures differently than result dicts.
         """
         
-        if(isinstance(result, Failure)):
-            result.blockID = blockID
-        else:
-            result['blockID'] = blockID
+        result['blockID'] = blockID
         
         return result
     
+    def _add_block_id_for_failure(self, failure, blockID):
+        """_add_block_id_for_failure"""
+        
+        failure.blockID = blockID
+        return failure
+    
+    
     def _add_history(self, result, block=None):
         """Add block to the history"""
         
@@ -313,20 +326,11 b' class FrontEndBase(object):'
     # Subclasses probably want to override these methods...
     ###
     
-    def update_cell_prompt(self, result):
+    def update_cell_prompt(self, result, blockID=None):
         """Subclass may override to update the input prompt for a block. 
         Since this method will be called as a 
         twisted.internet.defer.Deferred's callback, implementations should 
         return result when finished.
-        
-        NB: result is a failure if the execute returned a failre. 
-        To get the blockID, you should do something like::
-            if(isinstance(result, twisted.python.failure.Failure)):
-                blockID = result.blockID
-            else:
-                blockID = result['blockID']
-            
-        
         """
         
         return result
@@ -344,9 +348,60 b' class FrontEndBase(object):'
     def render_error(self, failure):
         """Subclasses must override to render the failure. Since this method 
         will be called as a twisted.internet.defer.Deferred's callback, 
-        implementations should return result when finished."""
+        implementations should return result when finished.
+        """
         
         return failure
     
 
 
+class AsyncFrontEndBase(FrontEndBase):
+    """
+    Overrides FrontEndBase to wrap execute in a deferred result.
+    All callbacks are made as callbacks on the deferred result.
+    """
+    
+    implements(IFrontEnd)
+    classProvides(IFrontEndFactory)
+    
+    def __init__(self, engine=None, history=None):
+        assert(engine==None or IEngineCore.providedBy(engine))
+        self.engine = IEngineCore(engine)
+        if history is None:
+                self.history = FrontEndHistory(input_cache=[''])
+        else:
+            self.history = history
+    
+    
+    def execute(self, block, blockID=None):
+        """Execute the block and return the deferred result.
+        
+        Parameters:
+            block : {str, AST}
+            blockID : any
+                Caller may provide an ID to identify this block. 
+                result['blockID'] := blockID
+        
+        Result:
+            Deferred result of self.interpreter.execute
+        """
+        
+        if(not self.is_complete(block)):
+            return Failure(Exception("Block is not compilable"))
+        
+        if(blockID == None):
+            blockID = uuid.uuid4() #random UUID
+        
+        d = self.engine.execute(block)
+        d.addCallback(self._add_history, block=block)
+        d.addCallbacks(self._add_block_id_for_result,
+                errback=self._add_block_id_for_failure,
+                callbackArgs=(blockID,),
+                errbackArgs=(blockID,))
+        d.addBoth(self.update_cell_prompt, blockID=blockID)
+        d.addCallbacks(self.render_result, 
+            errback=self.render_error)
+        
+        return d
+    
+

IPython/frontend/tests/test_frontendbase.py

@@ -19,7 +19,7 b' import unittest'
 from IPython.frontend import frontendbase
 from IPython.kernel.engineservice import EngineService
 
-class FrontEndCallbackChecker(frontendbase.FrontEndBase):
+class FrontEndCallbackChecker(frontendbase.AsyncFrontEndBase):
     """FrontEndBase subclass for checking callbacks"""
     def __init__(self, engine=None, history=None):
         super(FrontEndCallbackChecker, self).__init__(engine=engine, 
@@ -28,7 +28,7 b' class FrontEndCallbackChecker(frontendbase.FrontEndBase):'
         self.renderResultCalled = False
         self.renderErrorCalled = False
     
-    def update_cell_prompt(self, result):
+    def update_cell_prompt(self, result, blockID=None):
         self.updateCalled = True
         return result
     
@@ -44,7 +44,7 b' class FrontEndCallbackChecker(frontendbase.FrontEndBase):'
 
 
     
-class TestFrontendBase(unittest.TestCase):
+class TestAsyncFrontendBase(unittest.TestCase):
     def setUp(self):
         """Setup the EngineService and FrontEndBase"""
         
@@ -53,7 +53,7 b' class TestFrontendBase(unittest.TestCase):'
     
     def test_implements_IFrontEnd(self):
         assert(frontendbase.IFrontEnd.implementedBy(
-                                                frontendbase.FrontEndBase))
+                                    frontendbase.AsyncFrontEndBase))
     
     
     def test_is_complete_returns_False_for_incomplete_block(self):

IPython/genutils.py

@@ -1137,14 +1137,41 b' class SList(list):'
                 res.append(" ".join(lineparts))
             
         return res        
-                
-            
-            
+    def sort(self,field= None,  nums = False):
+        """ sort by specified fields (see fields())
+        
+        Example::
+            a.sort(1, nums = True)
+        
+        Sorts a by second field, in numerical order (so that 21 > 3)
+        
+        """ 
         
+        #decorate, sort, undecorate
+        if field is not None:
+            dsu = [[SList([line]).fields(field),  line] for line in self]
+        else:
+            dsu = [[line,  line] for line in self]
+        if nums:
+            for i in range(len(dsu)):
+                numstr = "".join([ch for ch in dsu[i][0] if ch.isdigit()])
+                try:
+                    n = int(numstr)
+                except ValueError:
+                    n = 0;
+                dsu[i][0] = n
+                
+                
+        dsu.sort()
+        return SList([t[1] for t in dsu])
 
 def print_slist(arg):
     """ Prettier (non-repr-like) and more informative printer for SList """
-    print "SList (.p, .n, .l, .s, .grep(), .fields() available). Value:"
+    print "SList (.p, .n, .l, .s, .grep(), .fields(), sort() available):"
+    if hasattr(arg,  'hideonce') and arg.hideonce:
+        arg.hideonce = False
+        return
+        
     nlprint(arg)
     
 print_slist = result_display.when_type(SList)(print_slist)

IPython/kernel/scripts/ipcluster.py

@@ -168,8 +168,7 b' def startMsg(control_host,control_port=10105):'
     print 'For interactive use, you can make a MultiEngineClient with:'
     print
     print 'from IPython.kernel import client'
-    print "mec = client.MultiEngineClient((%r,%s))" % \
-          (control_host,control_port)
+    print "mec = client.MultiEngineClient()"
     print
     print 'You can then cleanly stop the cluster from IPython using:'
     print
@@ -191,16 +190,18 b' def clusterLocal(opt,arg):'
         logfile = pjoin(logdir_base,'ipcluster-')
 
     print 'Starting controller:',
-    controller = Popen(['ipcontroller','--logfile',logfile])
+    controller = Popen(['ipcontroller','--logfile',logfile,'-x','-y'])
     print 'Controller PID:',controller.pid
 
     print 'Starting engines:   ',
-    time.sleep(3)
+    time.sleep(5)
 
     englogfile = '%s%s-' % (logfile,controller.pid)
     mpi = opt.mpi
     if mpi: # start with mpi - killing the engines with sigterm will not work if you do this
-        engines = [Popen(['mpirun', '-np', str(opt.n), 'ipengine', '--mpi', mpi, '--logfile',englogfile])]
+        engines = [Popen(['mpirun', '-np', str(opt.n), 'ipengine', '--mpi', 
+            mpi, '--logfile',englogfile])]
+        # engines = [Popen(['mpirun', '-np', str(opt.n), 'ipengine', '--mpi', mpi])]
     else: # do what we would normally do
         engines = [ Popen(['ipengine','--logfile',englogfile])
                     for i in range(opt.n) ]

IPython/kernel/scripts/ipengine.py

@@ -58,12 +58,14 b' def start_engine():'
     kernel_config = kernel_config_manager.get_config_obj()
     core_config = core_config_manager.get_config_obj()
     
+
     # Execute the mpi import statement that needs to call MPI_Init
+    global mpi
     mpikey = kernel_config['mpi']['default']
     mpi_import_statement = kernel_config['mpi'].get(mpikey, None)
     if mpi_import_statement is not None:
         try:
-            exec mpi_import_statement in locals(), globals()
+            exec mpi_import_statement in globals()
         except:
             mpi = None
     else:

IPython/platutils.py

@@ -3,13 +3,8 b''
 
 Importing this module should give you the implementations that are correct 
 for your operation system, from platutils_PLATFORMNAME module.
-
-$Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
-
-
 """
 
-
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
 #
@@ -21,15 +16,32 b' from IPython import Release'
 __author__  = '%s <%s>' % Release.authors['Ville']
 __license__ = Release.license
 
-import os,sys
+import os
+import sys
 
+# Import the platform-specific implementations
 if os.name == 'posix':
-    from platutils_posix import *
+    import platutils_posix as _platutils
 elif sys.platform == 'win32':
-    from platutils_win32 import *
+    import platutils_win32 as _platutils
 else:
-    from platutils_dummy import *
+    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.
+
+def freeze_term_title():
+    _platutils.ignore_termtitle = True
+
+
+def set_term_title(title):
+    """Set terminal title using the necessary platform-dependent calls."""
+
+    if _platutils.ignore_termtitle:
+        return
+    _platutils.set_term_title(title)

IPython/platutils_dummy.py

@@ -3,13 +3,8 b''
 
 This has empty implementation of the platutils functions, used for 
 unsupported operating systems.
-
-$Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
-
-
 """
 
-
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
 #
@@ -21,9 +16,9 b' from IPython import Release'
 __author__  = '%s <%s>' % Release.authors['Ville']
 __license__ = Release.license
 
+# This variable is part of the expected API of the module:
+ignore_termtitle = True
 
-def _dummy(*args,**kw):
+def set_term_title(*args,**kw):
+    """Dummy no-op."""
     pass
-
-set_term_title = _dummy
-

IPython/platutils_posix.py

@@ -3,12 +3,8 b''
 
 Importing this module directly is not portable - rather, import platutils 
 to use these functions in platform agnostic fashion.
-
-$Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
-
 """
 
-
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
 #
@@ -31,9 +27,6 b' def _dummy_op(*a, **b):'
 def _set_term_title_xterm(title):
     """ Change virtual terminal title in xterm-workalikes """
 
-    if ignore_termtitle:
-        return
-    
     sys.stdout.write('\033]%d;%s\007' % (0,title))
 
 
@@ -41,7 +34,3 b" if os.environ.get('TERM','') == 'xterm':"
     set_term_title = _set_term_title_xterm
 else:
     set_term_title = _dummy_op
-
-def freeze_term_title():
-    global ignore_termtitle
-    ignore_termtitle = True

IPython/platutils_win32.py

@@ -3,12 +3,8 b''
 
 Importing this module directly is not portable - rather, import platutils 
 to use these functions in platform agnostic fashion.
-
-$Id: ipstruct.py 1005 2006-01-12 08:39:26Z fperez $
-
 """
 
-
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
 #
@@ -22,35 +18,30 b' __license__ = Release.license'
 
 import os
 
-ignore_termtitle = 0
+ignore_termtitle = False
 
 try:
     import ctypes
-    SetConsoleTitleW=ctypes.windll.kernel32.SetConsoleTitleW
-    SetConsoleTitleW.argtypes=[ctypes.c_wchar_p]
-    def _set_term_title(title):
-        """ Set terminal title using the ctypes"""
+
+    SetConsoleTitleW = ctypes.windll.kernel32.SetConsoleTitleW
+    SetConsoleTitleW.argtypes = [ctypes.c_wchar_p]
+    
+    def set_term_title(title):
+        """Set terminal title using ctypes to access the Win32 APIs."""
         SetConsoleTitleW(title)
 
 except ImportError:
-    def _set_term_title(title):
-        """ Set terminal title using the 'title' command """
-        curr=os.getcwd()
-        os.chdir("C:") #Cannot be on network share when issuing system commands
-        ret = os.system("title " + title)
-        os.chdir(curr)
+    def set_term_title(title):
+        """Set terminal title using the 'title' command."""
+        global ignore_termtitle
+
+        try:
+            # Cannot be on network share when issuing system commands
+            curr = os.getcwd()
+            os.chdir("C:")
+            ret = os.system("title " + title)
+        finally:
+            os.chdir(curr)
         if ret:
-            ignore_termtitle = 1
-
-def set_term_title(title):
-    """ Set terminal title using the 'title' command """
-    global ignore_termtitle
-
-    if ignore_termtitle:
-        return
-    _set_term_title(title)
-
-def freeze_term_title():
-    global ignore_termtitle
-    ignore_termtitle = 1
-
+            # non-zero return code signals error, don't try again
+            ignore_termtitle = True

IPython/testing/tutils.py

@@ -1,6 +1,20 b''
-"""Utilities for testing code.
+"""DEPRECATED - use IPython.testing.util instead.
+
+Utilities for testing code.
 """
 
+#############################################################################
+
+# This was old testing code we never really used in IPython.  The pieces of
+# testing machinery from snakeoil that were good have already been merged into
+# the nose plugin, so this can be taken away soon.  Leave a warning for now,
+# we'll remove it in a later release (around 0.10 or so).
+from warnings import warn
+warn('This will be removed soon.  Use IPython.testing.util instead',
+     DeprecationWarning)
+
+#############################################################################
+
 # Required modules and packages
 
 # Standard Python lib
@@ -36,7 +50,7 b' def test_path(path):'
 
     This finds the correct path of the test package on disk, and prepends it
     to the input path."""
-    
+
     return os.path.join(TEST_PATH,path)
 
 def fullPath(startPath,files):
@@ -55,7 +69,7 b' def fullPath(startPath,files):'
         One or more files.
 
     :Examples:
-    
+
     >>> fullPath('/foo/bar.py',['a.txt','b.txt'])
     ['/foo/a.txt', '/foo/b.txt']
 
@@ -66,7 +80,7 b' def fullPath(startPath,files):'
     >>> fullPath('/foo','a.txt')
     ['/a.txt']
     """
-    
+
     files = utils.list_strings(files)
     base = os.path.split(startPath)[0]
     return [ os.path.join(base,f) for f in files ]

IPython/tools/tests/test_tools_utils.txt

@@ -3,40 +3,15 b''
 =========================================
 
 The way doctest loads these, the entire document is applied as a single test
-rather than multiple individual ones, unfortunately.
+rather than multiple individual ones, unfortunately::
 
-
-Auto-generated tests
-====================
-
-
-----------------------------------------------------------------------------
-
-Begin included file tst_tools_utils_doctest2.py::
-
-    # Setup - all imports are done in tcommon
-    >>> from IPython.testing import tcommon
-    >>> from IPython.testing.tcommon import *
-    
-    # Doctest code begins here
     >>> from IPython.tools import utils
-    
+
     # Some other tests for utils
-    
+
     >>> utils.marquee('Testing marquee')
     '****************************** Testing marquee ******************************'
-    
+
     >>> utils.marquee('Another test',30,'.')
     '........ Another test ........'
-    
-    
-End included file tst_tools_utils_doctest2.py
-
-----------------------------------------------------------------------------
-
-
-
-Manually generated tests
-========================
 
-These are one-off tests written by hand, copied from an interactive prompt.

MANIFEST.in

@@ -16,7 +16,6 b' graft IPython/tools'
 graft docs
 exclude docs/\#*
 exclude docs/man/*.1
-exclude docs/ChangeLog.*
 
 # There seems to be no way of excluding whole subdirectories, other than
 # manually excluding all their subdirs.  distutils really is horrible...

docs/emacs/ipython.el

@@ -9,7 +9,7 b''
 (defconst ipython-version "$Revision: 2927 $"
   "VC version number.")
 
-;;; Commentary 
+;;; Commentary
 ;; This library makes all the functionality python-mode has when running with
 ;; the normal python-interpreter available for ipython, too. It also enables a
 ;; persistent py-shell command history across sessions (if you exit python
@@ -31,13 +31,20 b''
 ;; To start an interactive ipython session run `py-shell' with ``M-x py-shell``
 ;; (or the default keybinding ``C-c C-!``).
 ;;
+;; You can customize the arguments passed to the IPython instance at startup by
+;; setting the ``py-python-command-args`` variable.  For example, to start
+;; always in ``pylab`` mode with hardcoded light-background colors, you can
+;; use::
+;;
+;; (setq py-python-command-args '("-pylab" "-colors" "LightBG"))
+;;
+;;
 ;; NOTE: This mode is currently somewhat alpha and although I hope that it
 ;; will work fine for most cases, doing certain things (like the
 ;; autocompletion and a decent scheme to switch between python interpreters)
 ;; properly will also require changes to ipython that will likely have to wait
 ;; for a larger rewrite scheduled some time in the future.
-;; 
-;; Also note that you currently NEED THE CVS VERSION OF PYTHON.EL.
+;;
 ;;
 ;; Further note that I don't know whether this runs under windows or not and
 ;; that if it doesn't I can't really help much, not being afflicted myself.
@@ -46,14 +53,15 b''
 ;; Hints for effective usage
 ;; -------------------------
 ;;
-;; - IMO the best feature by far of the ipython/emacs combo is how much easier it
-;;   makes it to find and fix bugs thanks to the ``%pdb on``/ pdbtrack combo. Try
-;;   it: first in the ipython to shell do ``%pdb on`` then do something that will
-;;   raise an exception (FIXME nice example) -- and be amazed how easy it is to
-;;   inspect the live objects in each stack frames and to jump to the
-;;   corresponding sourcecode locations as you walk up and down the stack trace
-;;   (even without ``%pdb on`` you can always use ``C-c -`` (`py-up-exception')
-;;   to jump to the corresponding source code locations).
+;; - IMO the best feature by far of the ipython/emacs combo is how much easier
+;;   it makes it to find and fix bugs thanks to the ``%pdb on or %debug``/
+;;   pdbtrack combo. Try it: first in the ipython to shell do ``%pdb on`` then
+;;   do something that will raise an exception (FIXME nice example), or type
+;;   ``%debug`` after the exception has been raised.  YOu'll be amazed at how
+;;   easy it is to inspect the live objects in each stack frames and to jump to
+;;   the corresponding sourcecode locations as you walk up and down the stack
+;;   trace (even without ``%pdb on`` you can always use ``C-c -``
+;;   (`py-up-exception') to jump to the corresponding source code locations).
 ;;
 ;; - emacs gives you much more powerful commandline editing and output searching
 ;;   capabilities than ipython-standalone -- isearch is your friend if you
@@ -65,9 +73,9 b''
 ;;   ipython, you can change ``meta p`` etc. for ``control p``)::
 ;;
 ;;         (require 'comint)
-;;         (define-key comint-mode-map [(meta p)] 
+;;         (define-key comint-mode-map [(meta p)]
 ;;           'comint-previous-matching-input-from-input)
-;;         (define-key comint-mode-map [(meta n)] 
+;;         (define-key comint-mode-map [(meta n)]
 ;;           'comint-next-matching-input-from-input)
 ;;         (define-key comint-mode-map [(control meta n)]
 ;;            'comint-next-input)
@@ -79,8 +87,8 b''
 ;;   variables comes later).
 ;;
 ;; Please send comments and feedback to the ipython-list
-;; (<[e-mail]>) where I (a.s.) or someone else will try to
-;; answer them (it helps if you specify your emacs version, OS etc; 
+;; (<[e-mail]>) where I (a.s.) or someone else will try to
+;; answer them (it helps if you specify your emacs version, OS etc;
 ;; familiarity with <http://www.catb.org/~esr/faqs/smart-questions.html> might
 ;; speed up things further).
 ;;
@@ -106,10 +114,10 b''
 ;;      - neither::
 ;;
 ;;         (py-shell "-c print 'FOOBAR'")
-;;       
+;;
 ;;        nor::
-;;       
-;;         (let ((py-python-command-args (append py-python-command-args 
+;;
+;;         (let ((py-python-command-args (append py-python-command-args
 ;;                                              '("-c" "print 'FOOBAR'"))))
 ;;           (py-shell))
 ;;
@@ -127,7 +135,7 b''
 
 (defcustom ipython-command "ipython"
   "*Shell command used to start ipython."
-  :type 'string 
+  :type 'string
   :group 'python)
 
 ;; Users can set this to nil
@@ -138,7 +146,7 b''
 (defvar ipython-backup-of-py-python-command nil
   "HACK")
 
-  
+
 (defvar ipython-de-input-prompt-regexp "\\(?:
 In \\[[0-9]+\\]: *.*
 ----+> \\(.*
@@ -181,16 +189,16 b' the second for a \'normal\' command, and the third for a multiline command.")'
       ;;XXX this is really just a cheap hack, it only completes symbols in the
       ;;interactive session -- useful nonetheless.
       (define-key py-mode-map [(meta tab)] 'ipython-complete)
-      
+
       )
     (add-hook 'py-shell-hook 'ipython-shell-hook)
     ;; Regular expression that describes tracebacks for IPython in context and
-    ;; verbose mode. 
-  
+    ;; verbose mode.
+
     ;;Adapt python-mode settings for ipython.
     ;; (this works for %xmode 'verbose' or 'context')
 
-    ;; XXX putative regexps for syntax errors; unfortunately the 
+    ;; XXX putative regexps for syntax errors; unfortunately the
     ;;     current python-mode traceback-line-re scheme is too primitive,
     ;;     so it's either matching syntax errors, *or* everything else
     ;;     (XXX: should ask Fernando for a change)
@@ -200,20 +208,20 b' the second for a \'normal\' command, and the third for a multiline command.")'
     (setq py-traceback-line-re
           "\\(^[^\t >].+?\\.py\\).*\n   +[0-9]+[^\00]*?\n-+> \\([0-9]+\\)+")
 
-    
+
     ;; Recognize the ipython pdb, whose prompt is 'ipdb>' or  'ipydb>'
     ;;instead of '(Pdb)'
     (setq py-pdbtrack-input-prompt "\n[(<]*[Ii]?[Pp]y?db[>)]+ ")
     (setq pydb-pydbtrack-input-prompt "\n[(]*ipydb[>)]+ ")
-    
+
     (setq py-shell-input-prompt-1-regexp "^In \\[[0-9]+\\]: *"
           py-shell-input-prompt-2-regexp "^   [.][.][.]+: *" )
     ;; select a suitable color-scheme
     (unless (member "-colors" py-python-command-args)
-      (setq py-python-command-args 
-            (nconc py-python-command-args 
+      (setq py-python-command-args
+            (nconc py-python-command-args
                    (list "-colors"
-                         (cond  
+                         (cond
                            ((eq frame-background-mode 'dark)
                             "Linux")
                            ((eq frame-background-mode 'light)
@@ -253,7 +261,7 b' buffer already exists."'
 
 (defadvice py-execute-region (around py-execute-buffer-ensure-process)
   "HACK: if `py-shell' is not active or ASYNC is explicitly desired, fall back
-  to python instead of ipython." 
+  to python instead of ipython."
   (let ((py-which-shell (if (and (comint-check-proc "*Python*") (not async))
 			    py-python-command
 			  ipython-backup-of-py-python-command)))
@@ -267,14 +275,14 b' be used in doctests. Example:'
 
 
     In [1]: import sys
-    
+
     In [2]: sys.stdout.write 'Hi!\n'
     ------> sys.stdout.write ('Hi!\n')
     Hi!
-    
+
     In [3]: 3 + 4
     Out[3]: 7
-    
+
 gets converted to:
 
     >>> import sys
@@ -288,7 +296,7 b' gets converted to:'
   ;(message (format "###DEBUG s:%de:%d" start end))
   (save-excursion
     (save-match-data
-      ;; replace ``In [3]: bla`` with ``>>> bla`` and 
+      ;; replace ``In [3]: bla`` with ``>>> bla`` and
       ;;         ``... :   bla`` with ``...    bla``
       (goto-char start)
       (while (re-search-forward ipython-de-input-prompt-regexp end t)
@@ -302,7 +310,7 b' gets converted to:'
       (while (re-search-forward ipython-de-output-prompt-regexp end t)
         (replace-match "" t nil)))))
 
-(defvar ipython-completion-command-string 
+(defvar ipython-completion-command-string
   "print ';'.join(__IP.Completer.all_completions('%s')) #PYTHON-MODE SILENT\n"
   "The string send to ipython to query for all possible completions")
 
@@ -332,19 +340,19 b' in the current *Python* session."'
              (completion-table nil)
              completion
              (comint-output-filter-functions
-              (append comint-output-filter-functions 
+              (append comint-output-filter-functions
                       '(ansi-color-filter-apply
-                        (lambda (string) 
+                        (lambda (string)
                                         ;(message (format "DEBUG filtering: %s" string))
                           (setq ugly-return (concat ugly-return string))
-                          (delete-region comint-last-output-start 
+                          (delete-region comint-last-output-start
                                          (process-mark (get-buffer-process (current-buffer)))))))))
                                         ;(message (format "#DEBUG pattern: '%s'" pattern))
-        (process-send-string python-process 
+        (process-send-string python-process
                               (format ipython-completion-command-string pattern))
         (accept-process-output python-process)
                                         ;(message (format "DEBUG return: %s" ugly-return))
-        (setq completions 
+        (setq completions
               (split-string (substring ugly-return 0 (position ?\n ugly-return)) sep))
         (setq completion-table (loop for str in completions
                                      collect (list str nil)))
@@ -376,22 +384,22 b' in the current *Python* session."'
            ;; to let ipython have the complete line, so that context can be used
            ;; to do things like filename completion etc.
            (beg (save-excursion (skip-chars-backward "a-z0-9A-Z_./" (point-at-bol))
-                                (point))) 
+                                (point)))
            (end (point))
            (pattern (buffer-substring-no-properties beg end))
            (completions nil)
            (completion-table nil)
            completion
          (comint-preoutput-filter-functions
-          (append comint-preoutput-filter-functions 
+          (append comint-preoutput-filter-functions
                   '(ansi-color-filter-apply
-                    (lambda (string) 
+                    (lambda (string)
                       (setq ugly-return (concat ugly-return string))
                       "")))))
-      (process-send-string python-process 
+      (process-send-string python-process
                             (format ipython-completion-command-string pattern))
       (accept-process-output python-process)
-      (setq completions 
+      (setq completions
             (split-string (substring ugly-return 0 (position ?\n ugly-return)) sep))
                                         ;(message (format "DEBUG completions: %S" completions))
       (setq completion-table (loop for str in completions