Initial work towards refactoring the setup.py scripts to accept the new ipython1 packages

that have been merged.  I am also bringing in a new way for checking dependencies at
build time that is simple, but really helpful now that we have lots of optional
dependencies.

setupbase.py

@@ -0,0 +1,201 b''
+# encoding: utf-8
+
+__docformat__ = "restructuredtext en"
+
+#-------------------------------------------------------------------------------
+#  Copyright (C) 2008  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-------------------------------------------------------------------------------
+
+#-------------------------------------------------------------------------------
+# Imports
+#-------------------------------------------------------------------------------
+
+import os, sys
+
+from glob import glob
+
+from setupext import install_data_ext
+
+#-------------------------------------------------------------------------------
+# Useful globals and utility functions
+#-------------------------------------------------------------------------------
+
+# A few handy globals
+isfile = os.path.isfile
+pjoin = os.path.join
+
+def oscmd(s):
+    print ">", s
+    os.system(s)
+
+# A little utility we'll need below, since glob() does NOT allow you to do
+# exclusion on multiple endings!
+def file_doesnt_endwith(test,endings):
+    """Return true if test is a file and its name does NOT end with any
+    of the strings listed in endings."""
+    if not isfile(test):
+        return False
+    for e in endings:
+        if test.endswith(e):
+            return False
+    return True
+
+#---------------------------------------------------------------------------
+# Basic project information
+#---------------------------------------------------------------------------
+
+# Release.py contains version, authors, license, url, keywords, etc.
+execfile(pjoin('IPython','Release.py'))
+
+# Create a dict with the basic information
+# This dict is eventually passed to setup after additional keys are added.
+setup_args = dict(
+      name             = name,
+      version          = version,
+      description      = description,
+      long_description = long_description,
+      author           = author,
+      author_email     = author_email,
+      url              = url,
+      download_url     = download_url,
+      license          = license,
+      platforms        = platforms,
+      keywords         = keywords,
+      cmdclass         = {'install_data': install_data_ext},
+      )
+
+
+#---------------------------------------------------------------------------
+# Find packages
+#---------------------------------------------------------------------------
+
+def add_package(packages, pname, config=False, tests=False, scripts=False, others=None):
+    packages.append('.'.join(['ipython1',pname]))
+    if config:
+        packages.append('.'.join(['ipython1',pname,'config']))
+    if tests:
+        packages.append('.'.join(['ipython1',pname,'tests']))
+    if scripts:
+        packages.append('.'.join(['ipython1',pname,'scripts']))
+    if others is not None:
+        for o in others:
+            packages.append('.'.join(['ipython1',pname,o]))
+
+def find_packages():
+    packages = ['ipython']
+    add_package(packages, 'config', tests=True)
+    add_package(packages , 'Extensions')
+    add_package(packages, 'external')
+    add_package(packages, 'gui')
+    add_package(packages, 'gui.wx')
+    add_package(packages, 'kernel', config=True, tests=True, scripts=True)
+    add_package(packages, 'kernel.core', config=True, tests=True)
+    add_package(packages, 'testing', tests=True)
+    add_package(packages, 'tools', tests=True)
+    add_package(packages, 'UserConfig')
+    return packages
+
+#---------------------------------------------------------------------------
+# Find package data
+#---------------------------------------------------------------------------
+
+def find_package_data():
+    # This is not enough for these things to appear in an sdist.
+    # We need to muck with the MANIFEST to get this to work
+    package_data = {'IPython.UserConfig' : ['*'] }
+    return package_data
+
+
+#---------------------------------------------------------------------------
+# Find data files
+#---------------------------------------------------------------------------
+
+def find_data_files():
+    
+    # I can't find how to make distutils create a nested dir. structure, so
+    # in the meantime do it manually. Butt ugly.
+    # Note that http://www.redbrick.dcu.ie/~noel/distutils.html, ex. 2/3, contain
+    # information on how to do this more cleanly once python 2.4 can be assumed.
+    # Thanks to Noel for the tip.
+    docdirbase  = 'share/doc/ipython'
+    manpagebase = 'share/man/man1'
+
+    # We only need to exclude from this things NOT already excluded in the
+    # MANIFEST.in file.
+    exclude     = ('.sh','.1.gz')
+    docfiles    = filter(lambda f:file_doesnt_endwith(f,exclude),glob('doc/*'))
+    examfiles   = filter(isfile, glob('doc/examples/*.py'))
+    manfiles    = filter(isfile, glob('doc/manual/*'))
+    manstatic   = filter(isfile, glob('doc/manual/_static/*'))
+    manpages    = filter(isfile, glob('doc/*.1.gz'))
+    scriptfiles = filter(isfile, ['scripts/ipython','scripts/pycolor',
+                                  'scripts/irunner'])
+    igridhelpfiles = filter(isfile, glob('IPython/Extensions/igrid_help.*'))
+    
+    data_files = [('data', docdirbase, docfiles),
+                 ('data', pjoin(docdirbase, 'examples'),examfiles),
+                 ('data', pjoin(docdirbase, 'manual'),manfiles),
+                 ('data', pjoin(docdirbase, 'manual/_static'),manstatic),
+                 ('data', manpagebase, manpages),
+                 ('data',pjoin(docdirbase, 'extensions'),igridhelpfiles),
+                 ]
+    return data_files
+
+#---------------------------------------------------------------------------
+# Find scripts
+#---------------------------------------------------------------------------
+
+def find_scripts():
+    scripts = []
+    scripts.append('ipython1/kernel/scripts/ipengine')
+    scripts.append('ipython1/kernel/scripts/ipcontroller')
+    scripts.append('ipython1/kernel/scripts/ipcluster')
+    scripts.append('scripts/ipython')
+    scripts.append('scripts/pycolor')
+    scripts.append('scripts/irunner')
+    
+    # Script to be run by the windows binary installer after the default setup
+    # routine, to add shortcuts and similar windows-only things.  Windows
+    # post-install scripts MUST reside in the scripts/ dir, otherwise distutils
+    # doesn't find them.
+    if 'bdist_wininst' in sys.argv:
+        if len(sys.argv) > 2 and ('sdist' in sys.argv or 'bdist_rpm' in sys.argv):
+            print >> sys.stderr,"ERROR: bdist_wininst must be run alone. Exiting."
+            sys.exit(1)
+        scripts.append('scripts/ipython_win_post_install.py')
+    
+    return scripts
+
+#---------------------------------------------------------------------------
+# Find scripts
+#---------------------------------------------------------------------------
+
+def check_for_dependencies():
+    from setupext.setupext import (
+        print_line, print_raw, print_status, print_message,
+        check_for_zopeinterface, check_for_twisted,
+        check_for_foolscap, check_for_pyopenssl,
+        check_for_sphinx, check_for_pygments,
+        check_for_nose, check_for_pexpect
+    )
+    print_line()
+    print_raw("BUILDING IPYTHON")
+    print_status('python', sys.version)
+    print_status('platform', sys.platform)
+    if sys.platform == 'win32':
+        print_status('Windows version', sys.getwindowsversion())
+    
+    print_raw("")
+    print_raw("OPTIONAL DEPENDENCIES")
+
+    check_for_zopeinterface()
+    check_for_twisted()
+    check_for_foolscap()
+    check_for_pyopenssl()
+    check_for_sphinx()
+    check_for_pygments()
+    check_for_nose()
+    check_for_pexpect()
  No newline at end of file

setupext/setupext.py

@@ -0,0 +1,177 b''
+# encoding: utf-8
+
+__docformat__ = "restructuredtext en"
+
+#-------------------------------------------------------------------------------
+#  Copyright (C) 2008  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-------------------------------------------------------------------------------
+
+#-------------------------------------------------------------------------------
+# Imports
+#-------------------------------------------------------------------------------
+
+import sys, os
+from textwrap import fill
+
+display_status=True
+
+if display_status:
+    def print_line(char='='):
+        print char * 76
+
+    def print_status(package, status):
+        initial_indent = "%22s: " % package
+        indent = ' ' * 24
+        print fill(str(status), width=76,
+                   initial_indent=initial_indent,
+                   subsequent_indent=indent)
+
+    def print_message(message):
+        indent = ' ' * 24 + "* "
+        print fill(str(message), width=76,
+                   initial_indent=indent,
+                   subsequent_indent=indent)
+
+    def print_raw(section):
+        print section
+else:
+    def print_line(*args, **kwargs):
+        pass
+    print_status = print_message = print_raw = print_line
+
+#-------------------------------------------------------------------------------
+# Tests for specific packages
+#-------------------------------------------------------------------------------
+
+def check_for_ipython():
+    try:
+        import IPython
+    except ImportError:
+        print_status("IPython", "Not found")
+        return False
+    else:
+        print_status("IPython", IPython.__version__)
+        return True
+
+def check_for_zopeinterface():
+    try:
+        import zope.interface
+    except ImportError:
+        print_status("zope.Interface", "Not found (required for parallel computing capabilities)")
+        return False
+    else:
+        print_status("Zope.Interface","yes")
+        return True
+        
+def check_for_twisted():
+    try:
+        import twisted
+    except ImportError:
+        print_status("Twisted", "Not found (required for parallel computing capabilities)")
+        return False
+    else:
+        major = twisted.version.major
+        minor = twisted.version.minor
+        micro = twisted.version.micro
+        if not ((major==2 and minor>=5 and micro>=0) or \
+                major>=8):
+            print_message("WARNING: IPython requires Twisted 2.5.0 or greater, you have version %s"%twisted.version.short())
+            return False
+        else:
+            print_status("Twisted", twisted.version.short())
+            return True
+
+def check_for_foolscap():
+    try:
+        import foolscap
+    except ImportError:
+        print_status('Foolscap', "Not found (required for parallel computing capabilities)")
+        return False
+    else:
+        print_status('Foolscap', foolscap.__version__)
+        return True
+
+def check_for_pyopenssl():
+    try:
+        import OpenSSL
+    except ImportError:
+        print_status('OpenSSL', "Not found (required if you want security in the parallel computing capabilities)")
+        return False
+    else:
+        print_status('OpenSSL', OpenSSL.__version__)    
+        return True
+
+def check_for_sphinx():
+    try:
+        import sphinx
+    except ImportError:
+        print_status('sphinx', "Not found (required for building the IPtyhon documentation)")
+        return False
+    else:
+        print_status('sphinx', sphinx.__version__) 
+        return True
+
+def check_for_pygments():
+    try:
+        import pygments
+    except ImportError:
+        print_status('pygments', "Not found (required for syntax highlighting of code in the IPtyhon documentation)")
+        return False
+    else:
+        print_status('pygments', pygments.__version__)
+        return True
+
+def check_for_nose():
+    try:
+        import nose
+    except ImportError:
+        print_status('nose', "Not found (required for running the IPython test suite)")
+        return False
+    else:
+        print_status('nose', nose.__version__)
+        return True
+
+def check_for_pexpect():
+    try:
+        import pexpect
+    except ImportError:
+        print_status("pexpect", "no (required for running standalone doctests)")
+        return False
+    else:
+        print_status("pexpect", pexpect.__version__)
+        return True
+
+def check_for_httplib2():
+    try:
+        import httplib2
+    except ImportError:
+        print_status("httplib2", "no (required for blocking http clients)")
+        return False
+    else:
+        print_status("httplib2","yes")
+        return True
+
+def check_for_sqlalchemy():
+    try:
+        import sqlalchemy
+    except ImportError:
+        print_status("sqlalchemy", "no (required for the ipython1 notebook)")
+        return False
+    else:
+        print_status("sqlalchemy","yes")
+        return True
+
+def check_for_simplejson():
+    try:
+        import simplejson
+    except ImportError:
+        print_status("simplejson", "no (required for the ipython1 notebook)")
+        return False
+    else:
+        print_status("simplejson","yes")
+        return True
+
+        
  No newline at end of file

IPython/Release.py

@@ -1,89 +1,95 b''
 # -*- coding: utf-8 -*-
 """Release data for the IPython project.
 
 $Id: Release.py 3002 2008-02-01 07:17:00Z fperez $"""
 
 #*****************************************************************************
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
 #
 #       Copyright (c) 2001 Janko Hauser <[e-mail]> and Nathaniel Gray
 #       <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 # Name of the package for release purposes.  This is the name which labels
 # the tarballs and RPMs made by distutils, so it's best to lowercase it.
 name = 'ipython'
 
 # For versions with substrings (like 0.6.16.svn), use an extra . to separate
 # the new substring.  We have to avoid using either dashes or underscores,
 # because bdist_rpm does not accept dashes (an RPM) convention, and
 # bdist_deb does not accept underscores (a Debian convention).
 
 revision = '128'
 branch = 'ipython'
 
 if branch == 'ipython':
     version = '0.8.4.bzr.r' + revision
 else:
     version = '0.8.4.bzr.r%s.%s'  % (revision,branch)
 
 version = '0.8.4'
 
-description = "An enhanced interactive Python shell."
+description = "Tools for interactive development in Python."
 
 long_description = \
 """
 IPython provides a replacement for the interactive Python interpreter with
 extra functionality.
 
 Main features:
 
  * Comprehensive object introspection.
 
  * Input history, persistent across sessions.
 
  * Caching of output results during a session with automatically generated
    references.
 
  * Readline based name completion.
 
  * Extensible system of 'magic' commands for controlling the environment and
    performing many tasks related either to IPython or the operating system.
 
  * Configuration system with easy switching between different setups (simpler
    than changing $PYTHONSTARTUP environment variables every time).
 
  * Session logging and reloading.
 
  * Extensible syntax processing for special purpose situations.
 
  * Access to the system shell with user-extensible alias system.
 
  * Easily embeddable in other Python programs.
 
  * Integrated access to the pdb debugger and the Python profiler. 
 
  The latest development version is always available at the IPython subversion
  repository_.
 
 .. _repository: http://ipython.scipy.org/svn/ipython/ipython/trunk#egg=ipython-dev
  """
 
 license = 'BSD'
 
 authors = {'Fernando' : ('Fernando Perez','[e-mail]'),
            'Janko'    : ('Janko Hauser','[e-mail]'),
            'Nathan'   : ('Nathaniel Gray','[e-mail]'),
-           'Ville'    : ('Ville Vainio','[e-mail]')           
+           'Ville'    : ('Ville Vainio','[e-mail]'),
+           'Brian'    : ('Brian E Granger', '[e-mail]'),
+           'Min'      : ('Min Ragan-Kelley', '[e-mail]')
            }
 
+author = 'The IPython Development Team'
+
+author_email = '[e-mail]'
+
 url = 'http://ipython.scipy.org'
 
 download_url = 'http://ipython.scipy.org/dist'
 
 platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME']
 
-keywords = ['Interactive','Interpreter','Shell']
+keywords = ['Interactive','Interpreter','Shell','Parallel','Distributed']

IPython/kernel/tests/controllertest.py

@@ -1,102 +1,102 b''
 # encoding: utf-8
 
 """This file contains unittests for the kernel.engineservice.py module.
 
 Things that should be tested:
 
  - Should the EngineService return Deferred objects?
  - Run the same tests that are run in shell.py.
  - Make sure that the Interface is really implemented.
  - The startService and stopService methods.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from twisted.internet import defer
 import zope.interface as zi
 
 from IPython.kernel import engineservice as es
 from IPython.kernel import error
-from IPython.testutils.util import DeferredTestCase
+from IPython.testing.util import DeferredTestCase
 from IPython.kernel.controllerservice import \
     IControllerCore
 
 
 class IControllerCoreTestCase(object):
     """Tests for objects that implement IControllerCore.
     
     This test assumes that self.controller is defined and implements
     IControllerCore.
     """
     
     def testIControllerCoreInterface(self):
         """Does self.engine claim to implement IEngineCore?"""
         self.assert_(IControllerCore.providedBy(self.controller))
         
     def testIControllerCoreInterfaceMethods(self):
         """Does self.engine have the methods and attributes in IEngireCore."""
         for m in list(IControllerCore):
             self.assert_(hasattr(self.controller, m))
     
     def testRegisterUnregisterEngine(self):
         engine = es.EngineService()
         qengine = es.QueuedEngine(engine)
         regDict = self.controller.register_engine(qengine, 0)
         self.assert_(isinstance(regDict, dict))
         self.assert_(regDict.has_key('id'))
         self.assert_(regDict['id']==0)
         self.controller.unregister_engine(0)
         self.assert_(self.controller.engines.get(0, None) == None)
 
     def testRegisterUnregisterMultipleEngines(self):
         e1 = es.EngineService()
         qe1 = es.QueuedEngine(e1)
         e2 = es.EngineService()
         qe2 = es.QueuedEngine(e2)
         rd1 = self.controller.register_engine(qe1, 0)
         self.assertEquals(rd1['id'], 0)
         rd2 = self.controller.register_engine(qe2, 1)
         self.assertEquals(rd2['id'], 1)
         self.controller.unregister_engine(0)
         rd1 = self.controller.register_engine(qe1, 0)
         self.assertEquals(rd1['id'], 0)
         self.controller.unregister_engine(1)
         rd2 = self.controller.register_engine(qe2, 0)
         self.assertEquals(rd2['id'], 1)
         self.controller.unregister_engine(0)
         self.controller.unregister_engine(1)
         self.assertEquals(self.controller.engines,{})
         
     def testRegisterCallables(self):
         e1 = es.EngineService()
         qe1 = es.QueuedEngine(e1)
         self.registerCallableCalled = ';lkj'
         self.unregisterCallableCalled = ';lkj'
         self.controller.on_register_engine_do(self._registerCallable, False)
         self.controller.on_unregister_engine_do(self._unregisterCallable, False)
         self.controller.register_engine(qe1, 0)
         self.assertEquals(self.registerCallableCalled, 'asdf')
         self.controller.unregister_engine(0)
         self.assertEquals(self.unregisterCallableCalled, 'asdf')
         self.controller.on_register_engine_do_not(self._registerCallable)
         self.controller.on_unregister_engine_do_not(self._unregisterCallable)
             
     def _registerCallable(self):
         self.registerCallableCalled = 'asdf'
         
     def _unregisterCallable(self):
         self.unregisterCallableCalled = 'asdf'
         
     def testBadUnregister(self):
         self.assertRaises(AssertionError, self.controller.unregister_engine, 'foo')
  No newline at end of file

IPython/kernel/tests/engineservicetest.py

@@ -1,373 +1,373 b''
 # encoding: utf-8
 
 """Test template for complete engine object"""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import cPickle as pickle
 
 from twisted.internet import defer, reactor
 from twisted.python import failure
 from twisted.application import service
 import zope.interface as zi
 
 from IPython.kernel import newserialized
 from IPython.kernel import error
 from IPython.kernel.pickleutil import can, uncan
 import IPython.kernel.engineservice as es
 from IPython.kernel.core.interpreter import Interpreter
-from IPython.testutils.parametric import Parametric, parametric
+from IPython.testing.parametric import Parametric, parametric
 
 #-------------------------------------------------------------------------------
 # Tests
 #-------------------------------------------------------------------------------
 
     
 # A sequence of valid commands run through execute
 validCommands = ['a=5',
                  'b=10',
                  'a=5; b=10; c=a+b',
                  'import math; 2.0*math.pi',
                  """def f():
     result = 0.0
     for i in range(10):
         result += i
 """,
                  'if 1<2: a=5',
                  """import time
 time.sleep(0.1)""",
                 """from math import cos;
 x = 1.0*cos(0.5)""", # Semicolons lead to Discard ast nodes that should be discarded
                 """from sets import Set
 s = Set()
    """, # Trailing whitespace should be allowed.
                 """import math
 math.cos(1.0)""", # Test a method call with a discarded return value
                 """x=1.0234
 a=5; b=10""", # Test an embedded semicolon
                 """x=1.0234
 a=5; b=10;""" # Test both an embedded and trailing semicolon
                  ]
                  
 # A sequence of commands that raise various exceptions
 invalidCommands = [('a=1/0',ZeroDivisionError),
                    ('print v',NameError),
                    ('l=[];l[0]',IndexError),
                    ("d={};d['a']",KeyError),
                    ("assert 1==0",AssertionError),
                    ("import abababsdbfsbaljasdlja",ImportError),
                    ("raise Exception()",Exception)]
 
 def testf(x):
     return 2.0*x
 
 globala = 99
 
 def testg(x):
     return  globala*x
 
 class IEngineCoreTestCase(object):
     """Test an IEngineCore implementer."""
 
     def createShell(self):
         return Interpreter()
 
     def catchQueueCleared(self, f):
         try:
             f.raiseException()
         except error.QueueCleared:
             pass
         
     def testIEngineCoreInterface(self):
         """Does self.engine claim to implement IEngineCore?"""
         self.assert_(es.IEngineCore.providedBy(self.engine))
         
     def testIEngineCoreInterfaceMethods(self):
         """Does self.engine have the methods and attributes in IEngineCore."""
         for m in list(es.IEngineCore):
             self.assert_(hasattr(self.engine, m))
     
     def testIEngineCoreDeferreds(self):
         d = self.engine.execute('a=5')
         d.addCallback(lambda _: self.engine.pull('a'))
         d.addCallback(lambda _: self.engine.get_result())
         d.addCallback(lambda _: self.engine.keys())
         d.addCallback(lambda _: self.engine.push(dict(a=10)))
         return d
     
     def runTestExecute(self, cmd):
         self.shell = Interpreter()
         actual = self.shell.execute(cmd)
         def compare(computed):
             actual['id'] = computed['id']
             self.assertEquals(actual, computed)
         d = self.engine.execute(cmd)
         d.addCallback(compare)
         return d
     
     @parametric
     def testExecute(cls):
         return [(cls.runTestExecute, cmd) for cmd in validCommands]
 
     def runTestExecuteFailures(self, cmd, exc):
         def compare(f):
             self.assertRaises(exc, f.raiseException)
         d = self.engine.execute(cmd)
         d.addErrback(compare)
         return d
     
     @parametric
     def testExecuteFailures(cls):
         return [(cls.runTestExecuteFailures, cmd, exc) for cmd, exc in invalidCommands]
     
     def runTestPushPull(self, o):
         d = self.engine.push(dict(a=o))
         d.addCallback(lambda r: self.engine.pull('a'))
         d.addCallback(lambda r: self.assertEquals(o,r))
         return d
     
     @parametric
     def testPushPull(cls):
         objs = [10,"hi there",1.2342354,{"p":(1,2)},None]
         return [(cls.runTestPushPull, o) for o in objs]
         
     def testPullNameError(self):
         d = self.engine.push(dict(a=5))
         d.addCallback(lambda _:self.engine.reset())
         d.addCallback(lambda _: self.engine.pull("a"))
         d.addErrback(lambda f: self.assertRaises(NameError, f.raiseException))
         return d        
     
     def testPushPullFailures(self):
         d = self.engine.pull('a')
         d.addErrback(lambda f: self.assertRaises(NameError, f.raiseException))
         d.addCallback(lambda _: self.engine.execute('l = lambda x: x'))
         d.addCallback(lambda _: self.engine.pull('l'))
         d.addErrback(lambda f: self.assertRaises(pickle.PicklingError, f.raiseException))
         d.addCallback(lambda _: self.engine.push(dict(l=lambda x: x)))
         d.addErrback(lambda f: self.assertRaises(pickle.PicklingError, f.raiseException))
         return d
         
     def testPushPullArray(self):
         try:
             import numpy
         except:
             print 'no numpy, ',
             return
         a = numpy.random.random(1000)
         d = self.engine.push(dict(a=a))
         d.addCallback(lambda _: self.engine.pull('a'))
         d.addCallback(lambda b: b==a)
         d.addCallback(lambda c: c.all())
         return self.assertDeferredEquals(d, True)
         
     def testPushFunction(self):
                     
         d = self.engine.push_function(dict(f=testf))
         d.addCallback(lambda _: self.engine.execute('result = f(10)'))
         d.addCallback(lambda _: self.engine.pull('result'))
         d.addCallback(lambda r: self.assertEquals(r, testf(10)))
         return d
 
     def testPullFunction(self):
         d = self.engine.push_function(dict(f=testf, g=testg))
         d.addCallback(lambda _: self.engine.pull_function(('f','g')))
         d.addCallback(lambda r: self.assertEquals(r[0](10), testf(10)))
         return d
         
     def testPushFunctionGlobal(self):
         """Make sure that pushed functions pick up the user's namespace for globals."""
         d = self.engine.push(dict(globala=globala))
         d.addCallback(lambda _: self.engine.push_function(dict(g=testg)))
         d.addCallback(lambda _: self.engine.execute('result = g(10)'))
         d.addCallback(lambda _: self.engine.pull('result'))
         d.addCallback(lambda r: self.assertEquals(r, testg(10)))
         return d
         
     def testGetResultFailure(self):
         d = self.engine.get_result(None)
         d.addErrback(lambda f: self.assertRaises(IndexError, f.raiseException))
         d.addCallback(lambda _: self.engine.get_result(10))
         d.addErrback(lambda f: self.assertRaises(IndexError, f.raiseException))
         return d
 
     def runTestGetResult(self, cmd):
         self.shell = Interpreter()
         actual = self.shell.execute(cmd)
         def compare(computed):
             actual['id'] = computed['id']
             self.assertEquals(actual, computed)
         d = self.engine.execute(cmd)
         d.addCallback(lambda r: self.engine.get_result(r['number']))
         d.addCallback(compare)
         return d
     
     @parametric
     def testGetResult(cls):
         return [(cls.runTestGetResult, cmd) for cmd in validCommands]
     
     def testGetResultDefault(self):
         cmd = 'a=5'
         shell = self.createShell()
         shellResult = shell.execute(cmd)
         def popit(dikt, key):
             dikt.pop(key)
             return dikt
         d = self.engine.execute(cmd)
         d.addCallback(lambda _: self.engine.get_result())
         d.addCallback(lambda r: self.assertEquals(shellResult, popit(r,'id')))
         return d
 
     def testKeys(self):
         d = self.engine.keys()
         d.addCallback(lambda s: isinstance(s, list))
         d.addCallback(lambda r: self.assertEquals(r, True))
         return d
             
 Parametric(IEngineCoreTestCase)
             
 class IEngineSerializedTestCase(object):
     """Test an IEngineCore implementer."""
         
     def testIEngineSerializedInterface(self):
         """Does self.engine claim to implement IEngineCore?"""
         self.assert_(es.IEngineSerialized.providedBy(self.engine))
         
     def testIEngineSerializedInterfaceMethods(self):
         """Does self.engine have the methods and attributes in IEngireCore."""
         for m in list(es.IEngineSerialized):
             self.assert_(hasattr(self.engine, m))
        
     def testIEngineSerializedDeferreds(self):
         dList = []
         d = self.engine.push_serialized(dict(key=newserialized.serialize(12345)))
         self.assert_(isinstance(d, defer.Deferred))
         dList.append(d)
         d = self.engine.pull_serialized('key')
         self.assert_(isinstance(d, defer.Deferred))
         dList.append(d)
         D = defer.DeferredList(dList)
         return D
                 
     def testPushPullSerialized(self):
         objs = [10,"hi there",1.2342354,{"p":(1,2)}]
         d = defer.succeed(None)
         for o in objs:
             self.engine.push_serialized(dict(key=newserialized.serialize(o)))
             value = self.engine.pull_serialized('key')
             value.addCallback(lambda serial: newserialized.IUnSerialized(serial).getObject())
             d = self.assertDeferredEquals(value,o,d)
         return d
 
     def testPullSerializedFailures(self):
         d = self.engine.pull_serialized('a')
         d.addErrback(lambda f: self.assertRaises(NameError, f.raiseException))
         d.addCallback(lambda _: self.engine.execute('l = lambda x: x'))
         d.addCallback(lambda _: self.engine.pull_serialized('l'))
         d.addErrback(lambda f: self.assertRaises(pickle.PicklingError, f.raiseException))
         return d
 
 Parametric(IEngineSerializedTestCase)
 
 class IEngineQueuedTestCase(object):
     """Test an IEngineQueued implementer."""
         
     def testIEngineQueuedInterface(self):
         """Does self.engine claim to implement IEngineQueued?"""
         self.assert_(es.IEngineQueued.providedBy(self.engine))
         
     def testIEngineQueuedInterfaceMethods(self):
         """Does self.engine have the methods and attributes in IEngireQueued."""
         for m in list(es.IEngineQueued):
             self.assert_(hasattr(self.engine, m))
             
     def testIEngineQueuedDeferreds(self): 
         dList = []
         d = self.engine.clear_queue()
         self.assert_(isinstance(d, defer.Deferred))
         dList.append(d)
         d = self.engine.queue_status()
         self.assert_(isinstance(d, defer.Deferred))
         dList.append(d)
         D = defer.DeferredList(dList)
         return D
             
     def testClearQueue(self):
         result = self.engine.clear_queue()
         d1 = self.assertDeferredEquals(result, None)
         d1.addCallback(lambda _: self.engine.queue_status())
         d2 = self.assertDeferredEquals(d1, {'queue':[], 'pending':'None'})
         return d2
         
     def testQueueStatus(self):
         result = self.engine.queue_status()
         result.addCallback(lambda r: 'queue' in r and 'pending' in r)
         d = self.assertDeferredEquals(result, True)
         return d
 
 Parametric(IEngineQueuedTestCase)
 
 class IEnginePropertiesTestCase(object):
     """Test an IEngineProperties implementor."""
     
     def testIEnginePropertiesInterface(self):
         """Does self.engine claim to implement IEngineProperties?"""
         self.assert_(es.IEngineProperties.providedBy(self.engine))
     
     def testIEnginePropertiesInterfaceMethods(self):
         """Does self.engine have the methods and attributes in IEngireProperties."""
         for m in list(es.IEngineProperties):
             self.assert_(hasattr(self.engine, m))
     
     def testGetSetProperties(self):
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d = self.engine.set_properties(dikt)
         d.addCallback(lambda r: self.engine.get_properties())
         d = self.assertDeferredEquals(d, dikt)
         d.addCallback(lambda r: self.engine.get_properties(('c',)))
         d = self.assertDeferredEquals(d, {'c': dikt['c']})
         d.addCallback(lambda r: self.engine.set_properties(dict(c=False)))
         d.addCallback(lambda r: self.engine.get_properties(('c', 'd')))
         d = self.assertDeferredEquals(d, dict(c=False, d=None))
         return d
     
     def testClearProperties(self):
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d = self.engine.set_properties(dikt)
         d.addCallback(lambda r: self.engine.clear_properties())
         d.addCallback(lambda r: self.engine.get_properties())
         d = self.assertDeferredEquals(d, {})
         return d
     
     def testDelHasProperties(self):
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d = self.engine.set_properties(dikt)
         d.addCallback(lambda r: self.engine.del_properties(('b','e')))
         d.addCallback(lambda r: self.engine.has_properties(('a','b','c','d','e')))
         d = self.assertDeferredEquals(d, [True, False, True, True, False])
         return d
     
     def testStrictDict(self):
         s = """from IPython.kernel.engineservice import get_engine
 p = get_engine(%s).properties"""%self.engine.id
         d = self.engine.execute(s)
         d.addCallback(lambda r: self.engine.execute("p['a'] = lambda _:None"))
         d = self.assertDeferredRaises(d, error.InvalidProperty)
         d.addCallback(lambda r: self.engine.execute("p['a'] = range(5)"))
         d.addCallback(lambda r: self.engine.execute("p['a'].append(5)"))
         d.addCallback(lambda r: self.engine.get_properties('a'))
         d = self.assertDeferredEquals(d, dict(a=range(5)))
         return d
         
 Parametric(IEnginePropertiesTestCase)

IPython/kernel/tests/multienginetest.py

@@ -1,838 +1,838 b''
 # encoding: utf-8
 
 """"""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from twisted.internet import defer
 
 from IPython.kernel import engineservice as es
 from IPython.kernel import multiengine as me
 from IPython.kernel import newserialized
 from IPython.kernel.error import NotDefined
-from IPython.testutils import util
-from IPython.testutils.parametric import parametric, Parametric
+from IPython.testing import util
+from IPython.testing.parametric import parametric, Parametric
 from IPython.kernel import newserialized
 from IPython.kernel.util import printer
 from IPython.kernel.error import (InvalidEngineID,
     NoEnginesRegistered,
     CompositeError,
     InvalidDeferredID)
 from IPython.kernel.tests.engineservicetest import validCommands, invalidCommands
 from IPython.kernel.core.interpreter import Interpreter
 
 
 #-------------------------------------------------------------------------------
 # Base classes and utilities
 #-------------------------------------------------------------------------------
 
 class IMultiEngineBaseTestCase(object):
     """Basic utilities for working with multiengine tests.
 
     Some subclass should define:
 
     * self.multiengine
     * self.engines to keep track of engines for clean up"""
 
     def createShell(self):
         return Interpreter()
 
     def addEngine(self, n=1):
         for i in range(n):
             e = es.EngineService()
             e.startService()
             regDict = self.controller.register_engine(es.QueuedEngine(e), None)
             e.id = regDict['id']
             self.engines.append(e)
 
 
 def testf(x):
     return 2.0*x
 
 
 globala = 99
 
 
 def testg(x):
     return  globala*x
 
 
 def isdid(did):
     if not isinstance(did, str):
         return False
     if not len(did)==40:
         return False
     return True
 
 
 def _raise_it(f):
     try:
         f.raiseException()
     except CompositeError, e:
         e.raise_exception()
 
 #-------------------------------------------------------------------------------
 # IMultiEngineTestCase
 #-------------------------------------------------------------------------------
 
 class IMultiEngineTestCase(IMultiEngineBaseTestCase):
     """A test for any object that implements IEngineMultiplexer.
 
     self.multiengine must be defined and implement IEngineMultiplexer.
     """
 
     def testIMultiEngineInterface(self):
         """Does self.engine claim to implement IEngineCore?"""
         self.assert_(me.IEngineMultiplexer.providedBy(self.multiengine))
         self.assert_(me.IMultiEngine.providedBy(self.multiengine))
 
     def testIEngineMultiplexerInterfaceMethods(self):
         """Does self.engine have the methods and attributes in IEngineCore."""
         for m in list(me.IEngineMultiplexer):
             self.assert_(hasattr(self.multiengine, m))
 
     def testIEngineMultiplexerDeferreds(self):
         self.addEngine(1)
         d= self.multiengine.execute('a=5', targets=0)
         d.addCallback(lambda _: self.multiengine.push(dict(a=5),targets=0))
         d.addCallback(lambda _: self.multiengine.push(dict(a=5, b='asdf', c=[1,2,3]),targets=0))
         d.addCallback(lambda _: self.multiengine.pull(('a','b','c'),targets=0))
         d.addCallback(lambda _: self.multiengine.get_result(targets=0))
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.keys(targets=0))
         d.addCallback(lambda _: self.multiengine.push_serialized(dict(a=newserialized.serialize(10)),targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a',targets=0))
         d.addCallback(lambda _: self.multiengine.clear_queue(targets=0))
         d.addCallback(lambda _: self.multiengine.queue_status(targets=0))
         return d
 
     def testInvalidEngineID(self):
          self.addEngine(1)
          badID = 100
          d = self.multiengine.execute('a=5', targets=badID)
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.push(dict(a=5), targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.pull('a', targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.reset(targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.keys(targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.push_serialized(dict(a=newserialized.serialize(10)), targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.queue_status(targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          return d
 
     def testNoEnginesRegistered(self):
         badID = 'all'
         d= self.multiengine.execute('a=5', targets=badID)
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.push(dict(a=5), targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.pull('a', targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.get_result(targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.reset(targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.keys(targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.push_serialized(dict(a=newserialized.serialize(10)), targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.queue_status(targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         return d
 
     def runExecuteAll(self, d, cmd, shell):
         actual = shell.execute(cmd)
         d.addCallback(lambda _: self.multiengine.execute(cmd))
         def compare(result):
             for r in result:
                 actual['id'] = r['id']
                 self.assertEquals(r, actual)
         d.addCallback(compare)
 
     def testExecuteAll(self):
         self.addEngine(4)
         d= defer.Deferred()
         shell = Interpreter()
         for cmd in validCommands:
                 self.runExecuteAll(d, cmd, shell)
         d.callback(None)
         return d
 
     # The following two methods show how to do parametrized
     # tests.  This is really slick!  Same is used above.
     def runExecuteFailures(self, cmd, exc):
         self.addEngine(4)
         d= self.multiengine.execute(cmd)
         d.addErrback(lambda f: self.assertRaises(exc, _raise_it, f))
         return d
 
     @parametric
     def testExecuteFailures(cls):
         return [(cls.runExecuteFailures,cmd,exc) for
                 cmd,exc in invalidCommands]
 
     def testPushPull(self):
         self.addEngine(1)
         objs = [10,"hi there",1.2342354,{"p":(1,2)}]
         d= self.multiengine.push(dict(key=objs[0]), targets=0)
         d.addCallback(lambda _: self.multiengine.pull('key', targets=0))
         d.addCallback(lambda r: self.assertEquals(r, [objs[0]]))
         d.addCallback(lambda _: self.multiengine.push(dict(key=objs[1]), targets=0))
         d.addCallback(lambda _: self.multiengine.pull('key', targets=0))
         d.addCallback(lambda r: self.assertEquals(r, [objs[1]]))
         d.addCallback(lambda _: self.multiengine.push(dict(key=objs[2]), targets=0))
         d.addCallback(lambda _: self.multiengine.pull('key', targets=0))
         d.addCallback(lambda r: self.assertEquals(r, [objs[2]]))
         d.addCallback(lambda _: self.multiengine.push(dict(key=objs[3]), targets=0))
         d.addCallback(lambda _: self.multiengine.pull('key', targets=0))
         d.addCallback(lambda r: self.assertEquals(r, [objs[3]]))
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.pull('a', targets=0))
         d.addErrback(lambda f: self.assertRaises(NameError, _raise_it, f))
         d.addCallback(lambda _: self.multiengine.push(dict(a=10,b=20)))
         d.addCallback(lambda _: self.multiengine.pull(('a','b')))
         d.addCallback(lambda r: self.assertEquals(r, [[10,20]]))
         return d
 
     def testPushPullAll(self):
         self.addEngine(4)
         d= self.multiengine.push(dict(a=10))
         d.addCallback(lambda _: self.multiengine.pull('a'))
         d.addCallback(lambda r: self.assert_(r==[10,10,10,10]))
         d.addCallback(lambda _: self.multiengine.push(dict(a=10, b=20)))
         d.addCallback(lambda _: self.multiengine.pull(('a','b')))
         d.addCallback(lambda r: self.assert_(r==4*[[10,20]]))
         d.addCallback(lambda _: self.multiengine.push(dict(a=10, b=20), targets=0))
         d.addCallback(lambda _: self.multiengine.pull(('a','b'), targets=0))
         d.addCallback(lambda r: self.assert_(r==[[10,20]]))
         d.addCallback(lambda _: self.multiengine.push(dict(a=None, b=None), targets=0))
         d.addCallback(lambda _: self.multiengine.pull(('a','b'), targets=0))
         d.addCallback(lambda r: self.assert_(r==[[None,None]]))
         return d
 
     def testPushPullSerialized(self):
         self.addEngine(1)
         objs = [10,"hi there",1.2342354,{"p":(1,2)}]
         d= self.multiengine.push_serialized(dict(key=newserialized.serialize(objs[0])), targets=0)
         d.addCallback(lambda _: self.multiengine.pull_serialized('key', targets=0))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, objs[0]))
         d.addCallback(lambda _: self.multiengine.push_serialized(dict(key=newserialized.serialize(objs[1])), targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('key', targets=0))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, objs[1]))
         d.addCallback(lambda _: self.multiengine.push_serialized(dict(key=newserialized.serialize(objs[2])), targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('key', targets=0))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, objs[2]))
         d.addCallback(lambda _: self.multiengine.push_serialized(dict(key=newserialized.serialize(objs[3])), targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('key', targets=0))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, objs[3]))
         d.addCallback(lambda _: self.multiengine.push(dict(a=10,b=range(5)), targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized(('a','b'), targets=0))
         d.addCallback(lambda serial: [newserialized.IUnSerialized(s).getObject() for s in serial[0]])
         d.addCallback(lambda r: self.assertEquals(r, [10, range(5)]))
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=0))
         d.addErrback(lambda f: self.assertRaises(NameError, _raise_it, f))
         return d
 
         objs = [10,"hi there",1.2342354,{"p":(1,2)}]
         d= defer.succeed(None)
         for o in objs:
             self.multiengine.push_serialized(0, key=newserialized.serialize(o))
             value = self.multiengine.pull_serialized(0, 'key')
             value.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
             d = self.assertDeferredEquals(value,o,d)
         return d
 
     def runGetResultAll(self, d, cmd, shell):
         actual = shell.execute(cmd)
         d.addCallback(lambda _: self.multiengine.execute(cmd))
         d.addCallback(lambda _: self.multiengine.get_result())
         def compare(result):
             for r in result:
                 actual['id'] = r['id']
                 self.assertEquals(r, actual)
         d.addCallback(compare)
 
     def testGetResultAll(self):
         self.addEngine(4)
         d= defer.Deferred()
         shell = Interpreter()
         for cmd in validCommands:
                 self.runGetResultAll(d, cmd, shell)
         d.callback(None)
         return d
 
     def testGetResultDefault(self):
         self.addEngine(1)
         target = 0
         cmd = 'a=5'
         shell = self.createShell()
         shellResult = shell.execute(cmd)
         def popit(dikt, key):
             dikt.pop(key)
             return dikt
         d= self.multiengine.execute(cmd, targets=target)
         d.addCallback(lambda _: self.multiengine.get_result(targets=target))
         d.addCallback(lambda r: self.assertEquals(shellResult, popit(r[0],'id')))
         return d
 
     def testGetResultFailure(self):
         self.addEngine(1)
         d= self.multiengine.get_result(None, targets=0)
         d.addErrback(lambda f: self.assertRaises(IndexError, _raise_it, f))
         d.addCallback(lambda _: self.multiengine.get_result(10, targets=0))
         d.addErrback(lambda f: self.assertRaises(IndexError, _raise_it, f))
         return d
 
     def testPushFunction(self):
         self.addEngine(1)
         d= self.multiengine.push_function(dict(f=testf), targets=0)
         d.addCallback(lambda _: self.multiengine.execute('result = f(10)', targets=0))
         d.addCallback(lambda _: self.multiengine.pull('result', targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0], testf(10)))
         d.addCallback(lambda _: self.multiengine.push(dict(globala=globala), targets=0))
         d.addCallback(lambda _: self.multiengine.push_function(dict(g=testg), targets=0))
         d.addCallback(lambda _: self.multiengine.execute('result = g(10)', targets=0))
         d.addCallback(lambda _: self.multiengine.pull('result', targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0], testg(10)))
         return d
 
     def testPullFunction(self):
         self.addEngine(1)
         d= self.multiengine.push(dict(a=globala), targets=0)
         d.addCallback(lambda _: self.multiengine.push_function(dict(f=testf), targets=0))
         d.addCallback(lambda _: self.multiengine.pull_function('f', targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0](10), testf(10)))
         d.addCallback(lambda _: self.multiengine.execute("def g(x): return x*x", targets=0))
         d.addCallback(lambda _: self.multiengine.pull_function(('f','g'),targets=0))
         d.addCallback(lambda r: self.assertEquals((r[0][0](10),r[0][1](10)), (testf(10), 100)))
         return d
 
     def testPushFunctionAll(self):
         self.addEngine(4)
         d= self.multiengine.push_function(dict(f=testf))
         d.addCallback(lambda _: self.multiengine.execute('result = f(10)'))
         d.addCallback(lambda _: self.multiengine.pull('result'))
         d.addCallback(lambda r: self.assertEquals(r, 4*[testf(10)]))
         d.addCallback(lambda _: self.multiengine.push(dict(globala=globala)))
         d.addCallback(lambda _: self.multiengine.push_function(dict(testg=testg)))
         d.addCallback(lambda _: self.multiengine.execute('result = testg(10)'))
         d.addCallback(lambda _: self.multiengine.pull('result'))
         d.addCallback(lambda r: self.assertEquals(r, 4*[testg(10)]))
         return d
 
     def testPullFunctionAll(self):
         self.addEngine(4)
         d= self.multiengine.push_function(dict(f=testf))
         d.addCallback(lambda _: self.multiengine.pull_function('f'))
         d.addCallback(lambda r: self.assertEquals([func(10) for func in r], 4*[testf(10)]))
         return d
 
     def testGetIDs(self):
         self.addEngine(1)
         d= self.multiengine.get_ids()
         d.addCallback(lambda r: self.assertEquals(r, [0]))
         d.addCallback(lambda _: self.addEngine(3))
         d.addCallback(lambda _: self.multiengine.get_ids())
         d.addCallback(lambda r: self.assertEquals(r, [0,1,2,3]))
         return d
 
     def testClearQueue(self):
         self.addEngine(4)
         d= self.multiengine.clear_queue()
         d.addCallback(lambda r: self.assertEquals(r,4*[None]))
         return d
 
     def testQueueStatus(self):
         self.addEngine(4)
         d= self.multiengine.queue_status(targets=0)
         d.addCallback(lambda r: self.assert_(isinstance(r[0],tuple)))
         return d
 
     def testGetSetProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.get_properties())
         d.addCallback(lambda r: self.assertEquals(r, 4*[dikt]))
         d.addCallback(lambda r: self.multiengine.get_properties(('c',)))
         d.addCallback(lambda r: self.assertEquals(r, 4*[{'c': dikt['c']}]))
         d.addCallback(lambda r: self.multiengine.set_properties(dict(c=False)))
         d.addCallback(lambda r: self.multiengine.get_properties(('c', 'd')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[dict(c=False, d=None)]))
         return d
 
     def testClearProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.clear_properties())
         d.addCallback(lambda r: self.multiengine.get_properties())
         d.addCallback(lambda r: self.assertEquals(r, 4*[{}]))
         return d
 
     def testDelHasProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.del_properties(('b','e')))
         d.addCallback(lambda r: self.multiengine.has_properties(('a','b','c','d','e')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[True, False, True, True, False]]))
         return d
 
 Parametric(IMultiEngineTestCase)
 
 #-------------------------------------------------------------------------------
 # ISynchronousMultiEngineTestCase
 #-------------------------------------------------------------------------------
 
 class ISynchronousMultiEngineTestCase(IMultiEngineBaseTestCase):
 
     def testISynchronousMultiEngineInterface(self):
         """Does self.engine claim to implement IEngineCore?"""
         self.assert_(me.ISynchronousEngineMultiplexer.providedBy(self.multiengine))
         self.assert_(me.ISynchronousMultiEngine.providedBy(self.multiengine))
 
     def testExecute(self):
         self.addEngine(4)
         execute = self.multiengine.execute
         d= execute('a=5', targets=0, block=True)
         d.addCallback(lambda r: self.assert_(len(r)==1))
         d.addCallback(lambda _: execute('b=10'))
         d.addCallback(lambda r: self.assert_(len(r)==4))
         d.addCallback(lambda _: execute('c=30', block=False))
         d.addCallback(lambda did: self.assert_(isdid(did)))
         d.addCallback(lambda _: execute('d=[0,1,2]', block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assert_(len(r)==4))
         return d
 
     def testPushPull(self):
         data = dict(a=10, b=1.05, c=range(10), d={'e':(1,2),'f':'hi'})
         self.addEngine(4)
         push = self.multiengine.push
         pull = self.multiengine.pull
         d= push({'data':data}, targets=0)
         d.addCallback(lambda r: pull('data', targets=0))
         d.addCallback(lambda r: self.assertEqual(r,[data]))
         d.addCallback(lambda _: push({'data':data}))
         d.addCallback(lambda r: pull('data'))
         d.addCallback(lambda r: self.assertEqual(r,4*[data]))
         d.addCallback(lambda _: push({'data':data}, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda _: pull('data', block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEqual(r,4*[data]))
         d.addCallback(lambda _: push(dict(a=10,b=20)))
         d.addCallback(lambda _: pull(('a','b')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[10,20]]))
         return d
 
     def testPushPullFunction(self):
         self.addEngine(4)
         pushf = self.multiengine.push_function
         pullf = self.multiengine.pull_function
         push = self.multiengine.push
         pull = self.multiengine.pull
         execute = self.multiengine.execute
         d= pushf({'testf':testf}, targets=0)
         d.addCallback(lambda r: pullf('testf', targets=0))
         d.addCallback(lambda r: self.assertEqual(r[0](1.0), testf(1.0)))
         d.addCallback(lambda _: execute('r = testf(10)', targets=0))
         d.addCallback(lambda _: pull('r', targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0], testf(10)))
         d.addCallback(lambda _: pushf({'testf':testf}, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda _: pullf('testf', block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEqual(r[0](1.0), testf(1.0)))
         d.addCallback(lambda _: execute("def g(x): return x*x", targets=0))
         d.addCallback(lambda _: pullf(('testf','g'),targets=0))
         d.addCallback(lambda r: self.assertEquals((r[0][0](10),r[0][1](10)), (testf(10), 100)))
         return d
 
     def testGetResult(self):
         shell = Interpreter()
         result1 = shell.execute('a=10')
         result1['id'] = 0
         result2 = shell.execute('b=20')
         result2['id'] = 0
         execute= self.multiengine.execute
         get_result = self.multiengine.get_result
         self.addEngine(1)
         d= execute('a=10')
         d.addCallback(lambda _: get_result())
         d.addCallback(lambda r: self.assertEquals(r[0], result1))
         d.addCallback(lambda _: execute('b=20'))
         d.addCallback(lambda _: get_result(1))
         d.addCallback(lambda r: self.assertEquals(r[0], result1))
         d.addCallback(lambda _: get_result(2, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r[0], result2))
         return d
 
     def testResetAndKeys(self):
         self.addEngine(1)
 
         #Blocking mode
         d= self.multiengine.push(dict(a=10, b=20, c=range(10)), targets=0)
         d.addCallback(lambda _: self.multiengine.keys(targets=0))
         def keys_found(keys):
             self.assert_('a' in keys[0])
             self.assert_('b' in keys[0])
             self.assert_('b' in keys[0])
         d.addCallback(keys_found)
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.keys(targets=0))
         def keys_not_found(keys):
             self.assert_('a' not in keys[0])
             self.assert_('b' not in keys[0])
             self.assert_('b' not in keys[0])
         d.addCallback(keys_not_found)
 
         #Non-blocking mode
         d.addCallback(lambda _: self.multiengine.push(dict(a=10, b=20, c=range(10)), targets=0))
         d.addCallback(lambda _: self.multiengine.keys(targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         def keys_found(keys):
             self.assert_('a' in keys[0])
             self.assert_('b' in keys[0])
             self.assert_('b' in keys[0])
         d.addCallback(keys_found)
         d.addCallback(lambda _: self.multiengine.reset(targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda _: self.multiengine.keys(targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         def keys_not_found(keys):
             self.assert_('a' not in keys[0])
             self.assert_('b' not in keys[0])
             self.assert_('b' not in keys[0])
         d.addCallback(keys_not_found)
 
         return d
 
     def testPushPullSerialized(self):
         self.addEngine(1)
         dikt = dict(a=10,b='hi there',c=1.2345,d={'p':(1,2)})
         sdikt = {}
         for k,v in dikt.iteritems():
             sdikt[k] = newserialized.serialize(v)
         d= self.multiengine.push_serialized(dict(a=sdikt['a']), targets=0)
         d.addCallback(lambda _: self.multiengine.pull('a',targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0], dikt['a']))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=0))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, dikt['a']))
         d.addCallback(lambda _: self.multiengine.push_serialized(sdikt, targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized(sdikt.keys(), targets=0))
         d.addCallback(lambda serial: [newserialized.IUnSerialized(s).getObject() for s in serial[0]])
         d.addCallback(lambda r: self.assertEquals(r, dikt.values()))
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=0))
         d.addErrback(lambda f: self.assertRaises(NameError, _raise_it, f))
 
         #Non-blocking mode
         d.addCallback(lambda r: self.multiengine.push_serialized(dict(a=sdikt['a']), targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda _: self.multiengine.pull('a',targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0], dikt['a']))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, dikt['a']))
         d.addCallback(lambda _: self.multiengine.push_serialized(sdikt, targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda _: self.multiengine.pull_serialized(sdikt.keys(), targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda serial: [newserialized.IUnSerialized(s).getObject() for s in serial[0]])
         d.addCallback(lambda r: self.assertEquals(r, dikt.values()))
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addErrback(lambda f: self.assertRaises(NameError, _raise_it, f))
         return d
 
     def testClearQueue(self):
         self.addEngine(4)
         d= self.multiengine.clear_queue()
         d.addCallback(lambda r: self.multiengine.clear_queue(block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r,4*[None]))
         return d
 
     def testQueueStatus(self):
         self.addEngine(4)
         d= self.multiengine.queue_status(targets=0)
         d.addCallback(lambda r: self.assert_(isinstance(r[0],tuple)))
         d.addCallback(lambda r: self.multiengine.queue_status(targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assert_(isinstance(r[0],tuple)))
         return d
 
     def testGetIDs(self):
         self.addEngine(1)
         d= self.multiengine.get_ids()
         d.addCallback(lambda r: self.assertEquals(r, [0]))
         d.addCallback(lambda _: self.addEngine(3))
         d.addCallback(lambda _: self.multiengine.get_ids())
         d.addCallback(lambda r: self.assertEquals(r, [0,1,2,3]))
         return d
 
     def testGetSetProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.get_properties())
         d.addCallback(lambda r: self.assertEquals(r, 4*[dikt]))
         d.addCallback(lambda r: self.multiengine.get_properties(('c',)))
         d.addCallback(lambda r: self.assertEquals(r, 4*[{'c': dikt['c']}]))
         d.addCallback(lambda r: self.multiengine.set_properties(dict(c=False)))
         d.addCallback(lambda r: self.multiengine.get_properties(('c', 'd')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[dict(c=False, d=None)]))
 
         #Non-blocking
         d.addCallback(lambda r: self.multiengine.set_properties(dikt, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.get_properties(block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, 4*[dikt]))
         d.addCallback(lambda r: self.multiengine.get_properties(('c',), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, 4*[{'c': dikt['c']}]))
         d.addCallback(lambda r: self.multiengine.set_properties(dict(c=False), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.get_properties(('c', 'd'), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, 4*[dict(c=False, d=None)]))
         return d
 
     def testClearProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.clear_properties())
         d.addCallback(lambda r: self.multiengine.get_properties())
         d.addCallback(lambda r: self.assertEquals(r, 4*[{}]))
 
         #Non-blocking
         d.addCallback(lambda r: self.multiengine.set_properties(dikt, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.clear_properties(block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.get_properties(block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, 4*[{}]))
         return d
 
     def testDelHasProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.del_properties(('b','e')))
         d.addCallback(lambda r: self.multiengine.has_properties(('a','b','c','d','e')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[True, False, True, True, False]]))
 
         #Non-blocking
         d.addCallback(lambda r: self.multiengine.set_properties(dikt, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.del_properties(('b','e'), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.has_properties(('a','b','c','d','e'), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[True, False, True, True, False]]))
         return d
 
     def test_clear_pending_deferreds(self):
         self.addEngine(4)
         did_list = []
         d= self.multiengine.execute('a=10',block=False)
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.push(dict(b=10),block=False))
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.pull(('a','b'),block=False))
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.clear_pending_deferreds())
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[0],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[1],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[2],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         return d
 
 #-------------------------------------------------------------------------------
 # Coordinator test cases
 #-------------------------------------------------------------------------------
 
 class IMultiEngineCoordinatorTestCase(object):
 
     def testScatterGather(self):
         self.addEngine(4)
         d= self.multiengine.scatter('a', range(16))
         d.addCallback(lambda r: self.multiengine.gather('a'))
         d.addCallback(lambda r: self.assertEquals(r, range(16)))
         d.addCallback(lambda _: self.multiengine.gather('asdf'))
         d.addErrback(lambda f: self.assertRaises(NameError, _raise_it, f))
         return d
 
     def testScatterGatherNumpy(self):
         try:
             import numpy
             from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
         except:
             return
         else:
             self.addEngine(4)
             a = numpy.arange(16)
             d = self.multiengine.scatter('a', a)
             d.addCallback(lambda r: self.multiengine.gather('a'))
             d.addCallback(lambda r: assert_array_equal(r, a))
             return d
 
     def testMap(self):
         self.addEngine(4)
         def f(x):
             return x**2
         data = range(16)
         d= self.multiengine.map(f, data)
         d.addCallback(lambda r: self.assertEquals(r,[f(x) for x in data]))
         return d
 
 
 class ISynchronousMultiEngineCoordinatorTestCase(IMultiEngineCoordinatorTestCase):
 
     def testScatterGatherNonblocking(self):
         self.addEngine(4)
         d= self.multiengine.scatter('a', range(16), block=False)
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.gather('a', block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, range(16)))
         return d
 
     def testScatterGatherNumpyNonblocking(self):
         try:
             import numpy
             from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
         except:
             return
         else:
             self.addEngine(4)
             a = numpy.arange(16)
             d = self.multiengine.scatter('a', a, block=False)
             d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
             d.addCallback(lambda r: self.multiengine.gather('a', block=False))
             d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
             d.addCallback(lambda r: assert_array_equal(r, a))
             return d
 
     def testMapNonblocking(self):
         self.addEngine(4)
         def f(x):
             return x**2
         data = range(16)
         d= self.multiengine.map(f, data, block=False)
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r,[f(x) for x in data]))
         return d
 
     def test_clear_pending_deferreds(self):
         self.addEngine(4)
         did_list = []
         d= self.multiengine.scatter('a',range(16),block=False)
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.gather('a',block=False))
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.map(lambda x: x, range(16),block=False))
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.clear_pending_deferreds())
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[0],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[1],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[2],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         return d
 
 #-------------------------------------------------------------------------------
 # Extras test cases
 #-------------------------------------------------------------------------------
 
 class IMultiEngineExtrasTestCase(object):
 
     def testZipPull(self):
         self.addEngine(4)
         d= self.multiengine.push(dict(a=10,b=20))
         d.addCallback(lambda r: self.multiengine.zip_pull(('a','b')))
         d.addCallback(lambda r: self.assert_(r, [4*[10],4*[20]]))
         return d
 
     def testRun(self):
         self.addEngine(4)
         import tempfile
         fname = tempfile.mktemp('foo.py')
         f= open(fname, 'w')
         f.write('a = 10\nb=30')
         f.close()
         d= self.multiengine.run(fname)
         d.addCallback(lambda r: self.multiengine.pull(('a','b')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[10,30]]))
         return d
 
 
 class ISynchronousMultiEngineExtrasTestCase(IMultiEngineExtrasTestCase):
 
     def testZipPullNonblocking(self):
         self.addEngine(4)
         d= self.multiengine.push(dict(a=10,b=20))
         d.addCallback(lambda r: self.multiengine.zip_pull(('a','b'), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assert_(r, [4*[10],4*[20]]))
         return d
 
     def testRunNonblocking(self):
         self.addEngine(4)
         import tempfile
         fname = tempfile.mktemp('foo.py')
         f= open(fname, 'w')
         f.write('a = 10\nb=30')
         f.close()
         d= self.multiengine.run(fname, block=False)
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.pull(('a','b')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[10,30]]))
         return d
 
 
 #-------------------------------------------------------------------------------
 # IFullSynchronousMultiEngineTestCase
 #-------------------------------------------------------------------------------
 
 class IFullSynchronousMultiEngineTestCase(ISynchronousMultiEngineTestCase,
     ISynchronousMultiEngineCoordinatorTestCase,
     ISynchronousMultiEngineExtrasTestCase):
     pass

IPython/kernel/tests/test_controllerservice.py

@@ -1,40 +1,40 b''
 # encoding: utf-8
 
 """This file contains unittests for the kernel.engineservice.py module.
 
 Things that should be tested:
 
  - Should the EngineService return Deferred objects?
  - Run the same tests that are run in shell.py.
  - Make sure that the Interface is really implemented.
  - The startService and stopService methods.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from twisted.application.service import IService
 from IPython.kernel.controllerservice import ControllerService
 from IPython.kernel.tests import multienginetest as met
 from controllertest import IControllerCoreTestCase
-from IPython.testutils.util import DeferredTestCase
+from IPython.testing.util import DeferredTestCase
 
 class BasicControllerServiceTest(DeferredTestCase,
     IControllerCoreTestCase):
     
     def setUp(self):
         self.controller  = ControllerService()
         self.controller.startService()
     
     def tearDown(self):
         self.controller.stopService()

IPython/kernel/tests/test_enginefc.py

@@ -1,89 +1,89 b''
 # encoding: utf-8
 
 """This file contains unittests for the enginepb.py module."""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 
 from twisted.python import components
 from twisted.internet import reactor, defer
 from twisted.spread import pb
 from twisted.internet.base import DelayedCall
 DelayedCall.debug = True
 
 import zope.interface as zi
 
 from IPython.kernel.fcutil import Tub, UnauthenticatedTub
 from IPython.kernel import engineservice as es
-from IPython.testutils.util import DeferredTestCase
+from IPython.testing.util import DeferredTestCase
 from IPython.kernel.controllerservice import IControllerBase
 from IPython.kernel.enginefc import FCRemoteEngineRefFromService, IEngineBase
 from IPython.kernel.engineservice import IEngineQueued
 from IPython.kernel.engineconnector import EngineConnector
     
 from IPython.kernel.tests.engineservicetest import \
     IEngineCoreTestCase, \
     IEngineSerializedTestCase, \
     IEngineQueuedTestCase
 
 class EngineFCTest(DeferredTestCase, 
                    IEngineCoreTestCase, 
                    IEngineSerializedTestCase,
                    IEngineQueuedTestCase
                    ):
         
     zi.implements(IControllerBase)
         
     def setUp(self):
 
         # Start a server and append to self.servers
         self.controller_reference = FCRemoteEngineRefFromService(self)
         self.controller_tub = Tub()
         self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
         self.controller_tub.setLocation('127.0.0.1:10105')
         
         furl = self.controller_tub.registerReference(self.controller_reference)
         self.controller_tub.startService()
         
         # Start an EngineService and append to services/client
         self.engine_service = es.EngineService()
         self.engine_service.startService()
         self.engine_tub = Tub()
         self.engine_tub.startService()
         engine_connector = EngineConnector(self.engine_tub)
         d = engine_connector.connect_to_controller(self.engine_service, furl)
         # This deferred doesn't fire until after register_engine has returned and
         # thus, self.engine has been defined and the tets can proceed.
         return d
     
     def tearDown(self):
         dlist = []
         # Shut down the engine
         d = self.engine_tub.stopService()
         dlist.append(d)
         # Shut down the controller
         d = self.controller_tub.stopService()
         dlist.append(d)
         return defer.DeferredList(dlist)
     
     #---------------------------------------------------------------------------
     # Make me look like a basic controller
     #---------------------------------------------------------------------------
     
     def register_engine(self, engine_ref, id=None, ip=None, port=None, pid=None):
         self.engine = IEngineQueued(IEngineBase(engine_ref))
         return {'id':id}
     
     def unregister_engine(self, id):
         pass
  No newline at end of file

IPython/kernel/tests/test_engineservice.py

@@ -1,64 +1,64 b''
 # encoding: utf-8
 
 """This file contains unittests for the kernel.engineservice.py module.
 
 Things that should be tested:
 
  - Should the EngineService return Deferred objects?
  - Run the same tests that are run in shell.py.
  - Make sure that the Interface is really implemented.
  - The startService and stopService methods.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from twisted.internet import defer
 from twisted.application.service import IService
 
 from IPython.kernel import engineservice as es
-from IPython.testutils.util import DeferredTestCase
+from IPython.testing.util import DeferredTestCase
 from IPython.kernel.tests.engineservicetest import \
     IEngineCoreTestCase, \
     IEngineSerializedTestCase, \
     IEngineQueuedTestCase, \
     IEnginePropertiesTestCase
     
 
 class BasicEngineServiceTest(DeferredTestCase,
                              IEngineCoreTestCase, 
                              IEngineSerializedTestCase,
                              IEnginePropertiesTestCase):
     
     def setUp(self):
         self.engine = es.EngineService()
         self.engine.startService()
     
     def tearDown(self):
         return self.engine.stopService()
 
 class QueuedEngineServiceTest(DeferredTestCase,
                               IEngineCoreTestCase, 
                               IEngineSerializedTestCase,
                               IEnginePropertiesTestCase,
                               IEngineQueuedTestCase):
                               
     def setUp(self):
         self.rawEngine = es.EngineService()
         self.rawEngine.startService()
         self.engine = es.IEngineQueued(self.rawEngine)
         
     def tearDown(self):
         return self.rawEngine.stopService()
 
  

IPython/kernel/tests/test_multiengine.py

@@ -1,52 +1,52 b''
 # encoding: utf-8
 
 """"""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from twisted.internet import defer
-from IPython.testutils.util import DeferredTestCase
+from IPython.testing.util import DeferredTestCase
 from IPython.kernel.controllerservice import ControllerService
 from IPython.kernel import multiengine as me
 from IPython.kernel.tests.multienginetest import (IMultiEngineTestCase,
     ISynchronousMultiEngineTestCase)
     
     
 class BasicMultiEngineTestCase(DeferredTestCase, IMultiEngineTestCase):
     
     def setUp(self):
         self.controller = ControllerService()
         self.controller.startService()
         self.multiengine = me.IMultiEngine(self.controller)
         self.engines = []
         
     def tearDown(self):
         self.controller.stopService()
         for e in self.engines:
             e.stopService()
 
 
 class SynchronousMultiEngineTestCase(DeferredTestCase, ISynchronousMultiEngineTestCase):
     
     def setUp(self):
         self.controller = ControllerService()
         self.controller.startService()
         self.multiengine = me.ISynchronousMultiEngine(me.IMultiEngine(self.controller))
         self.engines = []
         
     def tearDown(self):
         self.controller.stopService()
         for e in self.engines:
             e.stopService()
 

IPython/kernel/tests/test_multienginefc.py

@@ -1,68 +1,68 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from twisted.internet import defer, reactor
 
 from IPython.kernel.fcutil import Tub, UnauthenticatedTub
 
-from IPython.testutils.util import DeferredTestCase
+from IPython.testing.util import DeferredTestCase
 from IPython.kernel.controllerservice import ControllerService
 from IPython.kernel.multiengine import IMultiEngine
 from IPython.kernel.tests.multienginetest import IFullSynchronousMultiEngineTestCase
 from IPython.kernel.multienginefc import IFCSynchronousMultiEngine
 from IPython.kernel import multiengine as me
 from IPython.kernel.clientconnector import ClientConnector
 
 
 class FullSynchronousMultiEngineTestCase(DeferredTestCase, IFullSynchronousMultiEngineTestCase):
     
     def setUp(self):
         
         self.engines = []
                 
         self.controller = ControllerService()
         self.controller.startService()
         self.imultiengine = IMultiEngine(self.controller)
         self.mec_referenceable = IFCSynchronousMultiEngine(self.imultiengine)
 
         self.controller_tub = Tub()
         self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
         self.controller_tub.setLocation('127.0.0.1:10105')
         
         furl = self.controller_tub.registerReference(self.mec_referenceable)
         self.controller_tub.startService()
         
         self.client_tub = ClientConnector()
         d = self.client_tub.get_multiengine_client(furl)
         d.addCallback(self.handle_got_client)
         return d
         
     def handle_got_client(self, client):
         self.multiengine = client
     
     def tearDown(self):
         dlist = []
         # Shut down the multiengine client
         d = self.client_tub.tub.stopService()
         dlist.append(d)
         # Shut down the engines
         for e in self.engines:
             e.stopService()
         # Shut down the controller
         d = self.controller_tub.stopService()
         d.addBoth(lambda _: self.controller.stopService())
         dlist.append(d)
         return defer.DeferredList(dlist)

IPython/kernel/tests/test_newserialized.py

@@ -1,99 +1,99 b''
 # encoding: utf-8
 
 """This file contains unittests for the shell.py module."""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import zope.interface as zi
 from twisted.trial import unittest
-from IPython.testutils.util import DeferredTestCase
+from IPython.testing.util import DeferredTestCase
 
 from IPython.kernel.newserialized import \
     ISerialized, \
     IUnSerialized, \
     Serialized, \
     UnSerialized, \
     SerializeIt, \
     UnSerializeIt
     
 #-------------------------------------------------------------------------------
 # Tests
 #-------------------------------------------------------------------------------
     
 class SerializedTestCase(unittest.TestCase):
     
     def setUp(self):
         pass
         
     def tearDown(self):
         pass
         
     def testSerializedInterfaces(self):
 
         us = UnSerialized({'a':10, 'b':range(10)})
         s = ISerialized(us)
         uss = IUnSerialized(s)
         self.assert_(ISerialized.providedBy(s))
         self.assert_(IUnSerialized.providedBy(us))
         self.assert_(IUnSerialized.providedBy(uss))
         for m in list(ISerialized):
             self.assert_(hasattr(s, m))
         for m in list(IUnSerialized):
             self.assert_(hasattr(us, m))
         for m in list(IUnSerialized):
             self.assert_(hasattr(uss, m))
 
     def testPickleSerialized(self):
         obj = {'a':1.45345, 'b':'asdfsdf', 'c':10000L}
         original = UnSerialized(obj)
         originalSer = ISerialized(original)
         firstData = originalSer.getData()
         firstTD = originalSer.getTypeDescriptor()
         firstMD = originalSer.getMetadata()
         self.assert_(firstTD == 'pickle')
         self.assert_(firstMD == {})
         unSerialized = IUnSerialized(originalSer)
         secondObj = unSerialized.getObject()
         for k, v in secondObj.iteritems():
             self.assert_(obj[k] == v)
         secondSer = ISerialized(UnSerialized(secondObj))
         self.assert_(firstData == secondSer.getData())
         self.assert_(firstTD == secondSer.getTypeDescriptor() )
         self.assert_(firstMD == secondSer.getMetadata())
         
     def testNDArraySerialized(self):
         try:
             import numpy
         except ImportError:
             pass
         else:
             a = numpy.linspace(0.0, 1.0, 1000)
             unSer1 = UnSerialized(a)
             ser1 = ISerialized(unSer1)
             td = ser1.getTypeDescriptor()
             self.assert_(td == 'ndarray')
             md = ser1.getMetadata()
             self.assert_(md['shape'] == a.shape)
             self.assert_(md['dtype'] == a.dtype.str)
             buff = ser1.getData()
             self.assert_(buff == numpy.getbuffer(a))
             s = Serialized(buff, td, md)
             us = IUnSerialized(s)
             final = us.getObject()
             self.assert_(numpy.getbuffer(a) == numpy.getbuffer(final))
             self.assert_(a.dtype.str == final.dtype.str)
             self.assert_(a.shape == final.shape)
             
             
     
  No newline at end of file

IPython/kernel/tests/test_pendingdeferred.py

@@ -1,215 +1,215 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
 """Tests for pendingdeferred.py"""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from twisted.internet import defer
 from twisted.python import failure
 
-from IPython.testutils import tcommon
-from IPython.testutils.tcommon import *
-from IPython.testutils.util import DeferredTestCase
+from IPython.testing import tcommon
+from IPython.testing.tcommon import *
+from IPython.testing.util import DeferredTestCase
 import IPython.kernel.pendingdeferred as pd
 from IPython.kernel import error
 from IPython.kernel.util import printer
 
 
 #-------------------------------------------------------------------------------
 # Setup for inline and standalone doctests
 #-------------------------------------------------------------------------------
 
 
 # If you have standalone doctests in a separate file, set their names in the
 # dt_files variable (as a single string  or a list thereof):
 dt_files = []
 
 # If you have any modules whose docstrings should be scanned for embedded tests
 # as examples accorging to standard doctest practice, set them here (as a
 # single string or a list thereof):
 dt_modules = []
 
 #-------------------------------------------------------------------------------
 # Regular Unittests
 #-------------------------------------------------------------------------------
 
 
 class Foo(object):
     
     def bar(self, bahz):
         return defer.succeed('blahblah: %s' % bahz)
 
 class TwoPhaseFoo(pd.PendingDeferredManager):
     
     def __init__(self, foo):
         self.foo = foo
         pd.PendingDeferredManager.__init__(self)
 
     @pd.two_phase
     def bar(self, bahz):
         return self.foo.bar(bahz)
 
 class PendingDeferredManagerTest(DeferredTestCase):
     
     def setUp(self):
         self.pdm = pd.PendingDeferredManager()
         
     def tearDown(self):
         pass
     
     def testBasic(self):
         dDict = {}
         # Create 10 deferreds and save them
         for i in range(10):
             d = defer.Deferred()
             did = self.pdm.save_pending_deferred(d)
             dDict[did] = d
         # Make sure they are begin saved
         for k in dDict.keys():
             self.assert_(self.pdm.quick_has_id(k))
         # Get the pending deferred (block=True), then callback with 'foo' and compare
         for did in dDict.keys()[0:5]:
             d = self.pdm.get_pending_deferred(did,block=True)
             dDict[did].callback('foo')
             d.addCallback(lambda r: self.assert_(r=='foo'))
         # Get the pending deferreds with (block=False) and make sure ResultNotCompleted is raised
         for did in dDict.keys()[5:10]:
             d = self.pdm.get_pending_deferred(did,block=False)
             d.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
         # Now callback the last 5, get them and compare.
         for did in dDict.keys()[5:10]:
             dDict[did].callback('foo')
             d = self.pdm.get_pending_deferred(did,block=False)
             d.addCallback(lambda r: self.assert_(r=='foo'))
     
     def test_save_then_delete(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         self.assert_(self.pdm.quick_has_id(did))
         self.pdm.delete_pending_deferred(did)
         self.assert_(not self.pdm.quick_has_id(did))
     
     def test_save_get_delete(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d2.addErrback(lambda f: self.assertRaises(error.AbortedPendingDeferredError, f.raiseException))
         self.pdm.delete_pending_deferred(did)
         return d2
    
     def test_double_get(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d3 = self.pdm.get_pending_deferred(did,True)
         d3.addErrback(lambda f: self.assertRaises(error.InvalidDeferredID, f.raiseException))
     
     def test_get_after_callback(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d.callback('foo')
         d2 = self.pdm.get_pending_deferred(did,True)
         d2.addCallback(lambda r: self.assertEquals(r,'foo'))
         self.assert_(not self.pdm.quick_has_id(did))
 
     def test_get_before_callback(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d.callback('foo')
         d2.addCallback(lambda r: self.assertEquals(r,'foo'))
         self.assert_(not self.pdm.quick_has_id(did))
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d2.addCallback(lambda r: self.assertEquals(r,'foo'))
         d.callback('foo')
         self.assert_(not self.pdm.quick_has_id(did))
     
     def test_get_after_errback(self):
         class MyError(Exception):
             pass
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d.errback(failure.Failure(MyError('foo')))
         d2 = self.pdm.get_pending_deferred(did,True)
         d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
         self.assert_(not self.pdm.quick_has_id(did))
 
     def test_get_before_errback(self):
         class MyError(Exception):
             pass
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d.errback(failure.Failure(MyError('foo')))
         d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
         self.assert_(not self.pdm.quick_has_id(did))
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
         d.errback(failure.Failure(MyError('foo')))
         self.assert_(not self.pdm.quick_has_id(did))
         
     def test_noresult_noblock(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,False)
         d2.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
 
     def test_with_callbacks(self):
         d = defer.Deferred()
         d.addCallback(lambda r: r+' foo')
         d.addCallback(lambda r: r+' bar')
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d.callback('bam')
         d2.addCallback(lambda r: self.assertEquals(r,'bam foo bar'))
     
     def test_with_errbacks(self):
         class MyError(Exception):
             pass
         d = defer.Deferred()
         d.addCallback(lambda r: 'foo')
         d.addErrback(lambda f: 'caught error')
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d.errback(failure.Failure(MyError('bam')))
         d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
     
     def test_nested_deferreds(self):
         d = defer.Deferred()
         d2 = defer.Deferred()
         d.addCallback(lambda r: d2)
         did = self.pdm.save_pending_deferred(d)
         d.callback('foo')
         d3 = self.pdm.get_pending_deferred(did,False)
         d3.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
         d2.callback('bar')
         d3 = self.pdm.get_pending_deferred(did,False)
         d3.addCallback(lambda r: self.assertEquals(r,'bar'))
 
 #-------------------------------------------------------------------------------
 # Regular Unittests
 #-------------------------------------------------------------------------------
 
 # This ensures that the code will run either standalone as a script, or that it
 # can be picked up by Twisted's `trial` test wrapper to run all the tests.
 if tcommon.pexpect is not None:
     if __name__ == '__main__':
         unittest.main(testLoader=IPDocTestLoader(dt_files,dt_modules))
     else:
         testSuite = lambda : makeTestSuite(__name__,dt_files,dt_modules)

IPython/kernel/tests/test_task.py

@@ -1,47 +1,47 b''
 # encoding: utf-8
 
 """This file contains unittests for the kernel.task.py module."""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import time
 
 from twisted.internet import defer
 from twisted.trial import unittest
 
 from IPython.kernel import task, controllerservice as cs, engineservice as es
 from IPython.kernel.multiengine import IMultiEngine
-from IPython.testutils.util import DeferredTestCase
+from IPython.testing.util import DeferredTestCase
 from IPython.kernel.tests.tasktest import ITaskControllerTestCase
 
 #-------------------------------------------------------------------------------
 # Tests
 #-------------------------------------------------------------------------------
 
 class BasicTaskControllerTestCase(DeferredTestCase, ITaskControllerTestCase):
     
     def setUp(self):
         self.controller  = cs.ControllerService()
         self.controller.startService()
         self.multiengine = IMultiEngine(self.controller)
         self.tc = task.ITaskController(self.controller)
         self.tc.failurePenalty = 0
         self.engines=[]
         
     def tearDown(self):
         self.controller.stopService()
         for e in self.engines:
             e.stopService()
 
 

IPython/kernel/tests/test_taskfc.py

@@ -1,86 +1,86 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import time
 
 from twisted.internet import defer, reactor
 
 from IPython.kernel.fcutil import Tub, UnauthenticatedTub
 
 from IPython.kernel import task as taskmodule
 from IPython.kernel import controllerservice as cs
 import IPython.kernel.multiengine as me
-from IPython.testutils.util import DeferredTestCase
+from IPython.testing.util import DeferredTestCase
 from IPython.kernel.multienginefc import IFCSynchronousMultiEngine
 from IPython.kernel.taskfc import IFCTaskController
 from IPython.kernel.util import printer
 from IPython.kernel.tests.tasktest import ITaskControllerTestCase
 from IPython.kernel.clientconnector import ClientConnector
 
 #-------------------------------------------------------------------------------
 # Tests
 #-------------------------------------------------------------------------------
 
 class TaskTest(DeferredTestCase, ITaskControllerTestCase):
 
     def setUp(self):
         
         self.engines = []
                 
         self.controller = cs.ControllerService()
         self.controller.startService()
         self.imultiengine = me.IMultiEngine(self.controller)
         self.itc = taskmodule.ITaskController(self.controller)
         self.itc.failurePenalty = 0
         
         self.mec_referenceable = IFCSynchronousMultiEngine(self.imultiengine)
         self.tc_referenceable = IFCTaskController(self.itc)
         
         self.controller_tub = Tub()
         self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
         self.controller_tub.setLocation('127.0.0.1:10105')
         
         mec_furl = self.controller_tub.registerReference(self.mec_referenceable)
         tc_furl = self.controller_tub.registerReference(self.tc_referenceable)
         self.controller_tub.startService()
         
         self.client_tub = ClientConnector()
         d = self.client_tub.get_multiengine_client(mec_furl)
         d.addCallback(self.handle_mec_client)
         d.addCallback(lambda _: self.client_tub.get_task_client(tc_furl))
         d.addCallback(self.handle_tc_client)
         return d
         
     def handle_mec_client(self, client):
         self.multiengine = client
     
     def handle_tc_client(self, client):
         self.tc = client
     
     def tearDown(self):
         dlist = []
         # Shut down the multiengine client
         d = self.client_tub.tub.stopService()
         dlist.append(d)
         # Shut down the engines
         for e in self.engines:
             e.stopService()
         # Shut down the controller
         d = self.controller_tub.stopService()
         d.addBoth(lambda _: self.controller.stopService())
         dlist.append(d)
         return defer.DeferredList(dlist)
 

IPython/testing/tcommon.py

@@ -1,36 +1,36 b''
 """Common utilities for testing IPython.
 
 This file is meant to be used as
 
-from IPython.testutils.tcommon import *
+from IPython.testing.tcommon import *
 
 by any test code.
 
 While a bit ugly, this helps us keep all testing facilities in one place, and
 start coding standalone test scripts easily, which can then be pasted into the
 larger test suites without any modifications required.
 """
 
 # Required modules and packages
 
 # Standard Python lib
 import cPickle as pickle
 import doctest
 import math
 import os
 import sys
 import unittest
 
 from pprint import pformat, pprint
 
 # From the IPython test lib
 import tutils
 from tutils import fullPath
 
 try:
     import pexpect
 except ImportError:
     pexpect = None
 else:
-    from IPython.testutils.ipdoctest import IPDocTestLoader,makeTestSuite
+    from IPython.testing.ipdoctest import IPDocTestLoader,makeTestSuite
     

IPython/testing/testTEMPLATE.py

@@ -1,66 +1,66 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """Simple template for unit tests.
 
 This file should be renamed to
 
 test_FEATURE.py
 
 so that it is recognized by the overall test driver (Twisted's 'trial'), which
 looks for all test_*.py files in the current directory to extract tests from
 them.
 """
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #       Copyright (C) 2005  Fernando Perez <[e-mail]>
 #                           Brian E Granger <[e-mail]>
 #                           Benjamin Ragan-Kelley <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
-from IPython.testutils import tcommon
-from IPython.testutils.tcommon import *
+from IPython.testing import tcommon
+from IPython.testing.tcommon import *
 
 #-------------------------------------------------------------------------------
 # Setup for inline and standalone doctests
 #-------------------------------------------------------------------------------
 
 
 # If you have standalone doctests in a separate file, set their names in the
 # dt_files variable (as a single string  or a list thereof).  The mkPath call
 # forms an absolute path based on the current file, it is not needed if you
 # provide the full pahts.
 dt_files = fullPath(__file__,[])
 
 
 # If you have any modules whose docstrings should be scanned for embedded tests
 # as examples accorging to standard doctest practice, set them here (as a
 # single string or a list thereof):
 dt_modules = []
 
 #-------------------------------------------------------------------------------
 # Regular Unittests
 #-------------------------------------------------------------------------------
 
 class FooTestCase(unittest.TestCase):
     def test_foo(self):
         pass
         
 #-------------------------------------------------------------------------------
 # Regular Unittests
 #-------------------------------------------------------------------------------
 
 # This ensures that the code will run either standalone as a script, or that it
 # can be picked up by Twisted's `trial` test wrapper to run all the tests.
 if tcommon.pexpect is not None:
     if __name__ == '__main__':
         unittest.main(testLoader=IPDocTestLoader(dt_files,dt_modules))
     else:
         testSuite = lambda : makeTestSuite(__name__,dt_files,dt_modules)

IPython/testing/tests/test_testutils.py

@@ -1,66 +1,66 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """Simple template for unit tests.
 
 This file should be renamed to
 
 test_FEATURE.py
 
 so that it is recognized by the overall test driver (Twisted's 'trial'), which
 looks for all test_*.py files in the current directory to extract tests from
 them.
 """
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #       Copyright (C) 2005  Fernando Perez <[e-mail]>
 #                           Brian E Granger <[e-mail]>
 #                           Benjamin Ragan-Kelley <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
-from IPython.testutils import tcommon
-from IPython.testutils.tcommon import *
+from IPython.testing import tcommon
+from IPython.testing.tcommon import *
 
 #-------------------------------------------------------------------------------
 # Setup for inline and standalone doctests
 #-------------------------------------------------------------------------------
 
 
 # If you have standalone doctests in a separate file, set their names in the
 # dt_files variable (as a single string  or a list thereof).  The mkPath call
 # forms an absolute path based on the current file, it is not needed if you
 # provide the full pahts.
 dt_files = fullPath(__file__,[])
 
 
 # If you have any modules whose docstrings should be scanned for embedded tests
 # as examples accorging to standard doctest practice, set them here (as a
 # single string or a list thereof):
-dt_modules = ['IPython.testutils.tutils']
+dt_modules = ['IPython.testing.tutils']
 
 #-------------------------------------------------------------------------------
 # Regular Unittests
 #-------------------------------------------------------------------------------
 
 ## class FooTestCase(unittest.TestCase):
 ##     def test_foo(self):
 ##         pass
         
 #-------------------------------------------------------------------------------
 # Regular Unittests
 #-------------------------------------------------------------------------------
 
 # This ensures that the code will run either standalone as a script, or that it
 # can be picked up by Twisted's `trial` test wrapper to run all the tests.
 if tcommon.pexpect is not None:
     if __name__ == '__main__':
         unittest.main(testLoader=IPDocTestLoader(dt_files,dt_modules))
     else:
         testSuite = lambda : makeTestSuite(__name__,dt_files,dt_modules)

IPython/testing/tstTEMPLATE_doctest.py

@@ -1,16 +1,16 b''
 """Run this file with
 
     irunner --python filename
 
 to generate valid doctest input.
 
 NOTE: make sure to ALWAYS have a blank line before comments, otherwise doctest
 gets confused."""
 
 #---------------------------------------------------------------------------
 
 # Setup - all imports are done in tcommon
 import tcommon; reload(tcommon)  # for interactive use
-from IPython.testutils.tcommon import *
+from IPython.testing.tcommon import *
 
 # Doctest code begins here

IPython/testing/tstTEMPLATE_doctest.txt

@@ -1,24 +1,24 b''
 Doctests for the ``XXX`` module
 =====================================
 
 The way doctest loads these, the entire document is applied as a single test
 rather than multiple individual ones, unfortunately.
 
 
 Auto-generated tests
 --------------------
 
 The tests below are generated from the companion file
 test_toeplitz_doctest.py, which is run via IPython's irunner script to create
 valid doctest input automatically.
 
 # Setup - all imports are done in tcommon
->>> from IPython.testutils.tcommon import *
+>>> from IPython.testing.tcommon import *
 
 # Rest of doctest goes here...
 
 
 Manually generated tests
 ------------------------
 
 These are one-off tests written by hand, copied from an interactive prompt.

IPython/tools/tests/test_tools_utils.py

@@ -1,36 +1,36 b''
 #!/usr/bin/env python
 """Testing script for the tools.utils module.
 """
 
 # Module imports
-from IPython.testutils import tcommon
-from IPython.testutils.tcommon import *
+from IPython.testing import tcommon
+from IPython.testing.tcommon import *
 
 # If you have standalone doctests in a separate file, set their names in the
 # dt_files variable (as a single string  or a list thereof).  The mkPath call
 # forms an absolute path based on the current file, it is not needed if you
 # provide the full pahts.
 dt_files = fullPath(__file__,['tst_tools_utils_doctest.txt',
                               'tst_tools_utils_doctest2.txt'])
 
 # If you have any modules whose docstrings should be scanned for embedded tests
 # as examples accorging to standard doctest practice, set them here (as a
 # single string or a list thereof):
 dt_modules = 'IPython.tools.utils'
 
 ##########################################################################
 ### Regular unittest test classes go here
 
 ## class utilsTestCase(unittest.TestCase):
 ##     def test_foo(self):
 ##         pass
         
 ##########################################################################
 ### Main
 # This ensures that the code will run either standalone as a script, or that it
 # can be picked up by Twisted's `trial` test wrapper to run all the tests.
 if tcommon.pexpect is not None:
     if __name__ == '__main__':
         unittest.main(testLoader=IPDocTestLoader(dt_files,dt_modules))
     else:
         testSuite = lambda : makeTestSuite(__name__,dt_files,dt_modules)

IPython/tools/tests/tst_tools_utils_doctest.py

@@ -1,12 +1,12 b''
 # Setup - all imports are done in tcommon
-from IPython.testutils import tcommon
-from IPython.testutils.tcommon import *
+from IPython.testing import tcommon
+from IPython.testing.tcommon import *
 
 # Doctest code begins here
 from IPython.tools import utils
 
 for i in range(10):
     print i,
     print i+1
 
 print 'simple loop is over'

IPython/tools/tests/tst_tools_utils_doctest.txt

@@ -1,42 +1,42 b''
 
 =========================
  Auto-generated doctests
 =========================
 
 This file was auto-generated by IPython in its entirety.  If you need finer
 control over the contents, simply make a manual template.  See the
 mkdoctests.py script for details.
 
 
 ----------------------------------------------------------------------------
 
 Begin included file tst_tools_utils_doctest.py::
 
     # Setup - all imports are done in tcommon
-    >>> from IPython.testutils import tcommon
-    >>> from IPython.testutils.tcommon import *
+    >>> from IPython.testing import tcommon
+    >>> from IPython.testing.tcommon import *
     
     # Doctest code begins here
     >>> from IPython.tools import utils
     
     >>> for i in range(10):
     ...     print i,
     ...     print i+1
     ... 
     0 1
     1 2
     2 3
     3 4
     4 5
     5 6
     6 7
     7 8
     8 9
     9 10
     >>> print 'simple loop is over'
     simple loop is over
     
 End included file tst_tools_utils_doctest.py
 
 ----------------------------------------------------------------------------
 

IPython/tools/tests/tst_tools_utils_doctest2.py

@@ -1,13 +1,13 b''
 # Setup - all imports are done in tcommon
-from IPython.testutils import tcommon
-from IPython.testutils.tcommon import *
+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')
 
 utils.marquee('Another test',30,'.')
 

IPython/tools/tests/tst_tools_utils_doctest2.txt

@@ -1,42 +1,42 b''
 =========================================
  Doctests for the ``tools.utils`` module
 =========================================
 
 The way doctest loads these, the entire document is applied as a single test
 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.testutils import tcommon
-    >>> from IPython.testutils.tcommon import *
+    >>> 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.

setup.py

@@ -1,186 +1,162 b''
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """Setup script for IPython.
 
 Under Posix environments it works like a typical setup.py script. 
 Under Windows, the command sdist is not supported, since IPython 
 requires utilities which are not available under Windows."""
 
-#*****************************************************************************
-#       Copyright (C) 2001-2005 Fernando Perez <[e-mail]>
+#-------------------------------------------------------------------------------
+#  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#*****************************************************************************
+#-------------------------------------------------------------------------------
+
+#-------------------------------------------------------------------------------
+# Imports
+#-------------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 import sys
 
 from glob import glob
 
 # BEFORE importing distutils, remove MANIFEST. distutils doesn't properly
 # update it when the contents of directories change.
 if os.path.exists('MANIFEST'): os.remove('MANIFEST')
 
 from distutils.core import setup
-from setupext import install_data_ext
 
 # Local imports
 from IPython.genutils import target_update
 
-# A few handy globals
+from setupbase import (
+    setup_args, 
+    find_packages, 
+    find_package_data, 
+    find_scripts,
+    find_data_files,
+    check_for_dependencies
+)
+
 isfile = os.path.isfile
-pjoin = os.path.join
-
-##############################################################################
-# Utility functions
-def oscmd(s):
-    print ">", s
-    os.system(s)
-
-# A little utility we'll need below, since glob() does NOT allow you to do
-# exclusion on multiple endings!
-def file_doesnt_endwith(test,endings):
-    """Return true if test is a file and its name does NOT end with any
-    of the strings listed in endings."""
-    if not isfile(test):
-        return False
-    for e in endings:
-        if test.endswith(e):
-            return False
-    return True
-
-###############################################################################
-# Main code begins
+
+#-------------------------------------------------------------------------------
+# Handle OS specific things
+#-------------------------------------------------------------------------------
 
 if os.name == 'posix':
     os_name = 'posix'
 elif os.name in ['nt','dos']:
     os_name = 'windows'
 else:
     print 'Unsupported operating system:',os.name
     sys.exit(1)
 
 # Under Windows, 'sdist' has not been supported.  Now that the docs build with
 # Sphinx it might work, but let's not turn it on until someone confirms that it
 # actually works.
 if os_name == 'windows' and 'sdist' in sys.argv:
     print 'The sdist command is not available under Windows.  Exiting.'
     sys.exit(1)
 
+#-------------------------------------------------------------------------------
+# Things related to the IPython documentation
+#-------------------------------------------------------------------------------
+
 # update the manuals when building a source dist
 if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):
     import textwrap
 
     # List of things to be updated. Each entry is a triplet of args for
     # target_update()
     to_update = [ # The do_sphinx scripts builds html and pdf, so just one
                   # target is enough to cover all manual generation
                  ('doc/manual/ipython.pdf',
                   ['IPython/Release.py','doc/source/ipython.rst'],
                   "cd doc && python do_sphinx.py" ),
 
                   # FIXME - Disabled for now: we need to redo an automatic way
                   # of generating the magic info inside the rst.                
                   #('doc/magic.tex',
                   #['IPython/Magic.py'],
                   #"cd doc && ./update_magic.sh" ),
                  
                  ('doc/ipython.1.gz',
                   ['doc/ipython.1'],
                   "cd doc && gzip -9c ipython.1 > ipython.1.gz"),
 
                  ('doc/pycolor.1.gz',
                   ['doc/pycolor.1'],
                   "cd doc && gzip -9c pycolor.1 > pycolor.1.gz"),
                  ]
 
     [ target_update(*t) for t in to_update ]
 
-# Release.py contains version, authors, license, url, keywords, etc.
-execfile(pjoin('IPython','Release.py'))
-
-# I can't find how to make distutils create a nested dir. structure, so
-# in the meantime do it manually. Butt ugly.
-# Note that http://www.redbrick.dcu.ie/~noel/distutils.html, ex. 2/3, contain
-# information on how to do this more cleanly once python 2.4 can be assumed.
-# Thanks to Noel for the tip.
-docdirbase  = 'share/doc/ipython'
-manpagebase = 'share/man/man1'
-
-# We only need to exclude from this things NOT already excluded in the
-# MANIFEST.in file.
-exclude     = ('.sh','.1.gz')
-docfiles    = filter(lambda f:file_doesnt_endwith(f,exclude),glob('doc/*'))
-examfiles   = filter(isfile, glob('doc/examples/*.py'))
-manfiles    = filter(isfile, glob('doc/manual/*'))
-manstatic   = filter(isfile, glob('doc/manual/_static/*'))
-manpages    = filter(isfile, glob('doc/*.1.gz'))
+#---------------------------------------------------------------------------
+# Find all the packages, package data, scripts and data_files
+#---------------------------------------------------------------------------
 
-cfgfiles    = filter(isfile, glob('IPython/UserConfig/*'))
-scriptfiles = filter(isfile, ['scripts/ipython','scripts/pycolor',
-                              'scripts/irunner'])
-
-igridhelpfiles = filter(isfile, glob('IPython/Extensions/igrid_help.*'))
-
-# Script to be run by the windows binary installer after the default setup
-# routine, to add shortcuts and similar windows-only things.  Windows
-# post-install scripts MUST reside in the scripts/ dir, otherwise distutils
-# doesn't find them.
-if 'bdist_wininst' in sys.argv:
-    if len(sys.argv) > 2 and ('sdist' in sys.argv or 'bdist_rpm' in sys.argv):
-        print >> sys.stderr,"ERROR: bdist_wininst must be run alone. Exiting."
-        sys.exit(1)
-    scriptfiles.append('scripts/ipython_win_post_install.py')
-
-datafiles = [('data', docdirbase, docfiles),
-             ('data', pjoin(docdirbase, 'examples'),examfiles),
-             ('data', pjoin(docdirbase, 'manual'),manfiles),
-             ('data', pjoin(docdirbase, 'manual/_static'),manstatic),
-             ('data', manpagebase, manpages),
-             ('data',pjoin(docdirbase, 'extensions'),igridhelpfiles),
-             ]
+packages = find_packages()
+package_data = find_package_data()
+scripts = find_scripts()
+data_files = find_data_files()
+
+#---------------------------------------------------------------------------
+# Handle dependencies and setuptools specific things
+#---------------------------------------------------------------------------
+
+# This dict is used for passing extra arguments that are setuptools 
+# specific to setup
+setuptools_extra_args = {}
 
 if 'setuptools' in sys.modules:
-    # setuptools config for egg building
-    egg_extra_kwds = {
-        'entry_points': {
+    setuptools_extra_args['zip_safe'] = False
+    setuptools_extra_args['entry_points'] = {
             'console_scripts': [
             'ipython = IPython.ipapi:launch_new_instance',
-            'pycolor = IPython.PyColorize:main'
-            ]}
+            'pycolor = IPython.PyColorize:main',
+            'ipcontroller = IPython.kernel.scripts.ipcontroller:main',
+            'ipengine = IPython.kernel.scripts.ipengine:main',
+            'ipcluster = IPython.kernel.scripts.ipcluster:main'
+        ]
         }
-    scriptfiles = []
+    setup_args["extras_require"] = dict(
+        kernel = [
+            "zope.interface>=3.4.1",
+            "Twisted>=8.0.1",
+            "foolscap>=0.2.6"        
+        ],
+        doc=['Sphinx>=0.3','pygments'],
+        test='nose>=0.10.1',
+        security=["pyOpenSSL>=0.6"]
+    )
+    # Allow setuptools to handle the scripts
+    scripts = []
     # eggs will lack docs, examples
-    datafiles = []
+    data_files = []
 else:
-    # Normal, non-setuptools install
-    egg_extra_kwds = {}
     # package_data of setuptools was introduced to distutils in 2.4
+    cfgfiles = filter(isfile, glob('IPython/UserConfig/*'))
     if sys.version_info < (2,4):
-        datafiles.append(('lib', 'IPython/UserConfig', cfgfiles))
-    
-# Call the setup() routine which does most of the work
-setup(name             = name,
-      version          = version,
-      description      = description,
-      long_description = long_description,
-      author           = authors['Fernando'][0],
-      author_email     = authors['Fernando'][1],
-      url              = url,
-      download_url     = download_url,
-      license          = license,
-      platforms        = platforms,
-      keywords         = keywords,
-      packages         = ['IPython', 'IPython.Extensions', 'IPython.external',
-                          'IPython.gui', 'IPython.gui.wx',
-                          'IPython.UserConfig'],
-      scripts          = scriptfiles,
-      package_data     = {'IPython.UserConfig' : ['*'] },
-      
-      cmdclass         = {'install_data': install_data_ext},
-      data_files       = datafiles,
-      # extra params needed for eggs
-      **egg_extra_kwds                        
-      )
+        data_files.append(('lib', 'IPython/UserConfig', cfgfiles))
+    # If we are running without setuptools, call this function which will
+    # check for dependencies an inform the user what is needed.  This is
+    # just to make life easy for users.
+    check_for_dependencies()
+
+
+#---------------------------------------------------------------------------
+# Do the actual setup now
+#---------------------------------------------------------------------------
+
+setup_args['packages'] = packages
+setup_args['package_data'] = package_data
+setup_args['scripts'] = scripts
+setup_args['data_files'] = data_files
+setup_args.update(setuptools_extra_args)
+
+if __name__ == '__main__':
+    setup(**setup_args)