Finished initial reworking and updating of setup.py and friends, including the MANIFEST.in. Everything seems

to work fine. 

I have also gone through the tests in various subpackages (like kernel) and have protected imports of 
twisted, zope.interface and foolscap with a try/except clause.  Now the tests are simply not run
if these deps are missing.  All tests now pass no matter what.

IPython/kernel/__init__.py

@@ -1,23 +1,24 b''
 # encoding: utf-8
 """The IPython1 kernel.
 
 The IPython kernel actually refers to three things:
 
  * The IPython Engine
  * The IPython Controller
  * Clients to the IPython Controller
 
 The kernel module implements the engine, controller and client and all the 
 network protocols needed for the various entities to talk to each other.
 
 An end user should probably begin by looking at the `client.py` module
 if they need blocking clients or in `asyncclient.py` if they want asynchronous,
 deferred/Twisted using clients.
 """
 __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.
-#-------------------------------------------------------------------------------
  No newline at end of file
+#-------------------------------------------------------------------------------
+    
  No newline at end of file

IPython/kernel/tests/test_controllerservice.py

@@ -1,40 +1,43 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.testing.util import DeferredTestCase
-
-class BasicControllerServiceTest(DeferredTestCase,
-    IControllerCoreTestCase):
+try:
+    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.testing.util import DeferredTestCase
+except ImportError:
+    pass
+else:
+    class BasicControllerServiceTest(DeferredTestCase,
+        IControllerCoreTestCase):
     
-    def setUp(self):
-        self.controller  = ControllerService()
-        self.controller.startService()
+        def setUp(self):
+            self.controller  = ControllerService()
+            self.controller.startService()
     
-    def tearDown(self):
-        self.controller.stopService()
+        def tearDown(self):
+            self.controller.stopService()

IPython/kernel/tests/test_enginefc.py

@@ -1,89 +1,92 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
 #-------------------------------------------------------------------------------
 
+try:
+    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
 
-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
 
-import zope.interface as zi
-
-from IPython.kernel.fcutil import Tub, UnauthenticatedTub
-from IPython.kernel import engineservice as es
-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.fcutil import Tub, UnauthenticatedTub
+    from IPython.kernel import engineservice as es
+    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
-                   ):
+    from IPython.kernel.tests.engineservicetest import \
+        IEngineCoreTestCase, \
+        IEngineSerializedTestCase, \
+        IEngineQueuedTestCase
+except ImportError:
+    print "we got an error!!!"
+    pass
+else:
+    class EngineFCTest(DeferredTestCase, 
+                       IEngineCoreTestCase, 
+                       IEngineSerializedTestCase,
+                       IEngineQueuedTestCase
+                       ):
         
-    zi.implements(IControllerBase)
+        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')
+        def setUp(self):
         
-        furl = self.controller_tub.registerReference(self.controller_reference)
-        self.controller_tub.startService()
+            # 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
         
-        # 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
+        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,66 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.testing.util import DeferredTestCase
-from IPython.kernel.tests.engineservicetest import \
-    IEngineCoreTestCase, \
-    IEngineSerializedTestCase, \
-    IEngineQueuedTestCase, \
-    IEnginePropertiesTestCase
+try:
+    from twisted.internet import defer
+    from twisted.application.service import IService
     
-
-class BasicEngineServiceTest(DeferredTestCase,
-                             IEngineCoreTestCase, 
-                             IEngineSerializedTestCase,
-                             IEnginePropertiesTestCase):
+    from IPython.kernel import engineservice as es
+    from IPython.testing.util import DeferredTestCase
+    from IPython.kernel.tests.engineservicetest import \
+        IEngineCoreTestCase, \
+        IEngineSerializedTestCase, \
+        IEngineQueuedTestCase, \
+        IEnginePropertiesTestCase
+except ImportError:
+    pass
+else:
+    class BasicEngineServiceTest(DeferredTestCase,
+                                 IEngineCoreTestCase, 
+                                 IEngineSerializedTestCase,
+                                 IEnginePropertiesTestCase):
     
-    def setUp(self):
-        self.engine = es.EngineService()
-        self.engine.startService()
+        def setUp(self):
+            self.engine = es.EngineService()
+            self.engine.startService()
     
-    def tearDown(self):
-        return self.engine.stopService()
+        def tearDown(self):
+            return self.engine.stopService()
 
-class QueuedEngineServiceTest(DeferredTestCase,
-                              IEngineCoreTestCase, 
-                              IEngineSerializedTestCase,
-                              IEnginePropertiesTestCase,
-                              IEngineQueuedTestCase):
+    class QueuedEngineServiceTest(DeferredTestCase,
+                                  IEngineCoreTestCase, 
+                                  IEngineSerializedTestCase,
+                                  IEnginePropertiesTestCase,
+                                  IEngineQueuedTestCase):
                               
-    def setUp(self):
-        self.rawEngine = es.EngineService()
-        self.rawEngine.startService()
-        self.engine = es.IEngineQueued(self.rawEngine)
+        def setUp(self):
+            self.rawEngine = es.EngineService()
+            self.rawEngine.startService()
+            self.engine = es.IEngineQueued(self.rawEngine)
         
-    def tearDown(self):
-        return self.rawEngine.stopService()
+        def tearDown(self):
+            return self.rawEngine.stopService()
 
  

IPython/kernel/tests/test_multiengine.py

@@ -1,52 +1,54 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.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)
+try:
+    from twisted.internet import defer
+    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)
+except ImportError:
+    pass
+else:    
+    class BasicMultiEngineTestCase(DeferredTestCase, IMultiEngineTestCase):
     
-    
-class BasicMultiEngineTestCase(DeferredTestCase, IMultiEngineTestCase):
-    
-    def setUp(self):
-        self.controller = ControllerService()
-        self.controller.startService()
-        self.multiengine = me.IMultiEngine(self.controller)
-        self.engines = []
+        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()
+        def tearDown(self):
+            self.controller.stopService()
+            for e in self.engines:
+                e.stopService()
 
 
-class SynchronousMultiEngineTestCase(DeferredTestCase, ISynchronousMultiEngineTestCase):
+    class SynchronousMultiEngineTestCase(DeferredTestCase, ISynchronousMultiEngineTestCase):
     
-    def setUp(self):
-        self.controller = ControllerService()
-        self.controller.startService()
-        self.multiengine = me.ISynchronousMultiEngine(me.IMultiEngine(self.controller))
-        self.engines = []
+        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()
+        def tearDown(self):
+            self.controller.stopService()
+            for e in self.engines:
+                e.stopService()
 

IPython/kernel/tests/test_multienginefc.py

@@ -1,68 +1,70 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
+try:
+    from twisted.internet import defer, reactor
 
-from IPython.kernel.fcutil import Tub, UnauthenticatedTub
+    from IPython.kernel.fcutil import Tub, UnauthenticatedTub
 
-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):
+    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
+except ImportError:
+    pass
+else:
+    class FullSynchronousMultiEngineTestCase(DeferredTestCase, IFullSynchronousMultiEngineTestCase):
     
-    def setUp(self):
+        def setUp(self):
         
-        self.engines = []
+            self.engines = []
                 
-        self.controller = ControllerService()
-        self.controller.startService()
-        self.imultiengine = IMultiEngine(self.controller)
-        self.mec_referenceable = IFCSynchronousMultiEngine(self.imultiengine)
+            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')
+            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()
+            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
+            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 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)
+        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,102 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.testing.util import DeferredTestCase
+try:
+    import zope.interface as zi
+    from twisted.trial import unittest
+    from IPython.testing.util import DeferredTestCase
 
-from IPython.kernel.newserialized import \
-    ISerialized, \
-    IUnSerialized, \
-    Serialized, \
-    UnSerialized, \
-    SerializeIt, \
-    UnSerializeIt
+    from IPython.kernel.newserialized import \
+        ISerialized, \
+        IUnSerialized, \
+        Serialized, \
+        UnSerialized, \
+        SerializeIt, \
+        UnSerializeIt
+except ImportError:
+    pass
+else:
+    #-------------------------------------------------------------------------------
+    # Tests
+    #-------------------------------------------------------------------------------
     
-#-------------------------------------------------------------------------------
-# Tests
-#-------------------------------------------------------------------------------
-    
-class SerializedTestCase(unittest.TestCase):
+    class SerializedTestCase(unittest.TestCase):
     
-    def setUp(self):
-        pass
+        def setUp(self):
+            pass
         
-    def tearDown(self):
-        pass
+        def tearDown(self):
+            pass
         
-    def testSerializedInterfaces(self):
+        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))
+            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 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)
+        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,218 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
+try:
+    from twisted.internet import defer
+    from twisted.python import failure
 
-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
+    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
+except ImportError:
+    pass
+else:
 
-
-#-------------------------------------------------------------------------------
-# Setup for inline and standalone doctests
-#-------------------------------------------------------------------------------
+    #-------------------------------------------------------------------------------
+    # 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 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 = []
+    # 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
-#-------------------------------------------------------------------------------
+    #-------------------------------------------------------------------------------
+    # Regular Unittests
+    #-------------------------------------------------------------------------------
 
 
-class Foo(object):
+    class Foo(object):
     
-    def bar(self, bahz):
-        return defer.succeed('blahblah: %s' % bahz)
+        def bar(self, bahz):
+            return defer.succeed('blahblah: %s' % bahz)
 
-class TwoPhaseFoo(pd.PendingDeferredManager):
+    class TwoPhaseFoo(pd.PendingDeferredManager):
     
-    def __init__(self, foo):
-        self.foo = foo
-        pd.PendingDeferredManager.__init__(self)
+        def __init__(self, foo):
+            self.foo = foo
+            pd.PendingDeferredManager.__init__(self)
 
-    @pd.two_phase
-    def bar(self, bahz):
-        return self.foo.bar(bahz)
+        @pd.two_phase
+        def bar(self, bahz):
+            return self.foo.bar(bahz)
 
-class PendingDeferredManagerTest(DeferredTestCase):
+    class PendingDeferredManagerTest(DeferredTestCase):
     
-    def setUp(self):
-        self.pdm = pd.PendingDeferredManager()
+        def setUp(self):
+            self.pdm = pd.PendingDeferredManager()
         
-    def tearDown(self):
-        pass
+        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 testBasic(self):
-        dDict = {}
-        # Create 10 deferreds and save them
-        for i in range(10):
+        def test_save_then_delete(self):
             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'))
+            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_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_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_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_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_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_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_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'))
+        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,50 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.testing.util import DeferredTestCase
-from IPython.kernel.tests.tasktest import ITaskControllerTestCase
-
-#-------------------------------------------------------------------------------
-# Tests
-#-------------------------------------------------------------------------------
-
-class BasicTaskControllerTestCase(DeferredTestCase, ITaskControllerTestCase):
+try:
+    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.testing.util import DeferredTestCase
+    from IPython.kernel.tests.tasktest import ITaskControllerTestCase
+except ImportError:
+    pass
+else:
+    #-------------------------------------------------------------------------------
+    # 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 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()
+        def tearDown(self):
+            self.controller.stopService()
+            for e in self.engines:
+                e.stopService()
 
 

IPython/kernel/tests/test_taskfc.py

@@ -1,86 +1,90 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
+try:
+    import time
 
-from twisted.internet import defer, reactor
+    from twisted.internet import defer, reactor
 
-from IPython.kernel.fcutil import Tub, UnauthenticatedTub
+    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.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
+    from IPython.kernel import task as taskmodule
+    from IPython.kernel import controllerservice as cs
+    import IPython.kernel.multiengine as me
+    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
+except ImportError:
+    pass
+else:
 
-#-------------------------------------------------------------------------------
-# Tests
-#-------------------------------------------------------------------------------
+    #-------------------------------------------------------------------------------
+    # Tests
+    #-------------------------------------------------------------------------------
 
-class TaskTest(DeferredTestCase, ITaskControllerTestCase):
+    class TaskTest(DeferredTestCase, ITaskControllerTestCase):
 
-    def setUp(self):
+        def setUp(self):
         
-        self.engines = []
+            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.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.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')
+            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()
+            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
+            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_mec_client(self, client):
+            self.multiengine = client
     
-    def handle_tc_client(self, client):
-        self.tc = 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)
+        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)
 

MANIFEST.in

@@ -1,31 +1,36 b''
 include README_Windows.txt
 include win32_manual_post_install.py
 include ipython.py
 
 graft scripts
 
 graft setupext
 
 graft IPython/UserConfig
 
+graft IPython/kernel
+graft IPython/config
+graft IPython/testing
+graft IPython/tools
+
 graft doc
 exclude doc/\#*
 exclude doc/*.1
 exclude doc/ChangeLog.*
 exclude doc/update_version.sh
 
 # There seems to be no way of excluding whole subdirectories, other than
 # manually excluding all their subdirs.  distutils really is horrible...
 exclude doc/attic/*
 exclude doc/build/doctrees/*
 exclude doc/build/html/_sources/*
 exclude doc/build/html/_static/*
 exclude doc/build/html/*
 exclude doc/build/latex/*
 
 global-exclude *~
 global-exclude *.flc
 global-exclude *.pyc
 global-exclude .dircopy.log
 global-exclude .svn
 global-exclude .bzr

setup.py

@@ -1,165 +1,169 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) 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
 
 # Local imports
 from IPython.genutils import target_update
 
 from setupbase import (
     setup_args, 
     find_packages, 
     find_package_data, 
     find_scripts,
     find_data_files,
     check_for_dependencies
 )
 
 isfile = os.path.isfile
 
 #-------------------------------------------------------------------------------
 # 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" ),
-
+    to_update = [
                   # 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"),
                  ]
 
+    try:
+        import sphinx
+    except ImportError:
+        pass
+    else:
+        # The do_sphinx scripts builds html and pdf, so just one
+        # target is enough to cover all manual generation
+        to_update.append(
+            ('doc/manual/ipython.pdf',
+            ['IPython/Release.py','doc/source/ipython.rst'],
+            "cd doc && python do_sphinx.py")
+        )
     [ target_update(*t) for t in to_update ]
 
 #---------------------------------------------------------------------------
 # Find all the packages, package data, scripts and data_files
 #---------------------------------------------------------------------------
 
 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_extra_args['zip_safe'] = False
     setuptools_extra_args['entry_points'] = {
         'console_scripts': [
             'ipython = IPython.ipapi:launch_new_instance',
             'pycolor = IPython.PyColorize:main',
             'ipcontroller = IPython.kernel.scripts.ipcontroller:main',
             'ipengine = IPython.kernel.scripts.ipengine:main',
             'ipcluster = IPython.kernel.scripts.ipcluster:main'
         ]
     }
     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
     data_files = []
 else:
     # package_data of setuptools was introduced to distutils in 2.4
     cfgfiles = filter(isfile, glob('IPython/UserConfig/*'))
     if sys.version_info < (2,4):
         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
 #---------------------------------------------------------------------------
 
-print packages
-
-
 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)

setupegg.py

@@ -1,20 +1,20 b''
 #!/usr/bin/env python
 """Wrapper to run setup.py using setuptools."""
 
 import os
 import sys
 
 # Add my local path to sys.path
 home = os.environ['HOME']
 sys.path.insert(0,'%s/usr/local/lib/python%s/site-packages' %
                 (home,sys.version[:3]))
 
 # now, import setuptools and call the actual setup
 import setuptools
-print sys.argv
+# print sys.argv
 #sys.argv=['','bdist_egg']
 execfile('setup.py')
 
 # clean up the junk left around by setuptools
 if "develop" not in sys.argv:
     os.system('rm -rf ipython.egg-info build')