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

@@ -20,4 +20,5 b' __docformat__ = "restructuredtext en"'
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
  No newline at end of file
+#-------------------------------------------------------------------------------
+    
  No newline at end of file

IPython/kernel/tests/test_controllerservice.py

@@ -23,18 +23,21 b' __docformat__ = "restructuredtext en"'
 # 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

@@ -15,75 +15,78 b' __docformat__ = "restructuredtext en"'
 # 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

@@ -23,42 +23,44 b' __docformat__ = "restructuredtext en"'
 # 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

@@ -15,38 +15,40 b' __docformat__ = "restructuredtext en"'
 # 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

@@ -14,55 +14,57 b' __docformat__ = "restructuredtext en"'
 # 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

@@ -15,85 +15,88 b' __docformat__ = "restructuredtext en"'
 # 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

@@ -16,191 +16,194 b' __docformat__ = "restructuredtext en"'
 # 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

IPython/kernel/tests/test_task.py

@@ -15,33 +15,36 b' __docformat__ = "restructuredtext en"'
 # 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

@@ -14,73 +14,77 b' __docformat__ = "restructuredtext en"'
 # 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

@@ -8,6 +8,11 b' graft setupext'
 
 graft IPython/UserConfig
 
+graft IPython/kernel
+graft IPython/config
+graft IPython/testing
+graft IPython/tools
+
 graft doc
 exclude doc/\#*
 exclude doc/*.1

setup.py

@@ -72,12 +72,7 b" if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):"
 
     # 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',
@@ -93,6 +88,18 b" if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):"
                   "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 ]
 
 #---------------------------------------------------------------------------
@@ -152,9 +159,6 b' else:'
 # Do the actual setup now
 #---------------------------------------------------------------------------
 
-print packages
-
-
 setup_args['packages'] = packages
 setup_args['package_data'] = package_data
 setup_args['scripts'] = scripts

setupegg.py

@@ -11,7 +11,7 b" sys.path.insert(0,'%s/usr/local/lib/python%s/site-packages' %"
 
 # now, import setuptools and call the actual setup
 import setuptools
-print sys.argv
+# print sys.argv
 #sys.argv=['','bdist_egg']
 execfile('setup.py')