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
 # 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

IPython/kernel/tests/test_controllerservice.py

@@ -1,40 +1,43
 # 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
 #-------------------------------------------------------------------------------
 
+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 tearDown(self):
         self.controller.stopService()

IPython/kernel/tests/test_enginefc.py

@@ -1,89 +1,92
 # 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
 
 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.tests.engineservicetest import \
     IEngineCoreTestCase, \
     IEngineSerializedTestCase, \
     IEngineQueuedTestCase
-
+except ImportError:
+    print "we got an error!!!"
+    pass
+else:
 class EngineFCTest(DeferredTestCase, 
                    IEngineCoreTestCase, 
                    IEngineSerializedTestCase,
                    IEngineQueuedTestCase
                    ):
         
     zi.implements(IControllerBase)
         
     def setUp(self):
 
         # Start a server and append to self.servers
         self.controller_reference = FCRemoteEngineRefFromService(self)
         self.controller_tub = Tub()
         self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
         self.controller_tub.setLocation('127.0.0.1:10105')
         
         furl = self.controller_tub.registerReference(self.controller_reference)
         self.controller_tub.startService()
         
         # Start an EngineService and append to services/client
         self.engine_service = es.EngineService()
         self.engine_service.startService()
         self.engine_tub = Tub()
         self.engine_tub.startService()
         engine_connector = EngineConnector(self.engine_tub)
         d = engine_connector.connect_to_controller(self.engine_service, furl)
         # This deferred doesn't fire until after register_engine has returned and
         # thus, self.engine has been defined and the tets can proceed.
         return d
     
     def tearDown(self):
         dlist = []
         # Shut down the engine
         d = self.engine_tub.stopService()
         dlist.append(d)
         # Shut down the controller
         d = self.controller_tub.stopService()
         dlist.append(d)
         return defer.DeferredList(dlist)
     
     #---------------------------------------------------------------------------
     # Make me look like a basic controller
     #---------------------------------------------------------------------------
     
     def register_engine(self, engine_ref, id=None, ip=None, port=None, pid=None):
         self.engine = IEngineQueued(IEngineBase(engine_ref))
         return {'id':id}
     
     def unregister_engine(self, id):
         pass
  No newline at end of file

IPython/kernel/tests/test_engineservice.py

@@ -1,64 +1,66
 # 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
 #-------------------------------------------------------------------------------
 
+try:
 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
-    
-
+except ImportError:
+    pass
+else:
 class BasicEngineServiceTest(DeferredTestCase,
                              IEngineCoreTestCase, 
                              IEngineSerializedTestCase,
                              IEnginePropertiesTestCase):
     
     def setUp(self):
         self.engine = es.EngineService()
         self.engine.startService()
     
     def tearDown(self):
         return self.engine.stopService()
 
 class QueuedEngineServiceTest(DeferredTestCase,
                               IEngineCoreTestCase, 
                               IEngineSerializedTestCase,
                               IEnginePropertiesTestCase,
                               IEngineQueuedTestCase):
                               
     def setUp(self):
         self.rawEngine = es.EngineService()
         self.rawEngine.startService()
         self.engine = es.IEngineQueued(self.rawEngine)
         
     def tearDown(self):
         return self.rawEngine.stopService()
 
  

IPython/kernel/tests/test_multiengine.py

@@ -1,52 +1,54
 # 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
 #-------------------------------------------------------------------------------
 
+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):
     
     def setUp(self):
         self.controller = ControllerService()
         self.controller.startService()
         self.multiengine = me.IMultiEngine(self.controller)
         self.engines = []
         
     def tearDown(self):
         self.controller.stopService()
         for e in self.engines:
             e.stopService()
 
 
 class SynchronousMultiEngineTestCase(DeferredTestCase, ISynchronousMultiEngineTestCase):
     
     def setUp(self):
         self.controller = ControllerService()
         self.controller.startService()
         self.multiengine = me.ISynchronousMultiEngine(me.IMultiEngine(self.controller))
         self.engines = []
         
     def tearDown(self):
         self.controller.stopService()
         for e in self.engines:
             e.stopService()
 

IPython/kernel/tests/test_multienginefc.py

@@ -1,68 +1,70
 #!/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
 #-------------------------------------------------------------------------------
 
+try:
 from twisted.internet import defer, reactor
 
 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
-
-
+except ImportError:
+    pass
+else:
 class FullSynchronousMultiEngineTestCase(DeferredTestCase, IFullSynchronousMultiEngineTestCase):
     
     def setUp(self):
         
         self.engines = []
                 
         self.controller = ControllerService()
         self.controller.startService()
         self.imultiengine = IMultiEngine(self.controller)
         self.mec_referenceable = IFCSynchronousMultiEngine(self.imultiengine)
 
         self.controller_tub = Tub()
         self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
         self.controller_tub.setLocation('127.0.0.1:10105')
         
         furl = self.controller_tub.registerReference(self.mec_referenceable)
         self.controller_tub.startService()
         
         self.client_tub = ClientConnector()
         d = self.client_tub.get_multiengine_client(furl)
         d.addCallback(self.handle_got_client)
         return d
         
     def handle_got_client(self, client):
         self.multiengine = client
     
     def tearDown(self):
         dlist = []
         # Shut down the multiengine client
         d = self.client_tub.tub.stopService()
         dlist.append(d)
         # Shut down the engines
         for e in self.engines:
             e.stopService()
         # Shut down the controller
         d = self.controller_tub.stopService()
         d.addBoth(lambda _: self.controller.stopService())
         dlist.append(d)
         return defer.DeferredList(dlist)

IPython/kernel/tests/test_newserialized.py

@@ -1,99 +1,102
 # 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
 #-------------------------------------------------------------------------------
 
+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
-    
+except ImportError:
+    pass
+else:
 #-------------------------------------------------------------------------------
 # Tests
 #-------------------------------------------------------------------------------
     
 class SerializedTestCase(unittest.TestCase):
     
     def setUp(self):
         pass
         
     def tearDown(self):
         pass
         
     def testSerializedInterfaces(self):
 
         us = UnSerialized({'a':10, 'b':range(10)})
         s = ISerialized(us)
         uss = IUnSerialized(s)
         self.assert_(ISerialized.providedBy(s))
         self.assert_(IUnSerialized.providedBy(us))
         self.assert_(IUnSerialized.providedBy(uss))
         for m in list(ISerialized):
             self.assert_(hasattr(s, m))
         for m in list(IUnSerialized):
             self.assert_(hasattr(us, m))
         for m in list(IUnSerialized):
             self.assert_(hasattr(uss, m))
 
     def testPickleSerialized(self):
         obj = {'a':1.45345, 'b':'asdfsdf', 'c':10000L}
         original = UnSerialized(obj)
         originalSer = ISerialized(original)
         firstData = originalSer.getData()
         firstTD = originalSer.getTypeDescriptor()
         firstMD = originalSer.getMetadata()
         self.assert_(firstTD == 'pickle')
         self.assert_(firstMD == {})
         unSerialized = IUnSerialized(originalSer)
         secondObj = unSerialized.getObject()
         for k, v in secondObj.iteritems():
             self.assert_(obj[k] == v)
         secondSer = ISerialized(UnSerialized(secondObj))
         self.assert_(firstData == secondSer.getData())
         self.assert_(firstTD == secondSer.getTypeDescriptor() )
         self.assert_(firstMD == secondSer.getMetadata())
         
     def testNDArraySerialized(self):
         try:
             import numpy
         except ImportError:
             pass
         else:
             a = numpy.linspace(0.0, 1.0, 1000)
             unSer1 = UnSerialized(a)
             ser1 = ISerialized(unSer1)
             td = ser1.getTypeDescriptor()
             self.assert_(td == 'ndarray')
             md = ser1.getMetadata()
             self.assert_(md['shape'] == a.shape)
             self.assert_(md['dtype'] == a.dtype.str)
             buff = ser1.getData()
             self.assert_(buff == numpy.getbuffer(a))
             s = Serialized(buff, td, md)
             us = IUnSerialized(s)
             final = us.getObject()
             self.assert_(numpy.getbuffer(a) == numpy.getbuffer(final))
             self.assert_(a.dtype.str == final.dtype.str)
             self.assert_(a.shape == final.shape)
             
             
     
  No newline at end of file

IPython/kernel/tests/test_pendingdeferred.py

@@ -1,215 +1,218
 #!/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
 #-------------------------------------------------------------------------------
 
+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
-
+except ImportError:
+    pass
+else:
 
 #-------------------------------------------------------------------------------
 # Setup for inline and standalone doctests
 #-------------------------------------------------------------------------------
 
 
 # If you have standalone doctests in a separate file, set their names in the
 # dt_files variable (as a single string  or a list thereof):
 dt_files = []
 
 # If you have any modules whose docstrings should be scanned for embedded tests
 # as examples accorging to standard doctest practice, set them here (as a
 # single string or a list thereof):
 dt_modules = []
 
 #-------------------------------------------------------------------------------
 # Regular Unittests
 #-------------------------------------------------------------------------------
 
 
 class Foo(object):
     
     def bar(self, bahz):
         return defer.succeed('blahblah: %s' % bahz)
 
 class TwoPhaseFoo(pd.PendingDeferredManager):
     
     def __init__(self, foo):
         self.foo = foo
         pd.PendingDeferredManager.__init__(self)
 
     @pd.two_phase
     def bar(self, bahz):
         return self.foo.bar(bahz)
 
 class PendingDeferredManagerTest(DeferredTestCase):
     
     def setUp(self):
         self.pdm = pd.PendingDeferredManager()
         
     def tearDown(self):
         pass
     
     def testBasic(self):
         dDict = {}
         # Create 10 deferreds and save them
         for i in range(10):
             d = defer.Deferred()
             did = self.pdm.save_pending_deferred(d)
             dDict[did] = d
         # Make sure they are begin saved
         for k in dDict.keys():
             self.assert_(self.pdm.quick_has_id(k))
         # Get the pending deferred (block=True), then callback with 'foo' and compare
         for did in dDict.keys()[0:5]:
             d = self.pdm.get_pending_deferred(did,block=True)
             dDict[did].callback('foo')
             d.addCallback(lambda r: self.assert_(r=='foo'))
         # Get the pending deferreds with (block=False) and make sure ResultNotCompleted is raised
         for did in dDict.keys()[5:10]:
             d = self.pdm.get_pending_deferred(did,block=False)
             d.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
         # Now callback the last 5, get them and compare.
         for did in dDict.keys()[5:10]:
             dDict[did].callback('foo')
             d = self.pdm.get_pending_deferred(did,block=False)
             d.addCallback(lambda r: self.assert_(r=='foo'))
     
     def test_save_then_delete(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         self.assert_(self.pdm.quick_has_id(did))
         self.pdm.delete_pending_deferred(did)
         self.assert_(not self.pdm.quick_has_id(did))
     
     def test_save_get_delete(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d2.addErrback(lambda f: self.assertRaises(error.AbortedPendingDeferredError, f.raiseException))
         self.pdm.delete_pending_deferred(did)
         return d2
    
     def test_double_get(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d3 = self.pdm.get_pending_deferred(did,True)
         d3.addErrback(lambda f: self.assertRaises(error.InvalidDeferredID, f.raiseException))
     
     def test_get_after_callback(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d.callback('foo')
         d2 = self.pdm.get_pending_deferred(did,True)
         d2.addCallback(lambda r: self.assertEquals(r,'foo'))
         self.assert_(not self.pdm.quick_has_id(did))
 
     def test_get_before_callback(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d.callback('foo')
         d2.addCallback(lambda r: self.assertEquals(r,'foo'))
         self.assert_(not self.pdm.quick_has_id(did))
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d2.addCallback(lambda r: self.assertEquals(r,'foo'))
         d.callback('foo')
         self.assert_(not self.pdm.quick_has_id(did))
     
     def test_get_after_errback(self):
         class MyError(Exception):
             pass
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d.errback(failure.Failure(MyError('foo')))
         d2 = self.pdm.get_pending_deferred(did,True)
         d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
         self.assert_(not self.pdm.quick_has_id(did))
 
     def test_get_before_errback(self):
         class MyError(Exception):
             pass
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d.errback(failure.Failure(MyError('foo')))
         d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
         self.assert_(not self.pdm.quick_has_id(did))
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
         d.errback(failure.Failure(MyError('foo')))
         self.assert_(not self.pdm.quick_has_id(did))
         
     def test_noresult_noblock(self):
         d = defer.Deferred()
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,False)
         d2.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
 
     def test_with_callbacks(self):
         d = defer.Deferred()
         d.addCallback(lambda r: r+' foo')
         d.addCallback(lambda r: r+' bar')
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d.callback('bam')
         d2.addCallback(lambda r: self.assertEquals(r,'bam foo bar'))
     
     def test_with_errbacks(self):
         class MyError(Exception):
             pass
         d = defer.Deferred()
         d.addCallback(lambda r: 'foo')
         d.addErrback(lambda f: 'caught error')
         did = self.pdm.save_pending_deferred(d)
         d2 = self.pdm.get_pending_deferred(did,True)
         d.errback(failure.Failure(MyError('bam')))
         d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
     
     def test_nested_deferreds(self):
         d = defer.Deferred()
         d2 = defer.Deferred()
         d.addCallback(lambda r: d2)
         did = self.pdm.save_pending_deferred(d)
         d.callback('foo')
         d3 = self.pdm.get_pending_deferred(did,False)
         d3.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
         d2.callback('bar')
         d3 = self.pdm.get_pending_deferred(did,False)
         d3.addCallback(lambda r: self.assertEquals(r,'bar'))
 
 #-------------------------------------------------------------------------------
 # Regular Unittests
 #-------------------------------------------------------------------------------
 
 # This ensures that the code will run either standalone as a script, or that it
 # can be picked up by Twisted's `trial` test wrapper to run all the tests.
 if tcommon.pexpect is not None:
     if __name__ == '__main__':
         unittest.main(testLoader=IPDocTestLoader(dt_files,dt_modules))
     else:
         testSuite = lambda : makeTestSuite(__name__,dt_files,dt_modules)

IPython/kernel/tests/test_task.py

@@ -1,47 +1,50
 # 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
 #-------------------------------------------------------------------------------
 
+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 tearDown(self):
         self.controller.stopService()
         for e in self.engines:
             e.stopService()
 
 

IPython/kernel/tests/test_taskfc.py

@@ -1,86 +1,90
 #!/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
 #-------------------------------------------------------------------------------
 
+try:
 import time
 
 from twisted.internet import defer, reactor
 
 from IPython.kernel.fcutil import Tub, UnauthenticatedTub
 
 from IPython.kernel import task as taskmodule
 from IPython.kernel import controllerservice as cs
 import IPython.kernel.multiengine as me
 from IPython.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
 #-------------------------------------------------------------------------------
 
 class TaskTest(DeferredTestCase, ITaskControllerTestCase):
 
     def setUp(self):
         
         self.engines = []
                 
         self.controller = cs.ControllerService()
         self.controller.startService()
         self.imultiengine = me.IMultiEngine(self.controller)
         self.itc = taskmodule.ITaskController(self.controller)
         self.itc.failurePenalty = 0
         
         self.mec_referenceable = IFCSynchronousMultiEngine(self.imultiengine)
         self.tc_referenceable = IFCTaskController(self.itc)
         
         self.controller_tub = Tub()
         self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
         self.controller_tub.setLocation('127.0.0.1:10105')
         
         mec_furl = self.controller_tub.registerReference(self.mec_referenceable)
         tc_furl = self.controller_tub.registerReference(self.tc_referenceable)
         self.controller_tub.startService()
         
         self.client_tub = ClientConnector()
         d = self.client_tub.get_multiengine_client(mec_furl)
         d.addCallback(self.handle_mec_client)
         d.addCallback(lambda _: self.client_tub.get_task_client(tc_furl))
         d.addCallback(self.handle_tc_client)
         return d
         
     def handle_mec_client(self, client):
         self.multiengine = client
     
     def handle_tc_client(self, client):
         self.tc = client
     
     def tearDown(self):
         dlist = []
         # Shut down the multiengine client
         d = self.client_tub.tub.stopService()
         dlist.append(d)
         # Shut down the engines
         for e in self.engines:
             e.stopService()
         # Shut down the controller
         d = self.controller_tub.stopService()
         d.addBoth(lambda _: self.controller.stopService())
         dlist.append(d)
         return defer.DeferredList(dlist)
 

MANIFEST.in

@@ -1,31 +1,36
 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
 #!/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
 #!/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')