Removed some tabs and added a new way of skipping tests that have

missing dependencies.

Previously, we were skipping tests in a hackish way if something
was missing (like Twisted).  Now we do the following::

    try:
        import twisted
    except ImportError:
        import nose
        raise nose.SkipTest("Twisted is required for this test")

This method should be used for all IPython tests that have 
dependencies.

IPython/frontend/asyncfrontendbase.py

@@ -1,92 +1,92
 """
 Base front end class for all async frontends.
 """
 __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 uuid
 
 try:
     from zope.interface import Interface, Attribute, implements, classProvides
 except ImportError, e:
     e.message = """%s
 ________________________________________________________________________________
 zope.interface is required to run asynchronous frontends.""" % e.message
     e.args = (e.message, ) + e.args[1:]
 
 from frontendbase import FrontEndBase, IFrontEnd, IFrontEndFactory
 
-from IPython.kernel.engineservice import IEngineCore
 from IPython.kernel.core.history import FrontEndHistory
 
 try:
+    from IPython.kernel.engineservice import IEngineCore
     from twisted.python.failure import Failure
 except ImportError, e:
     e.message = """%s
 ________________________________________________________________________________
 twisted is required to run asynchronous frontends.""" % e.message
     e.args = (e.message, ) + e.args[1:]
 
 
 
 
 class AsyncFrontEndBase(FrontEndBase):
     """
     Overrides FrontEndBase to wrap execute in a deferred result.
     All callbacks are made as callbacks on the deferred result.
     """
     
     implements(IFrontEnd)
     classProvides(IFrontEndFactory)
     
     def __init__(self, engine=None, history=None):
         assert(engine==None or IEngineCore.providedBy(engine))
         self.engine = IEngineCore(engine)
         if history is None:
                 self.history = FrontEndHistory(input_cache=[''])
         else:
             self.history = history
     
     
     def execute(self, block, blockID=None):
         """Execute the block and return the deferred result.
         
         Parameters:
             block : {str, AST}
             blockID : any
                 Caller may provide an ID to identify this block. 
                 result['blockID'] := blockID
         
         Result:
             Deferred result of self.interpreter.execute
         """
         
         if(not self.is_complete(block)):
             return Failure(Exception("Block is not compilable"))
         
         if(blockID == None):
             blockID = uuid.uuid4() #random UUID
         
         d = self.engine.execute(block)
         d.addCallback(self._add_history, block=block)
         d.addCallbacks(self._add_block_id_for_result,
                 errback=self._add_block_id_for_failure,
                 callbackArgs=(blockID,),
                 errbackArgs=(blockID,))
         d.addBoth(self.update_cell_prompt, blockID=blockID)
         d.addCallbacks(self.render_result, 
             errback=self.render_error)
         
         return d
     
 

IPython/frontend/cocoa/tests/test_cocoa_frontend.py

@@ -1,94 +1,94
 # encoding: utf-8
 """This file contains unittests for the 
 IPython.frontend.cocoa.cocoa_frontend module.
 """
 __docformat__ = "restructuredtext en"
                                                                             
 #---------------------------------------------------------------------------
 #       Copyright (C) 2005  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 IPython.kernel.core.interpreter import Interpreter                     
-	import IPython.kernel.engineservice as es
-	from IPython.testing.util import DeferredTestCase
-	from twisted.internet.defer import succeed
-	from IPython.frontend.cocoa.cocoa_frontend import IPythonCocoaController                                                    
-	from Foundation import NSMakeRect
-	from AppKit import NSTextView, NSScrollView                                                
+    from IPython.kernel.core.interpreter import Interpreter
+    import IPython.kernel.engineservice as es
+    from IPython.testing.util import DeferredTestCase
+    from twisted.internet.defer import succeed
+    from IPython.frontend.cocoa.cocoa_frontend import IPythonCocoaController                                                    
+    from Foundation import NSMakeRect
+    from AppKit import NSTextView, NSScrollView                                                
 except ImportError:
-	pass
-else:
-	class TestIPythonCocoaControler(DeferredTestCase):
-	    """Tests for IPythonCocoaController"""
-    
-	    def setUp(self):
-	        self.controller = IPythonCocoaController.alloc().init()
-	        self.engine = es.EngineService()
-	        self.engine.startService()
-    
-    
-	    def tearDown(self):
-	        self.controller = None
-	        self.engine.stopService()
-    
-	    def testControllerExecutesCode(self):
-	        code ="""5+5"""
-	        expected = Interpreter().execute(code)
-	        del expected['number']
-	        def removeNumberAndID(result):
-	            del result['number']
-	            del result['id']
-	            return result
-	        self.assertDeferredEquals(
-	            self.controller.execute(code).addCallback(removeNumberAndID), 
-	            expected)
-    
-	    def testControllerMirrorsUserNSWithValuesAsStrings(self):
-	        code = """userns1=1;userns2=2"""
-	        def testControllerUserNS(result):
-	            self.assertEquals(self.controller.userNS['userns1'], 1)
-	            self.assertEquals(self.controller.userNS['userns2'], 2)
-        
-	        self.controller.execute(code).addCallback(testControllerUserNS)
-    
-    
-	    def testControllerInstantiatesIEngine(self):
-	        self.assert_(es.IEngineBase.providedBy(self.controller.engine))
-    
-	    def testControllerCompletesToken(self):
-	        code = """longNameVariable=10"""
-	        def testCompletes(result):
-	            self.assert_("longNameVariable" in result)
-        
-	        def testCompleteToken(result):
-	            self.controller.complete("longNa").addCallback(testCompletes)
-        
-	        self.controller.execute(code).addCallback(testCompletes)
-    
-    
-	    def testCurrentIndent(self):
-	        """test that current_indent_string returns current indent or None.
-	        Uses _indent_for_block for direct unit testing.
-	        """
-        
-	        self.controller.tabUsesSpaces = True
-	        self.assert_(self.controller._indent_for_block("""a=3""") == None)
-	        self.assert_(self.controller._indent_for_block("") == None)
-	        block = """def test():\n    a=3"""
-	        self.assert_(self.controller._indent_for_block(block) == \
-	                    ' ' * self.controller.tabSpaces)
-        
-	        block = """if(True):\n%sif(False):\n%spass""" % \
-	                    (' '*self.controller.tabSpaces,
-	                     2*' '*self.controller.tabSpaces)
-	        self.assert_(self.controller._indent_for_block(block) == \
-	                    2*(' '*self.controller.tabSpaces))
-    
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted, Foolscap and PyObjC")
+
+class TestIPythonCocoaControler(DeferredTestCase):
+    """Tests for IPythonCocoaController"""
+   
+    def setUp(self):
+        self.controller = IPythonCocoaController.alloc().init()
+        self.engine = es.EngineService()
+        self.engine.startService()
+   
+    def tearDown(self):
+        self.controller = None
+        self.engine.stopService()
+   
+    def testControllerExecutesCode(self):
+        code ="""5+5"""
+        expected = Interpreter().execute(code)
+        del expected['number']
+        def removeNumberAndID(result):
+            del result['number']
+            del result['id']
+            return result
+        self.assertDeferredEquals(
+            self.controller.execute(code).addCallback(removeNumberAndID), 
+            expected)
+   
+    def testControllerMirrorsUserNSWithValuesAsStrings(self):
+        code = """userns1=1;userns2=2"""
+        def testControllerUserNS(result):
+            self.assertEquals(self.controller.userNS['userns1'], 1)
+            self.assertEquals(self.controller.userNS['userns2'], 2)
+       
+        self.controller.execute(code).addCallback(testControllerUserNS)
+   
+   
+    def testControllerInstantiatesIEngine(self):
+        self.assert_(es.IEngineBase.providedBy(self.controller.engine))
+   
+    def testControllerCompletesToken(self):
+        code = """longNameVariable=10"""
+        def testCompletes(result):
+            self.assert_("longNameVariable" in result)
+       
+        def testCompleteToken(result):
+            self.controller.complete("longNa").addCallback(testCompletes)
+       
+        self.controller.execute(code).addCallback(testCompletes)
+   
+   
+    def testCurrentIndent(self):
+        """test that current_indent_string returns current indent or None.
+        Uses _indent_for_block for direct unit testing.
+        """
+       
+        self.controller.tabUsesSpaces = True
+        self.assert_(self.controller._indent_for_block("""a=3""") == None)
+        self.assert_(self.controller._indent_for_block("") == None)
+        block = """def test():\n    a=3"""
+        self.assert_(self.controller._indent_for_block(block) == \
+                    ' ' * self.controller.tabSpaces)
+       
+        block = """if(True):\n%sif(False):\n%spass""" % \
+                    (' '*self.controller.tabSpaces,
+                     2*' '*self.controller.tabSpaces)
+        self.assert_(self.controller._indent_for_block(block) == \
+                    2*(' '*self.controller.tabSpaces))
+   

IPython/frontend/tests/test_frontendbase.py

@@ -1,157 +1,157
 # encoding: utf-8
 
 """This file contains unittests for the frontendbase 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 unittest
 
 try:
-	from IPython.frontend.asyncfrontendbase import AsyncFrontEndBase
-	from IPython.frontend import frontendbase 
-	from IPython.kernel.engineservice import EngineService
+    from IPython.frontend.asyncfrontendbase import AsyncFrontEndBase
+    from IPython.frontend import frontendbase 
+    from IPython.kernel.engineservice import EngineService
 except ImportError:
-	import nose
-	raise nose.SkipTest("This test requires zope.interface and Twisted")
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
 
 class FrontEndCallbackChecker(AsyncFrontEndBase):
     """FrontEndBase subclass for checking callbacks"""
     def __init__(self, engine=None, history=None):
         super(FrontEndCallbackChecker, self).__init__(engine=engine, 
                                                     history=history)
         self.updateCalled = False
         self.renderResultCalled = False
         self.renderErrorCalled = False
    
     def update_cell_prompt(self, result, blockID=None):
         self.updateCalled = True
         return result
    
     def render_result(self, result):
         self.renderResultCalled = True
         return result
     
     
     def render_error(self, failure):
         self.renderErrorCalled = True
         return failure
     
 
 
     
 class TestAsyncFrontendBase(unittest.TestCase):
     def setUp(self):
         """Setup the EngineService and FrontEndBase"""
         
         self.fb = FrontEndCallbackChecker(engine=EngineService())
     
     
     def test_implements_IFrontEnd(self):
         assert(frontendbase.IFrontEnd.implementedBy(
                                     AsyncFrontEndBase))
     
     
     def test_is_complete_returns_False_for_incomplete_block(self):
         """"""
         
         block = """def test(a):"""
         
         assert(self.fb.is_complete(block) == False)
     
     def test_is_complete_returns_True_for_complete_block(self):
         """"""
         
         block = """def test(a): pass"""
             
         assert(self.fb.is_complete(block))
         
         block = """a=3"""
         
         assert(self.fb.is_complete(block))
     
     
     def test_blockID_added_to_result(self):
         block = """3+3"""
         
         d = self.fb.execute(block, blockID='TEST_ID')
         
         d.addCallback(self.checkBlockID, expected='TEST_ID')
     
     def test_blockID_added_to_failure(self):
         block = "raise Exception()"
         
         d = self.fb.execute(block,blockID='TEST_ID')
         d.addErrback(self.checkFailureID, expected='TEST_ID')
     
     def checkBlockID(self, result, expected=""):
         assert(result['blockID'] == expected)
     
     
     def checkFailureID(self, failure, expected=""):
         assert(failure.blockID == expected)
     
     
     def test_callbacks_added_to_execute(self):
         """test that
         update_cell_prompt
         render_result
         
         are added to execute request
         """
         
         d = self.fb.execute("10+10")
         d.addCallback(self.checkCallbacks)
     
     
     def checkCallbacks(self, result):
         assert(self.fb.updateCalled)
         assert(self.fb.renderResultCalled)
     
     
     def test_error_callback_added_to_execute(self):
         """test that render_error called on execution error"""
         
         d = self.fb.execute("raise Exception()")
         d.addCallback(self.checkRenderError)
     
     def checkRenderError(self, result):
         assert(self.fb.renderErrorCalled)
     
     def test_history_returns_expected_block(self):
         """Make sure history browsing doesn't fail"""
         
         blocks = ["a=1","a=2","a=3"]
         for b in blocks:
             d = self.fb.execute(b)
         
         # d is now the deferred for the last executed block
         d.addCallback(self.historyTests, blocks)
         
     
     def historyTests(self, result, blocks):
         """historyTests"""
         
         assert(len(blocks) >= 3)
         assert(self.fb.get_history_previous("") == blocks[-2])
         assert(self.fb.get_history_previous("") == blocks[-3])
         assert(self.fb.get_history_next() == blocks[-2])
     
     
     def test_history_returns_none_at_startup(self):
         """test_history_returns_none_at_startup"""
         
         assert(self.fb.get_history_previous("")==None)
         assert(self.fb.get_history_next()==None)
     
     

IPython/kernel/tests/test_controllerservice.py

@@ -1,43 +1,44
 # 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()
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
+
+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,91 +1,93
 # 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:
-	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
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
+
+
+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,78 +1,80
 # 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 ThreadedEngineServiceTest(DeferredTestCase,
-                                 IEngineCoreTestCase, 
-                                 IEngineSerializedTestCase,
-                                 IEnginePropertiesTestCase):
-    
-        def setUp(self):
-            self.engine = es.ThreadedEngineService()
-            self.engine.startService()
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")    
+
+
+class BasicEngineServiceTest(DeferredTestCase,
+                             IEngineCoreTestCase, 
+                             IEngineSerializedTestCase,
+                             IEnginePropertiesTestCase):
+
+    def setUp(self):
+        self.engine = es.EngineService()
+        self.engine.startService()
+
+    def tearDown(self):
+        return self.engine.stopService()
+
+class ThreadedEngineServiceTest(DeferredTestCase,
+                             IEngineCoreTestCase, 
+                             IEngineSerializedTestCase,
+                             IEnginePropertiesTestCase):
+
+    def setUp(self):
+        self.engine = es.ThreadedEngineService()
+        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.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()
-
- 
+    def tearDown(self):
+        return self.rawEngine.stopService()
+
+

IPython/kernel/tests/test_multiengine.py

@@ -1,54 +1,56
 # 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):
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
+
+ 
+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()
-
-
-    class SynchronousMultiEngineTestCase(DeferredTestCase, ISynchronousMultiEngineTestCase):
+    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 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,144 +1,144
 #!/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
     from IPython.kernel.parallelfunction import ParallelFunction
     from IPython.kernel.error import CompositeError
     from IPython.kernel.util import printer
 except ImportError:
-    pass
-else:
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
     
-    def _raise_it(f):
-        try:
-            f.raiseException()
-        except CompositeError, e:
-            e.raise_exception()
+def _raise_it(f):
+    try:
+        f.raiseException()
+    except CompositeError, e:
+        e.raise_exception()
+
+
+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')
     
-    class FullSynchronousMultiEngineTestCase(DeferredTestCase, IFullSynchronousMultiEngineTestCase):
+        furl = self.controller_tub.registerReference(self.mec_referenceable)
+        self.controller_tub.startService()
     
-        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
+        self.client_tub = ClientConnector()
+        d = self.client_tub.get_multiengine_client(furl)
+        d.addCallback(self.handle_got_client)
+        return d
     
-        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 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 test_mapper(self):
-            self.addEngine(4)
-            m = self.multiengine.mapper()
-            self.assertEquals(m.multiengine,self.multiengine)
-            self.assertEquals(m.dist,'b')
-            self.assertEquals(m.targets,'all')
-            self.assertEquals(m.block,True)
-        
-        def test_map_default(self):
-            self.addEngine(4)
-            m = self.multiengine.mapper()
-            d = m.map(lambda x: 2*x, range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            d.addCallback(lambda _: self.multiengine.map(lambda x: 2*x, range(10)))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-        
-        def test_map_noblock(self):
-            self.addEngine(4)
-            m = self.multiengine.mapper(block=False)
-            d = m.map(lambda x: 2*x, range(10))
-            d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-                
-        def test_mapper_fail(self):
-            self.addEngine(4)
-            m = self.multiengine.mapper()
-            d = m.map(lambda x: 1/0, range(10))
-            d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
-            return d
-        
-        def test_parallel(self):
-            self.addEngine(4)
-            p = self.multiengine.parallel()
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 2*x
-            d = f(range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-        
-        def test_parallel_noblock(self):
-            self.addEngine(1)
-            p = self.multiengine.parallel(block=False)
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 2*x
-            d = f(range(10))
-            d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-        
-        def test_parallel_fail(self):
-            self.addEngine(4)
-            p = self.multiengine.parallel()
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 1/0
-            d = f(range(10))
-            d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
-            return d
  No newline at end of file
+    def test_mapper(self):
+        self.addEngine(4)
+        m = self.multiengine.mapper()
+        self.assertEquals(m.multiengine,self.multiengine)
+        self.assertEquals(m.dist,'b')
+        self.assertEquals(m.targets,'all')
+        self.assertEquals(m.block,True)
+    
+    def test_map_default(self):
+        self.addEngine(4)
+        m = self.multiengine.mapper()
+        d = m.map(lambda x: 2*x, range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        d.addCallback(lambda _: self.multiengine.map(lambda x: 2*x, range(10)))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
+    
+    def test_map_noblock(self):
+        self.addEngine(4)
+        m = self.multiengine.mapper(block=False)
+        d = m.map(lambda x: 2*x, range(10))
+        d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
+            
+    def test_mapper_fail(self):
+        self.addEngine(4)
+        m = self.multiengine.mapper()
+        d = m.map(lambda x: 1/0, range(10))
+        d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
+        return d
+    
+    def test_parallel(self):
+        self.addEngine(4)
+        p = self.multiengine.parallel()
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 2*x
+        d = f(range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
+    
+    def test_parallel_noblock(self):
+        self.addEngine(1)
+        p = self.multiengine.parallel(block=False)
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 2*x
+        d = f(range(10))
+        d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
+    
+    def test_parallel_fail(self):
+        self.addEngine(4)
+        p = self.multiengine.parallel()
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 1/0
+        d = f(range(10))
+        d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
+        return d
  No newline at end of file

IPython/kernel/tests/test_newserialized.py

@@ -1,102 +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
-    #-------------------------------------------------------------------------------
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
+
+#-------------------------------------------------------------------------------
+# Tests
+#-------------------------------------------------------------------------------
+
+class SerializedTestCase(unittest.TestCase):
+
+    def setUp(self):
+        pass
     
-    class SerializedTestCase(unittest.TestCase):
+    def tearDown(self):
+        pass
     
-        def setUp(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,186 +1,186
 #!/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.util import DeferredTestCase
     import IPython.kernel.pendingdeferred as pd
     from IPython.kernel import error
     from IPython.kernel.util import printer
 except ImportError:
-    pass
-else:
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
     
-    class Foo(object):
-    
-        def bar(self, bahz):
-            return defer.succeed('blahblah: %s' % bahz)
+class Foo(object):
 
-    class TwoPhaseFoo(pd.PendingDeferredManager):
-    
-        def __init__(self, foo):
-            self.foo = foo
-            pd.PendingDeferredManager.__init__(self)
+    def bar(self, bahz):
+        return defer.succeed('blahblah: %s' % bahz)
 
-        @pd.two_phase
-        def bar(self, bahz):
-            return self.foo.bar(bahz)
+class TwoPhaseFoo(pd.PendingDeferredManager):
 
-    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 __init__(self, foo):
+        self.foo = foo
+        pd.PendingDeferredManager.__init__(self)
 
-        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))
+    @pd.two_phase
+    def bar(self, bahz):
+        return self.foo.bar(bahz)
 
-        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'))
+class PendingDeferredManagerTest(DeferredTestCase):
+
+    def setUp(self):
+        self.pdm = pd.PendingDeferredManager()
     
-        def test_with_errbacks(self):
-            class MyError(Exception):
-                pass
+    def tearDown(self):
+        pass
+
+    def testBasic(self):
+        dDict = {}
+        # Create 10 deferreds and save them
+        for i in range(10):
             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))
+            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_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_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'))
 

IPython/kernel/tests/test_task.py

@@ -1,50 +1,51
 # 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
-    #-------------------------------------------------------------------------------
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
 
-    class BasicTaskControllerTestCase(DeferredTestCase, ITaskControllerTestCase):
+#-------------------------------------------------------------------------------
+# Tests
+#-------------------------------------------------------------------------------
+
+class BasicTaskControllerTestCase(DeferredTestCase, ITaskControllerTestCase):
+
+    def setUp(self):
+        self.controller  = cs.ControllerService()
+        self.controller.startService()
+        self.multiengine = IMultiEngine(self.controller)
+        self.tc = task.ITaskController(self.controller)
+        self.tc.failurePenalty = 0
+        self.engines=[]
     
-        def 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,161 +1,162
 #!/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
     from IPython.kernel.error import CompositeError
     from IPython.kernel.parallelfunction import ParallelFunction
 except ImportError:
-    pass
-else:
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
 
-    #-------------------------------------------------------------------------------
-    # Tests
-    #-------------------------------------------------------------------------------
 
-    def _raise_it(f):
-        try:
-            f.raiseException()
-        except CompositeError, e:
-            e.raise_exception()
+#-------------------------------------------------------------------------------
+# Tests
+#-------------------------------------------------------------------------------
 
-    class TaskTest(DeferredTestCase, ITaskControllerTestCase):
+def _raise_it(f):
+    try:
+        f.raiseException()
+    except CompositeError, e:
+        e.raise_exception()
 
-        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
+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)
+    
+    def test_mapper(self):
+        self.addEngine(1)
+        m = self.tc.mapper()
+        self.assertEquals(m.task_controller,self.tc)
+        self.assertEquals(m.clear_before,False)
+        self.assertEquals(m.clear_after,False)
+        self.assertEquals(m.retries,0)
+        self.assertEquals(m.recovery_task,None)
+        self.assertEquals(m.depend,None)
+        self.assertEquals(m.block,True)
+    
+    def test_map_default(self):
+        self.addEngine(1)
+        m = self.tc.mapper()
+        d = m.map(lambda x: 2*x, range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        d.addCallback(lambda _: self.tc.map(lambda x: 2*x, range(10)))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
+    
+    def test_map_noblock(self):
+        self.addEngine(1)
+        m = self.tc.mapper(block=False)
+        d = m.map(lambda x: 2*x, range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[x for x in range(10)]))
+        return d
+            
+    def test_mapper_fail(self):
+        self.addEngine(1)
+        m = self.tc.mapper()
+        d = m.map(lambda x: 1/0, range(10))
+        d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
+        return d
+    
+    def test_parallel(self):
+        self.addEngine(1)
+        p = self.tc.parallel()
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 2*x
+        d = f(range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
     
-        def handle_tc_client(self, client):
-            self.tc = client
+    def test_parallel_noblock(self):
+        self.addEngine(1)
+        p = self.tc.parallel(block=False)
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 2*x
+        d = f(range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[x for x in range(10)]))
+        return d
     
-        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 test_mapper(self):
-            self.addEngine(1)
-            m = self.tc.mapper()
-            self.assertEquals(m.task_controller,self.tc)
-            self.assertEquals(m.clear_before,False)
-            self.assertEquals(m.clear_after,False)
-            self.assertEquals(m.retries,0)
-            self.assertEquals(m.recovery_task,None)
-            self.assertEquals(m.depend,None)
-            self.assertEquals(m.block,True)
-        
-        def test_map_default(self):
-            self.addEngine(1)
-            m = self.tc.mapper()
-            d = m.map(lambda x: 2*x, range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            d.addCallback(lambda _: self.tc.map(lambda x: 2*x, range(10)))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-        
-        def test_map_noblock(self):
-            self.addEngine(1)
-            m = self.tc.mapper(block=False)
-            d = m.map(lambda x: 2*x, range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[x for x in range(10)]))
-            return d
-                
-        def test_mapper_fail(self):
-            self.addEngine(1)
-            m = self.tc.mapper()
-            d = m.map(lambda x: 1/0, range(10))
-            d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
-            return d
-        
-        def test_parallel(self):
-            self.addEngine(1)
-            p = self.tc.parallel()
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 2*x
-            d = f(range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-        
-        def test_parallel_noblock(self):
-            self.addEngine(1)
-            p = self.tc.parallel(block=False)
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 2*x
-            d = f(range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[x for x in range(10)]))
-            return d
-        
-        def test_parallel_fail(self):
-            self.addEngine(1)
-            p = self.tc.parallel()
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 1/0
-            d = f(range(10))
-            d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
-            return d
  No newline at end of file
+    def test_parallel_fail(self):
+        self.addEngine(1)
+        p = self.tc.parallel()
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 1/0
+        d = f(range(10))
+        d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
+        return d
  No newline at end of file

docs/source/development/development.txt

@@ -1,393 +1,401
 .. _development:
 
 ==================================
 IPython development guidelines
 ==================================
 
 .. contents::
 
 
 Overview
 ========
 
 IPython is the next generation of IPython.  It is named such for two reasons:
 
 - Eventually, IPython will become IPython version 1.0.
 - This new code base needs to be able to co-exist with the existing IPython until
   it is a full replacement for it.  Thus we needed a different name.  We couldn't
   use ``ipython`` (lowercase) as some files systems are case insensitive.
 
 There are two, no three, main goals of the IPython effort:
 
 1. Clean up the existing codebase and write lots of tests.
 2. Separate the core functionality of IPython from the terminal to enable IPython
    to be used from within a variety of GUI applications.
 3. Implement a system for interactive parallel computing.
 
 While the third goal may seem a bit unrelated to the main focus of IPython, it turns
 out that the technologies required for this goal are nearly identical with those
 required for goal two. This is the main reason the interactive parallel computing
 capabilities are being put into IPython proper. Currently the third of these goals is
 furthest along.
 
 This document describes IPython from the perspective of developers.  
 
 
 Project organization
 ====================
 
 Subpackages
 -----------
 
 IPython is organized into semi self-contained subpackages.  Each of the subpackages will have its own:
 
 - **Dependencies**.  One of the most important things to keep in mind in
   partitioning code amongst subpackages, is that they should be used to cleanly
   encapsulate dependencies.  
 - **Tests**.  Each subpackage shoud have its own ``tests`` subdirectory that
   contains all of the tests for that package.  For information about writing tests
   for IPython, see the `Testing System`_ section of this document.
 - **Configuration**.  Each subpackage should have its own ``config`` subdirectory
   that contains the configuration information for the components of the 
   subpackage.  For information about how the IPython configuration system
   works, see the `Configuration System`_ section of this document.
 - **Scripts**.  Each subpackage should have its own ``scripts`` subdirectory that
   contains all of the command line scripts associated with the subpackage.
 
 Installation and dependencies
 -----------------------------
    
 IPython will not use `setuptools`_ for installation. Instead, we will use standard
 ``setup.py`` scripts that use `distutils`_. While there are a number a extremely nice
 features that `setuptools`_ has (like namespace packages), the current implementation
 of `setuptools`_ has performance problems, particularly on shared file systems. In
 particular, when Python packages are installed on NSF file systems, import times
 become much too long (up towards 10 seconds). 
 
 Because IPython is being used extensively in the context of high performance
 computing, where performance is critical but shared file systems are common, we feel
 these performance hits are not acceptable. Thus, until the performance problems
 associated with `setuptools`_ are addressed, we will stick with plain `distutils`_. We
 are hopeful that these problems will be addressed and that we will eventually begin
 using `setuptools`_. Because of this, we are trying to organize IPython in a way that
 will make the eventual transition to `setuptools`_ as painless as possible.
 
 Because we will be using `distutils`_, there will be no method for automatically installing dependencies.  Instead, we are following the approach of `Matplotlib`_ which can be summarized as follows:
 
 - Distinguish between required and optional dependencies.  However, the required
   dependencies for IPython should be only the Python standard library.
 - Upon installation check to see which optional dependencies are present and tell
   the user which parts of IPython need which optional dependencies.
 
 It is absolutely critical that each subpackage of IPython has a clearly specified set
 of dependencies and that dependencies are not carelessly inherited from other IPython
 subpackages. Furthermore, tests that have certain dependencies should not fail if
 those dependencies are not present. Instead they should be skipped and print a
 message.
 
 .. _setuptools: http://peak.telecommunity.com/DevCenter/setuptools
 .. _distutils: http://docs.python.org/lib/module-distutils.html
 .. _Matplotlib: http://matplotlib.sourceforge.net/
 
 Specific subpackages
 --------------------
 
 ``core``
-	This is the core functionality of IPython that is independent of the
-	terminal, network and GUIs.  Most of the code that is in the current
-	IPython trunk will be refactored, cleaned up and moved here.
+    This is the core functionality of IPython that is independent of the
+    terminal, network and GUIs.  Most of the code that is in the current
+    IPython trunk will be refactored, cleaned up and moved here.
 
 ``kernel``
-	The enables the IPython core to be expose to a the network.  This is
-	also where all of the parallel computing capabilities are to be found.
-	
+    The enables the IPython core to be expose to a the network.  This is
+    also where all of the parallel computing capabilities are to be found.
+    
 ``config``
-	The configuration package used by IPython.
+    The configuration package used by IPython.
 
 ``frontends``
-	The various frontends for IPython.  A frontend is the end-user application
-	that exposes the capabilities of IPython to the user.  The most basic frontend
-	will simply be a terminal based application that looks just like today 's 
-	IPython.  Other frontends will likely be more powerful and based on GUI toolkits.
+    The various frontends for IPython.  A frontend is the end-user application
+    that exposes the capabilities of IPython to the user.  The most basic frontend
+    will simply be a terminal based application that looks just like today 's 
+    IPython.  Other frontends will likely be more powerful and based on GUI toolkits.
 
 ``notebook``
-	An application that allows users to work with IPython notebooks.
+    An application that allows users to work with IPython notebooks.
 
 ``tools``
-	This is where general utilities go.
+    This is where general utilities go.
 
 
 Version control
 ===============
 
 In the past, IPython development has been done using `Subversion`__.  Recently, we made the transition to using `Bazaar`__ and `Launchpad`__.  This makes it much easier for people
 to contribute code to IPython.  Here is a sketch of how to use Bazaar for IPython
 development.  First, you should install Bazaar.  After you have done that, make
 sure that it is working by getting the latest main branch of IPython::
 
-	$ bzr branch lp:ipython
+    $ bzr branch lp:ipython
 
 Now you can create a new branch for you to do your work in::
 
-	$ bzr branch ipython ipython-mybranch
+    $ bzr branch ipython ipython-mybranch
 
 The typical work cycle in this branch will be to make changes in `ipython-mybranch`
 and then commit those changes using the commit command::
 
-	$ ...do work in ipython-mybranch...
-	$ bzr ci -m "the commit message goes here"
+    $ ...do work in ipython-mybranch...
+    $ bzr ci -m "the commit message goes here"
 
 Please note that since we now don't use an old-style linear ChangeLog
 (that tends to cause problems with distributed version control
 systems), you should ensure that your log messages are reasonably
 detailed.  Use a docstring-like approach in the commit messages
 (including the second line being left *blank*)::
 
   Single line summary of  changes being committed.
 
   - more details when warranted ...
   - including crediting outside contributors if they sent the
     code/bug/idea!
 
 If we couple this with a policy of making single commits for each
 reasonably atomic change, the bzr log should give an excellent view of
 the project, and the `--short` log option becomes a nice summary.
 
 While working with this branch, it is a good idea to merge in changes that have been
 made upstream in the parent branch.  This can be done by doing::
 
-	$ bzr pull
-	
+    $ bzr pull
+    
 If this command shows that the branches have diverged, then you should do a merge
 instead::
 
-	$ bzr merge lp:ipython
+    $ bzr merge lp:ipython
 
 If you want others to be able to see your branch, you can create an account with
 launchpad and push the branch to your own workspace::
 
-	$ bzr push bzr+ssh://<me>@bazaar.launchpad.net/~<me>/+junk/ipython-mybranch
+    $ bzr push bzr+ssh://<me>@bazaar.launchpad.net/~<me>/+junk/ipython-mybranch
 
 Finally, once the work in your branch is done, you can merge your changes back into
 the `ipython` branch by using merge::
 
-	$ cd ipython
-	$ merge ../ipython-mybranch
-	[resolve any conflicts]
-	$ bzr ci -m "Fixing that bug"
-	$ bzr push
+    $ cd ipython
+    $ merge ../ipython-mybranch
+    [resolve any conflicts]
+    $ bzr ci -m "Fixing that bug"
+    $ bzr push
 
 But this will require you to have write permissions to the `ipython` branch.  It you don't
 you can tell one of the IPython devs about your branch and they can do the merge for you.
 
 More information about Bazaar workflows can be found `here`__.
 
 .. __: http://subversion.tigris.org/
 .. __: http://bazaar-vcs.org/
 .. __: http://www.launchpad.net/ipython
 .. __: http://doc.bazaar-vcs.org/bzr.dev/en/user-guide/index.html
 
 Documentation
 =============
 
 Standalone documentation
 ------------------------
 
 All standalone documentation should be written in plain text (``.txt``) files using
 `reStructuredText`_ for markup and formatting. All such documentation should be placed
 in the top level directory ``docs`` of the IPython source tree. Or, when appropriate,
 a suitably named subdirectory should be used. The documentation in this location will
 serve as the main source for IPython documentation and all existing documentation
 should be converted to this format.
 
 In the future, the text files in the ``docs`` directory will be used to generate all
 forms of documentation for IPython. This include documentation on the IPython website
 as well as *pdf* documentation.
 
 .. _reStructuredText: http://docutils.sourceforge.net/rst.html
 
 Docstring format
 ----------------
 
 Good docstrings are very important. All new code will use `Epydoc`_ for generating API
 docs, so we will follow the `Epydoc`_ conventions. More specifically, we will use
 `reStructuredText`_ for markup and formatting, since it is understood by a wide
 variety of tools. This means that if in the future we have any reason to change from
 `Epydoc`_ to something else, we'll have fewer transition pains.
 
 Details about using `reStructuredText`_ for docstrings can be found `here
 <http://epydoc.sourceforge.net/manual-othermarkup.html>`_.
 
 .. _Epydoc: http://epydoc.sourceforge.net/
 
 Additional PEPs of interest regarding documentation of code:
 
 - `Docstring Conventions <http://www.python.org/peps/pep-0257.html>`_
 - `Docstring Processing System Framework <http://www.python.org/peps/pep-0256.html>`_
 - `Docutils Design Specification <http://www.python.org/peps/pep-0258.html>`_
 
 
 Coding conventions
 ==================
 
 General
 -------
 
 In general, we'll try to follow the standard Python style conventions as described here:
 
 - `Style Guide for Python Code  <http://www.python.org/peps/pep-0008.html>`_  
 
 
 Other comments:
 
 - In a large file, top level classes and functions should be 
   separated by 2-3 lines to make it easier to separate them visually.
 - Use 4 spaces for indentation.
 - Keep the ordering of methods the same in classes that have the same 
   methods.  This is particularly true for classes that implement 
   similar interfaces and for interfaces that are similar.
 
 Naming conventions
 ------------------
 
 In terms of naming conventions, we'll follow the guidelines from the `Style Guide for
 Python Code`_.
 
 For all new IPython code (and much existing code is being refactored), we'll use:
 
 - All ``lowercase`` module names.
 
 - ``CamelCase`` for class names.
 
 - ``lowercase_with_underscores`` for methods, functions, variables and attributes.
 
 This may be confusing as most of the existing IPython codebase uses a different convention (``lowerCamelCase`` for methods and attributes).  Slowly, we will move IPython over to the new
 convention, providing shadow names for backward compatibility in public interfaces. 
 
 There are, however, some important exceptions to these rules.  In some cases, IPython
 code will interface with packages (Twisted, Wx, Qt) that use other conventions.  At some level this makes it impossible to adhere to our own standards at all times.  In particular, when subclassing classes that use other naming conventions, you must follow their naming conventions.  To deal with cases like this, we propose the following policy:
 
 - If you are subclassing a class that uses different conventions, use its
   naming conventions throughout your subclass.  Thus, if you are creating a 
   Twisted Protocol class, used Twisted's ``namingSchemeForMethodsAndAttributes.``
 
 - All IPython's official interfaces should use our conventions.  In some cases 
   this will mean that you need to provide shadow names (first implement ``fooBar``
   and then ``foo_bar = fooBar``).  We want to avoid this at all costs, but it 
   will probably be necessary at times.  But, please use this sparingly!
 
 Implementation-specific *private* methods will use ``_single_underscore_prefix``.
 Names with a leading double underscore will *only* be used in special cases, as they
 makes subclassing difficult (such names are not easily seen by child classes).
 
 Occasionally some run-in lowercase names are used, but mostly for very short names or
 where we are implementing methods very similar to existing ones in a base class (like
 ``runlines()`` where ``runsource()`` and ``runcode()`` had established precedent).
 
 The old IPython codebase has a big mix of classes and modules prefixed with an
 explicit ``IP``. In Python this is mostly unnecessary, redundant and frowned upon, as
 namespaces offer cleaner prefixing. The only case where this approach is justified is
 for classes which are expected to be imported into external namespaces and a very
 generic name (like Shell) is too likely to clash with something else. We'll need to
 revisit this issue as we clean up and refactor the code, but in general we should
 remove as many unnecessary ``IP``/``ip`` prefixes as possible. However, if a prefix
 seems absolutely necessary the more specific ``IPY`` or ``ipy`` are preferred.
 
 .. _devel_testing:
 
 Testing system
 ==============
 
 It is extremely important that all code contributed to IPython has tests. Tests should
 be written as unittests, doctests or as entities that the `Nose`_ testing package will
 find. Regardless of how the tests are written, we will use `Nose`_ for discovering and
 running the tests. `Nose`_ will be required to run the IPython test suite, but will
 not be required to simply use IPython.
 
 .. _Nose: http://code.google.com/p/python-nose/
 
 Tests of `Twisted`__ using code should be written by subclassing the ``TestCase`` class
 that comes with ``twisted.trial.unittest``. When this is done, `Nose`_ will be able to
 run the tests and the twisted reactor will be handled correctly.
 
 .. __: http://www.twistedmatrix.com
 
 Each subpackage in IPython should have its own ``tests`` directory that contains all
 of the tests for that subpackage. This allows each subpackage to be self-contained. If
 a subpackage has any dependencies beyond the Python standard library, the tests for
 that subpackage should be skipped if the dependencies are not found. This is very
 important so users don't get tests failing simply because they don't have dependencies.
 
 We also need to look into use Noses ability to tag tests to allow a more modular
 approach of running tests.
 
 .. _devel_config:
 
 Configuration system
 ====================
 
 IPython uses `.ini`_ files for configuration purposes. This represents a huge
 improvement over the configuration system used in IPython. IPython works with these
 files using the `ConfigObj`_ package, which IPython includes as
 ``ipython1/external/configobj.py``.
 
 Currently, we are using raw `ConfigObj`_ objects themselves. Each subpackage of IPython
 should contain a ``config`` subdirectory that contains all of the configuration
 information for the subpackage. To see how configuration information is defined (along
 with defaults) see at the examples in ``ipython1/kernel/config`` and
 ``ipython1/core/config``. Likewise, to see how the configuration information is used,
 see examples in ``ipython1/kernel/scripts/ipengine.py``.
 
 Eventually, we will add a new layer on top of the raw `ConfigObj`_ objects. We are
 calling this new layer, ``tconfig``, as it will use a `Traits`_-like validation model.
 We won't actually use `Traits`_, but will implement something similar in pure Python.
 But, even in this new system, we will still use `ConfigObj`_ and `.ini`_ files
 underneath the hood. Talk to Fernando if you are interested in working on this part of
 IPython. The current prototype of ``tconfig`` is located in the IPython sandbox.
 
 .. _.ini: http://docs.python.org/lib/module-ConfigParser.html
 .. _ConfigObj: http://www.voidspace.org.uk/python/configobj.html
 .. _Traits: http://code.enthought.com/traits/
 
 Installation and testing scenarios
 ==================================
 
 This section outlines the various scenarios that we need to test before we release an IPython version.  These scenarios represent different ways of installing IPython and its dependencies.
 
 Installation scenarios
 ----------------------
 
-	1.  Install from tarball using `python setup.py install`.
-		a.  With only readline+nose dependencies installed (test1)
-		b.  With all dependencies installed (readline, zope.interface,
-		    Twisted, foolscap, Sphinx, nose, pyOpenSSL) (test2)
-	2.  Install using easy_install.
-	    a.  With only readline+nose dependencies installed (test3)
-			i.  Default dependencies.
-			ii. Optional dependency sets (kernel, doc, test, security)
-			easy_install -f ipython-0.9.beta3-py2.5.egg IPython[kernel,doc,test,security]
-			
-		b.  With all dependencies already installed (test2)
+    1.  Install from tarball using `python setup.py install`.
+        a.  With only readline+nose dependencies installed (test1)
+        
+        virtualenv --no-site-packages test1
+        # Activate it
+        easy_install nose
+        easy_install readline # On OS X or pyreadline on win32
+        cd ipython-0.9.beta3
+        python setup.py install
+        
+        b.  With all dependencies installed (readline, zope.interface,
+            Twisted, foolscap, Sphinx, nose, pyOpenSSL) (test2)
+    2.  Install using easy_install.
+        a.  With only readline+nose dependencies installed (test3)
+            i.  Default dependencies.
+            ii. Optional dependency sets (kernel, doc, test, security)
+            easy_install -f ipython-0.9.beta3-py2.5.egg IPython[kernel,doc,test,security]
+            
+        b.  With all dependencies already installed (test2)
 
 
 Tests to run for these scenarios
 --------------------------------
 
-	1.  Run the full test suite.
-	2.  Start a controller and engines and try a few things by hand.
-		a.  Using ipcluster.
-		b.  Using ipcontroller/ipengine by hand.
-	3.  Run a few of the parallel examples.
-	4.  Try the kernel with and without security with and without PyOpenSSL
-	    installed.
-	5.  Beat on the IPython terminal a bunch.
-	6.  Make sure that furl files are being put in proper locations.
+    1.  Run the full test suite.
+    2.  Start a controller and engines and try a few things by hand.
+        a.  Using ipcluster.
+        b.  Using ipcontroller/ipengine by hand.
+    3.  Run a few of the parallel examples.
+    4.  Try the kernel with and without security with and without PyOpenSSL
+        installed.
+    5.  Beat on the IPython terminal a bunch.
+    6.  Make sure that furl files are being put in proper locations.