pep8 compliance, first pass

IPython/frontend/cocoa/cocoa_frontend.py

@@ -1,395 +1,415 b''
 # encoding: utf-8
-# -*- test-case-name: ipython1.frontend.cocoa.tests.test_cocoa_frontend -*-
+# -*- test-case-name: IPython.frontend.cocoa.tests.test_cocoa_frontend -*-
 
-"""PyObjC classes to provide a Cocoa frontend to the ipython1.kernel.engineservice.EngineService.
+"""PyObjC classes to provide a Cocoa frontend to the 
+IPython.kernel.engineservice.EngineService.
 
-The Cocoa frontend is divided into two classes:
-    - IPythonCocoaController
-    - IPythonCLITextViewDelegate
+To add an IPython interpreter to a cocoa app, instantiate an 
+IPythonCocoaController in a XIB and connect its textView outlet to an
+NSTextView instance in your UI. That's it.
 
-To add an IPython interpreter to a cocoa app, instantiate both of these classes in an XIB...[FINISH]
+Author: Barry Wark
 """
 
 __docformat__ = "restructuredtext en"
 
-#-------------------------------------------------------------------------------
-#       Copyright (C) 2008  Barry Wark <[e-mail]>
+#-----------------------------------------------------------------------------
+#       Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
+#-----------------------------------------------------------------------------
 
-#-------------------------------------------------------------------------------
+#-----------------------------------------------------------------------------
 # Imports
-#-------------------------------------------------------------------------------
+#-----------------------------------------------------------------------------
 
 import objc
 import uuid
 
 from Foundation import NSObject, NSMutableArray, NSMutableDictionary,\
                         NSLog, NSNotificationCenter, NSMakeRange,\
                         NSLocalizedString, NSIntersectionRange
                         
 from AppKit import NSApplicationWillTerminateNotification, NSBeep,\
                     NSTextView, NSRulerView, NSVerticalRuler
 
 from pprint import saferepr
 
 import IPython
 from IPython.kernel.engineservice import EngineService, ThreadedEngineService
 from IPython.frontend.frontendbase import FrontEndBase
 
 from twisted.internet.threads import blockingCallFromThread
 from twisted.python.failure import Failure
 
-#-------------------------------------------------------------------------------
+#------------------------------------------------------------------------------
 # Classes to implement the Cocoa frontend
-#-------------------------------------------------------------------------------
+#------------------------------------------------------------------------------
 
 # TODO: 
-#   1. use MultiEngineClient and out-of-process engine rather than ThreadedEngineService?
+#   1. use MultiEngineClient and out-of-process engine rather than 
+#       ThreadedEngineService?
 #   2. integrate Xgrid launching of engines
         
     
 
 
 class IPythonCocoaController(NSObject, FrontEndBase):
     userNS = objc.ivar() #mirror of engine.user_ns (key=>str(value))
     waitingForEngine = objc.ivar().bool()
     textView = objc.IBOutlet()
     
     def init(self):
         self = super(IPythonCocoaController, self).init()
         FrontEndBase.__init__(self, engine=ThreadedEngineService())
         if(self != None):
             self._common_init()
         
         return self
     
     def _common_init(self):
         """_common_init"""
         
         self.userNS = NSMutableDictionary.dictionary()
         self.waitingForEngine = False
         
         self.lines = {}
         self.tabSpaces = 4
         self.tabUsesSpaces = True
         self.currentBlockID = self.nextBlockID()
         self.blockRanges = {} # blockID=>NSRange
     
     
     def awakeFromNib(self):
         """awakeFromNib"""
         
         self._common_init()
         
         # Start the IPython engine
         self.engine.startService()
         NSLog('IPython engine started')
         
         # Register for app termination
-        NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(self,
+        NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(
+                                        self,
                                                 'appWillTerminate:',
                                                  NSApplicationWillTerminateNotification,
                                                   None)
         
         self.textView.setDelegate_(self)
         self.textView.enclosingScrollView().setHasVerticalRuler_(True)
         self.verticalRulerView = NSRulerView.alloc().initWithScrollView_orientation_(
             self.textView.enclosingScrollView(),
             NSVerticalRuler)
         self.verticalRulerView.setClientView_(self.textView)
         self.startCLIForTextView()
     
     
     def appWillTerminate_(self, notification):
         """appWillTerminate"""
         
         self.engine.stopService()
     
     
     def complete(self, token):
         """Complete token in engine's user_ns
         
         Parameters
         ----------
         token : string
         
         Result
         ------
         Deferred result of ipython1.kernel.engineservice.IEngineInteractive.complete
         """
         
         return self.engine.complete(token)
     
     
     def execute(self, block, blockID=None):
         self.waitingForEngine = True
         self.willChangeValueForKey_('commandHistory')
         d = super(IPythonCocoaController, self).execute(block, blockID)
         d.addBoth(self._engineDone)
         d.addCallback(self._updateUserNS)
         
         return d
     
         
     def _engineDone(self, x):
         self.waitingForEngine = False
         self.didChangeValueForKey_('commandHistory')
         return x
     
     def _updateUserNS(self, result):
         """Update self.userNS from self.engine's namespace"""
         d = self.engine.keys()
         d.addCallback(self._getEngineNamepsaceValuesForKeys)
         
         return result
     
     
     def _getEngineNamepsaceValuesForKeys(self, keys):
         d = self.engine.pull(keys)
         d.addCallback(self._storeEngineNamespaceValues, keys=keys)
     
     
     def _storeEngineNamespaceValues(self, values, keys=[]):
         assert(len(values) == len(keys))
         self.willChangeValueForKey_('userNS')
         for (k,v) in zip(keys,values):
             self.userNS[k] = saferepr(v)
         self.didChangeValueForKey_('userNS')
     
     
     def startCLIForTextView(self):
         """Print banner"""
         
-        banner = """IPython1 %s -- An enhanced Interactive Python.""" % IPython.__version__
+        banner = """IPython1 %s -- An enhanced Interactive Python.""" % \
+                    IPython.__version__
         
         self.insert_text(banner + '\n\n')
     
     # NSTextView/IPythonTextView delegate methods
     def textView_doCommandBySelector_(self, textView, selector):
         assert(textView == self.textView)
         NSLog("textView_doCommandBySelector_: "+selector)
         
         
         if(selector == 'insertNewline:'):
             indent = self.currentIndentString()
             if(indent):
                 line = indent + self.currentLine()
             else:
                 line = self.currentLine()
             
             if(self.is_complete(self.currentBlock())):
                 self.execute(self.currentBlock(),
                                 blockID=self.currentBlockID)
                 self.startNewBlock()
                 
                 return True
             
             return False
         
         elif(selector == 'moveUp:'):
             prevBlock = self.get_history_previous(self.currentBlock())
             if(prevBlock != None):
                 self.replaceCurrentBlockWithString(textView, prevBlock)
             else:
                 NSBeep()
             return True
         
         elif(selector == 'moveDown:'):
             nextBlock = self.get_history_next()
             if(nextBlock != None):
                 self.replaceCurrentBlockWithString(textView, nextBlock)
             else:
                 NSBeep()
             return True
         
         elif(selector == 'moveToBeginningOfParagraph:'):
-            textView.setSelectedRange_(NSMakeRange(self.currentBlockRange().location, 0))
+            textView.setSelectedRange_(NSMakeRange(
+                                        self.currentBlockRange().location, 
+                                        0))
             return True
         elif(selector == 'moveToEndOfParagraph:'):
-            textView.setSelectedRange_(NSMakeRange(self.currentBlockRange().location + \
+            textView.setSelectedRange_(NSMakeRange(
+                                    self.currentBlockRange().location + \
                                                 self.currentBlockRange().length, 0))
             return True
         elif(selector == 'deleteToEndOfParagraph:'):
-            if(textView.selectedRange().location <= self.currentBlockRange().location):
+            if(textView.selectedRange().location <= \
+                self.currentBlockRange().location):
                 # Intersect the selected range with the current line range
                 if(self.currentBlockRange().length < 0):
                     self.blockRanges[self.currentBlockID].length = 0
             
                 r = NSIntersectionRange(textView.rangesForUserTextChange()[0],
                                         self.currentBlockRange())
                 
                 if(r.length > 0): #no intersection
                     textView.setSelectedRange_(r)
             
             return False # don't actually handle the delete
         
         elif(selector == 'insertTab:'):
             if(len(self.currentLine().strip()) == 0): #only white space
                 return False
             else:
                 self.textView.complete_(self)
                 return True
         
         elif(selector == 'deleteBackward:'):
             #if we're at the beginning of the current block, ignore
-            if(textView.selectedRange().location == self.currentBlockRange().location):
+            if(textView.selectedRange().location == \
+                self.currentBlockRange().location):
                 return True
             else:
                 self.currentBlockRange().length-=1
                 return False
         return False
     
     
-    def textView_shouldChangeTextInRanges_replacementStrings_(self, textView, ranges, replacementStrings):
+    def textView_shouldChangeTextInRanges_replacementStrings_(self, 
+        textView, ranges, replacementStrings):
         """
         Delegate method for NSTextView.
         
-        Refuse change text in ranges not at end, but make those changes at end.
+        Refuse change text in ranges not at end, but make those changes at 
+        end.
         """
         
-        #print 'textView_shouldChangeTextInRanges_replacementStrings_:',ranges,replacementStrings
         assert(len(ranges) == len(replacementStrings))
         allow = True
         for r,s in zip(ranges, replacementStrings):
             r = r.rangeValue()
             if(textView.textStorage().length() > 0 and
                     r.location < self.currentBlockRange().location):
                 self.insert_text(s)
                 allow = False
             
             
-            self.blockRanges.setdefault(self.currentBlockID, self.currentBlockRange()).length += len(s)
+            self.blockRanges.setdefault(self.currentBlockID, 
+                                        self.currentBlockRange()).length +=\
+                                         len(s)
         
         return allow
     
-    def textView_completions_forPartialWordRange_indexOfSelectedItem_(self, textView, words, charRange, index):
+    def textView_completions_forPartialWordRange_indexOfSelectedItem_(self, 
+        textView, words, charRange, index):
         try:
-            token = textView.textStorage().string().substringWithRange_(charRange)
+            ts = textView.textStorage()
+            token = ts.string().substringWithRange_(charRange)
             completions = blockingCallFromThread(self.complete, token)
         except:
             completions = objc.nil
             NSBeep()
         
         return (completions,0)
     
     
     def startNewBlock(self):
         """"""
         
         self.currentBlockID = self.nextBlockID()
     
     
     
     def nextBlockID(self):
         
         return uuid.uuid4()
     
     def currentBlockRange(self):
-        return self.blockRanges.get(self.currentBlockID, NSMakeRange(self.textView.textStorage().length(), 0))
+        return self.blockRanges.get(self.currentBlockID, 
+                        NSMakeRange(self.textView.textStorage().length(), 
+                        0))
     
     def currentBlock(self):
         """The current block's text"""
         
         return self.textForRange(self.currentBlockRange())
     
     def textForRange(self, textRange):
         """textForRange"""
         
-        return self.textView.textStorage().string().substringWithRange_(textRange)
+        ts = self.textView.textStorage()
+        return ts.string().substringWithRange_(textRange)
     
     def currentLine(self):
         block = self.textForRange(self.currentBlockRange())
         block = block.split('\n')
         return block[-1]
     
     def update_cell_prompt(self, result):
         if(isinstance(result, Failure)):
             blockID = result.blockID
         else:
             blockID = result['blockID']
         
         
         self.insert_text(self.input_prompt(result=result),
                         textRange=NSMakeRange(self.blockRanges[blockID].location,0),
                         scrollToVisible=False
                         )
         
         return result
     
     
     def render_result(self, result):
         blockID = result['blockID']
         inputRange = self.blockRanges[blockID]
         del self.blockRanges[blockID]
         
         #print inputRange,self.currentBlockRange()
         self.insert_text('\n' +
                         self.output_prompt(result) +
                         result.get('display',{}).get('pprint','') +
                         '\n\n',
-                        textRange=NSMakeRange(inputRange.location+inputRange.length, 0))
+                textRange=NSMakeRange(inputRange.location+inputRange.length,
+                                    0))
         return result
     
         
     def render_error(self, failure):
         self.insert_text('\n\n'+str(failure)+'\n\n')
         self.startNewBlock()
         return failure
     
     
     def insert_text(self, string=None, textRange=None, scrollToVisible=True):
-        """Insert text into textView at textRange, updating blockRanges as necessary"""
+        """Insert text into textView at textRange, updating blockRanges 
+        as necessary
+        """
         
         if(textRange == None):
             textRange = NSMakeRange(self.textView.textStorage().length(), 0) #range for end of text
         
         for r in self.blockRanges.itervalues():
             intersection = NSIntersectionRange(r,textRange)
             if(intersection.length == 0): #ranges don't intersect
                 if r.location >= textRange.location:
                     r.location += len(string)
             else: #ranges intersect
                 if(r.location <= textRange.location):
                     assert(intersection.length == textRange.length)
                     r.length += textRange.length
                 else:
                     r.location += intersection.length
         
         self.textView.replaceCharactersInRange_withString_(textRange, string) #textStorage().string()
         self.textView.setSelectedRange_(NSMakeRange(textRange.location+len(string), 0))
         if(scrollToVisible):
             self.textView.scrollRangeToVisible_(textRange)
         
     
     
     def replaceCurrentBlockWithString(self, textView, string):
         textView.replaceCharactersInRange_withString_(self.currentBlockRange(),
                                                         string)
         self.currentBlockRange().length = len(string)
         r = NSMakeRange(textView.textStorage().length(), 0)
         textView.scrollRangeToVisible_(r)
         textView.setSelectedRange_(r)
     
     
     def currentIndentString(self):
         """returns string for indent or None if no indent"""
         
         if(len(self.currentBlock()) > 0):
             lines = self.currentBlock().split('\n')
             currentIndent = len(lines[-1]) - len(lines[-1])
             if(currentIndent == 0):
                 currentIndent = self.tabSpaces
         
             if(self.tabUsesSpaces):
                 result = ' ' * currentIndent
             else:
                 result = '\t' * (currentIndent/self.tabSpaces)
         else:
             result = None
         
         return result
     
 

IPython/frontend/cocoa/tests/test_cocoa_frontend.py

@@ -1,77 +1,72 b''
 # encoding: utf-8
-"""This file contains unittests for the ipython1.frontend.cocoa.cocoa_frontend module.
-
-Things that should be tested:
-
- - IPythonCocoaController instantiates an IEngineInteractive
- - IPythonCocoaController executes code on the engine
- - IPythonCocoaController mirrors engine's user_ns
+"""This file contains unittests for the 
+IPython.frontend.cocoa.cocoa_frontend module.
 """
 __docformat__ = "restructuredtext en"
 
-#-------------------------------------------------------------------------------
-#       Copyright (C) 2005  Fernando Perez <[e-mail]>
-#                           Brian E Granger <[e-mail]>
-#                           Benjamin Ragan-Kelley <[e-mail]>
+#---------------------------------------------------------------------------
+#       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
-#-------------------------------------------------------------------------------
+#---------------------------------------------------------------------------
 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                                                
 
 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)
+        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)
     

IPython/frontend/frontendbase.py

@@ -1,326 +1,344 b''
 # encoding: utf-8
+# -*- test-case-name: IPython.frontend.tests.test_frontendbase -*-
 """
-frontendbase provides an interface and base class for GUI frontends for IPython.kernel/IPython.kernel.core.
+frontendbase provides an interface and base class for GUI frontends for 
+IPython.kernel/IPython.kernel.core.
 
 Frontend implementations will likely want to subclass FrontEndBase. 
 
 Author: Barry Wark
 """
 __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 string
 import uuid
 import _ast
 
 import zope.interface as zi
 
 from IPython.kernel.core.history import FrontEndHistory
 from IPython.kernel.core.util import Bunch
 from IPython.kernel.engineservice import IEngineCore
 
 from twisted.python.failure import Failure
 
 ##############################################################################
 # TEMPORARY!!! fake configuration, while we decide whether to use tconfig or
 # not
 
 rc = Bunch()
 rc.prompt_in1 = r'In [$number]:  '
 rc.prompt_in2 = r'...'
 rc.prompt_out = r'Out [$number]:  '
 
 ##############################################################################
 
 class IFrontEndFactory(zi.Interface):
     """Factory interface for frontends."""
     
     def __call__(engine=None, history=None):
         """
         Parameters:
         interpreter : IPython.kernel.engineservice.IEngineCore
         """
         
         pass
 
 
 
 class IFrontEnd(zi.Interface):
     """Interface for frontends. All methods return t.i.d.Deferred"""
     
-    zi.Attribute("input_prompt_template", "string.Template instance substituteable with execute result.")
-    zi.Attribute("output_prompt_template", "string.Template instance substituteable with execute result.")
-    zi.Attribute("continuation_prompt_template", "string.Template instance substituteable with execute result.")
+    zi.Attribute("input_prompt_template", "string.Template instance\
+                substituteable with execute result.")
+    zi.Attribute("output_prompt_template", "string.Template instance\
+                substituteable with execute result.")
+    zi.Attribute("continuation_prompt_template", "string.Template instance\
+                substituteable with execute result.")
     
     def update_cell_prompt(self, result):
         """Subclass may override to update the input prompt for a block. 
-        Since this method will be called as a twisted.internet.defer.Deferred's callback,
+        Since this method will be called as a 
+        twisted.internet.defer.Deferred's callback,
         implementations should return result when finished."""
         
         pass
     
     def render_result(self, result):
-        """Render the result of an execute call. Implementors may choose the method of rendering.
-        For example, a notebook-style frontend might render a Chaco plot inline.
+        """Render the result of an execute call. Implementors may choose the
+         method of rendering.
+        For example, a notebook-style frontend might render a Chaco plot 
+        inline.
         
         Parameters:
             result : dict (result of IEngineBase.execute )
         
         Result:
             Output of frontend rendering
         """
         
         pass
     
     def render_error(self, failure):
-        """Subclasses must override to render the failure. Since this method will be called as a 
-        twisted.internet.defer.Deferred's callback, implementations should return result 
-        when finished."""
+        """Subclasses must override to render the failure. Since this method 
+        ill be called as a twisted.internet.defer.Deferred's callback, 
+        implementations should return result when finished.
+        """
         
         pass
     
     
     def input_prompt(result={}):
-        """Returns the input prompt by subsituting into self.input_prompt_template"""
+        """Returns the input prompt by subsituting into 
+        self.input_prompt_template
+        """
         pass
     
     def output_prompt(result):
-        """Returns the output prompt by subsituting into self.output_prompt_template"""
+        """Returns the output prompt by subsituting into 
+        self.output_prompt_template
+        """
         
         pass
     
     def continuation_prompt():
-        """Returns the continuation prompt by subsituting into self.continuation_prompt_template"""
+        """Returns the continuation prompt by subsituting into 
+        self.continuation_prompt_template
+        """
         
         pass
     
     def is_complete(block):
         """Returns True if block is complete, False otherwise."""
         
         pass
     
     def compile_ast(block):
         """Compiles block to an _ast.AST"""
         
         pass
     
     
     def get_history_previous(currentBlock):
         """Returns the block previous in  the history. Saves currentBlock if
         the history_cursor is currently at the end of the input history"""
         pass
     
     def get_history_next():
         """Returns the next block in the history."""
         
         pass
     
 
 class FrontEndBase(object):
     """
     FrontEndBase manages the state tasks for a CLI frontend:
         - Input and output history management
         - Input/continuation and output prompt generation
         
     Some issues (due to possibly unavailable engine):
         - How do we get the current cell number for the engine?
         - How do we handle completions?
     """
     
     zi.implements(IFrontEnd)
     zi.classProvides(IFrontEndFactory)
     
     history_cursor = 0
     
     current_indent_level = 0
     
     
     input_prompt_template = string.Template(rc.prompt_in1)
     output_prompt_template = string.Template(rc.prompt_out)
     continuation_prompt_template = string.Template(rc.prompt_in2)
     
     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 input_prompt(self, result={}):
         """Returns the current input prompt
         
         It would be great to use ipython1.core.prompts.Prompt1 here
         """
         
         result.setdefault('number','')
         
         return self.input_prompt_template.safe_substitute(result)
     
     
     def continuation_prompt(self):
         """Returns the current continuation prompt"""
         
         return self.continuation_prompt_template.safe_substitute()
     
     def output_prompt(self, result):
         """Returns the output prompt for result"""
         
         return self.output_prompt_template.safe_substitute(result)
     
     
     def is_complete(self, block):
         """Determine if block is complete.
         
         Parameters
         block : string
         
         Result 
         True if block can be sent to the engine without compile errors.
         False otherwise.
         """
         
         try:
             ast = self.compile_ast(block)
         except:
             return False
         
         lines = block.split('\n')
         return (len(lines)==1 or str(lines[-1])=='')
     
     
     def compile_ast(self, block):
         """Compile block to an AST
         
         Parameters:
             block : str
         
         Result:
             AST
         
         Throws:
             Exception if block cannot be compiled
         """
         
         return compile(block, "<string>", "exec", _ast.PyCF_ONLY_AST)
     
     
     def execute(self, block, blockID=None):
         """Execute the block and return result.
         
         Parameters:
             block : {str, AST}
             blockID : any
-                Caller may provide an ID to identify this block. result['blockID'] := blockID
+                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.addBoth(self._add_block_id, blockID)
         d.addBoth(self.update_cell_prompt)
         d.addCallbacks(self.render_result, errback=self.render_error)
         
         return d
     
     
     def _add_block_id(self, result, blockID):
-        """Add the blockID to result or failure. Unfortunatley, we have to treat failures
-        differently than result dicts
+        """Add the blockID to result or failure. Unfortunatley, we have to 
+        treat failures differently than result dicts.
         """
         
         if(isinstance(result, Failure)):
             result.blockID = blockID
         else:
             result['blockID'] = blockID
         
         return result
     
     def _add_history(self, result, block=None):
         """Add block to the history"""
         
         assert(block != None)
         self.history.add_items([block])
         self.history_cursor += 1
         
         return result
     
     
     def get_history_previous(self, currentBlock):
         """ Returns previous history string and decrement history cursor.
         """
         command = self.history.get_history_item(self.history_cursor - 1)
         
         if command is not None:
             if(self.history_cursor == len(self.history.input_cache)):
                 self.history.input_cache[self.history_cursor] = currentBlock
             self.history_cursor -= 1
         return command
     
     
     def get_history_next(self):
         """ Returns next history string and increment history cursor.
         """
         command = self.history.get_history_item(self.history_cursor+1)
         
         if command is not None:
             self.history_cursor += 1
         return command
     
     ###
     # Subclasses probably want to override these methods...
     ###
     
     def update_cell_prompt(self, result):
         """Subclass may override to update the input prompt for a block. 
-        Since this method will be called as a twisted.internet.defer.Deferred's callback,
-        implementations should return result when finished.
+        Since this method will be called as a 
+        twisted.internet.defer.Deferred's callback, implementations should 
+        return result when finished.
         
-        NP: result is a failure if the execute returned a failre. To get the blockID, you should
-        do something like::
+        NP: result is a failure if the execute returned a failre. 
+        To get the blockID, you should do something like::
             if(isinstance(result, twisted.python.failure.Failure)):
                 blockID = result.blockID
             else:
                 blockID = result['blockID']
             
         
         """
         
         return result
     
     
     def render_result(self, result):
-        """Subclasses must override to render result. Since this method will be called as a 
-        twisted.internet.defer.Deferred's callback, implementations should return result 
-        when finished."""
+        """Subclasses must override to render result. Since this method will
+        be called as a twisted.internet.defer.Deferred's callback, 
+        implementations should return result when finished.
+        """
         
         return result
     
     
     def render_error(self, failure):
-        """Subclasses must override to render the failure. Since this method will be called as a 
-        twisted.internet.defer.Deferred's callback, implementations should return result 
-        when finished."""
+        """Subclasses must override to render the failure. Since this method 
+        will be called as a twisted.internet.defer.Deferred's callback, 
+        implementations should return result when finished."""
         
         return failure
     
 
 

IPython/frontend/tests/test_frontendbase.py

@@ -1,149 +1,151 b''
 # 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
 from IPython.frontend import frontendbase
 from IPython.kernel.engineservice import EngineService
 
 class FrontEndCallbackChecker(frontendbase.FrontEndBase):
     """FrontEndBase subclass for checking callbacks"""
     def __init__(self, engine=None, history=None):
-        super(FrontEndCallbackChecker, self).__init__(engine=engine, history=history)
+        super(FrontEndCallbackChecker, self).__init__(engine=engine, 
+                                                    history=history)
         self.updateCalled = False
         self.renderResultCalled = False
         self.renderErrorCalled = False
     
     def update_cell_prompt(self, result):
         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 TestFrontendBase(unittest.TestCase):
     def setUp(self):
         """Setup the EngineService and FrontEndBase"""
         
         self.fb = FrontEndCallbackChecker(engine=EngineService())
     
     
     def test_implements_IFrontEnd(self):
-        assert(frontendbase.IFrontEnd.implementedBy(frontendbase.FrontEndBase))
+        assert(frontendbase.IFrontEnd.implementedBy(
+                                                frontendbase.FrontEndBase))
     
     
     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/engineservice.py

@@ -1,874 +1,876 b''
 # encoding: utf-8
 # -*- test-case-name: IPython.kernel.tests.test_engineservice -*-
 
 """A Twisted Service Representation of the IPython core.
 
 The IPython Core exposed to the network is called the Engine.  Its
 representation in Twisted in the EngineService.  Interfaces and adapters
 are used to abstract out the details of the actual network protocol used.
 The EngineService is an Engine that knows nothing about the actual protocol
 used.
 
 The EngineService is exposed with various network protocols in modules like:
 
 enginepb.py
 enginevanilla.py
 
 As of 12/12/06 the classes in this module have been simplified greatly.  It was 
 felt that we had over-engineered things.  To improve the maintainability of the
 code we have taken out the ICompleteEngine interface and the completeEngine
 method that automatically added methods to engines.
 
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import os, sys, copy
 import cPickle as pickle
 from new import instancemethod
 
 from twisted.application import service
 from twisted.internet import defer, reactor
 from twisted.python import log, failure, components
 import zope.interface as zi
 
 from IPython.kernel.core.interpreter import Interpreter
 from IPython.kernel import newserialized, error, util
 from IPython.kernel.util import printer
 from IPython.kernel.twistedutil import gatherBoth, DeferredList
 from IPython.kernel import codeutil
 
 
 #-------------------------------------------------------------------------------
 # Interface specification for the Engine
 #-------------------------------------------------------------------------------
 
 class IEngineCore(zi.Interface):
     """The minimal required interface for the IPython Engine.
     
     This interface provides a formal specification of the IPython core.
     All these methods should return deferreds regardless of what side of a
     network connection they are on.
     
     In general, this class simply wraps a shell class and wraps its return
     values as Deferred objects.  If the underlying shell class method raises
     an exception, this class should convert it to a twisted.failure.Failure
     that will be propagated along the Deferred's errback chain.
     
     In addition, Failures are aggressive.  By this, we mean that if a method
     is performing multiple actions (like pulling multiple object) if any
     single one fails, the entire method will fail with that Failure.  It is
     all or nothing. 
     """
     
     id = zi.interface.Attribute("the id of the Engine object")
     properties = zi.interface.Attribute("A dict of properties of the Engine")
     
     def execute(lines):
         """Execute lines of Python code.
         
         Returns a dictionary with keys (id, number, stdin, stdout, stderr)
         upon success.
         
         Returns a failure object if the execution of lines raises an exception.
         """
     
     def push(namespace):
         """Push dict namespace into the user's namespace.
         
         Returns a deferred to None or a failure.
         """
     
     def pull(keys):
         """Pulls values out of the user's namespace by keys.
         
         Returns a deferred to a tuple objects or a single object.
         
         Raises NameError if any one of objects doess not exist.
         """
     
     def push_function(namespace):
         """Push a dict of key, function pairs into the user's namespace.
         
         Returns a deferred to None or a failure."""
     
     def pull_function(keys):
         """Pulls functions out of the user's namespace by keys.
         
         Returns a deferred to a tuple of functions or a single function.
         
         Raises NameError if any one of the functions does not exist.
         """
     
     def get_result(i=None):
         """Get the stdin/stdout/stderr of command i.
         
         Returns a deferred to a dict with keys
         (id, number, stdin, stdout, stderr).
         
         Raises IndexError if command i does not exist.
         Raises TypeError if i in not an int.
         """
     
     def reset():
         """Reset the shell.
         
         This clears the users namespace.  Won't cause modules to be
         reloaded.  Should also re-initialize certain variables like id.
         """
     
     def kill():
         """Kill the engine by stopping the reactor."""
     
     def keys():
         """Return the top level variables in the users namspace.
         
         Returns a deferred to a dict."""
     
 
 class IEngineSerialized(zi.Interface):
     """Push/Pull methods that take Serialized objects.  
     
     All methods should return deferreds.
     """
     
     def push_serialized(namespace):
         """Push a dict of keys and Serialized objects into the user's namespace."""
     
     def pull_serialized(keys):
         """Pull objects by key from the user's namespace as Serialized.
         
         Returns a list of or one Serialized.
         
         Raises NameError is any one of the objects does not exist.
         """
     
 
 class IEngineProperties(zi.Interface):
     """Methods for access to the properties object of an Engine"""
     
     properties = zi.Attribute("A StrictDict object, containing the properties")
     
     def set_properties(properties):
         """set properties by key and value"""
     
     def get_properties(keys=None):
         """get a list of properties by `keys`, if no keys specified, get all"""
     
     def del_properties(keys):
         """delete properties by `keys`"""
     
     def has_properties(keys):
         """get a list of bool values for whether `properties` has `keys`"""
 
     def clear_properties():
         """clear the properties dict"""
     
 class IEngineBase(IEngineCore, IEngineSerialized, IEngineProperties):
     """The basic engine interface that EngineService will implement.
     
     This exists so it is easy to specify adapters that adapt to and from the
     API that the basic EngineService implements.
     """
     pass
 
 class IEngineQueued(IEngineBase):
     """Interface for adding a queue to an IEngineBase.  
     
     This interface extends the IEngineBase interface to add methods for managing
     the engine's queue.  The implicit details of this interface are that the 
     execution of all methods declared in IEngineBase should appropriately be
     put through a queue before execution. 
     
     All methods should return deferreds.
     """
     
     def clear_queue():
         """Clear the queue."""
     
     def queue_status():
         """Get the queued and pending commands in the queue."""
     
     def register_failure_observer(obs):
         """Register an observer of pending Failures.
         
         The observer must implement IFailureObserver.
         """
     
     def unregister_failure_observer(obs):
         """Unregister an observer of pending Failures."""
     
 
 class IEngineThreaded(zi.Interface):
     """A place holder for threaded commands.  
     
     All methods should return deferreds.
     """
     pass
 
 
 #-------------------------------------------------------------------------------
 # Functions and classes to implement the EngineService
 #-------------------------------------------------------------------------------
 
 
 class StrictDict(dict):
     """This is a strict copying dictionary for use as the interface to the 
     properties of an Engine.
     :IMPORTANT:
         This object copies the values you set to it, and returns copies to you
         when you request them.  The only way to change properties os explicitly
         through the setitem and getitem of the dictionary interface.
         Example:
         >>> e = kernel.get_engine(id)
         >>> L = someList
         >>> e.properties['L'] = L
         >>> L == e.properties['L']
         ... True
         >>> L.append(something Else)
         >>> L == e.properties['L']
         ... False
         
         getitem copies, so calls to methods of objects do not affect the
         properties, as in the following example:
         >>> e.properties[1] = range(2)
         >>> print e.properties[1]
         ... [0, 1]
         >>> e.properties[1].append(2)
         >>> print e.properties[1]
         ... [0, 1]
         
     """
     def __init__(self, *args, **kwargs):
         dict.__init__(self, *args, **kwargs)
         self.modified = True
     
     def __getitem__(self, key):
         return copy.deepcopy(dict.__getitem__(self, key))
     
     def __setitem__(self, key, value):
         # check if this entry is valid for transport around the network
         # and copying
         try:
             pickle.dumps(key, 2)
             pickle.dumps(value, 2)
             newvalue = copy.deepcopy(value)
         except:
             raise error.InvalidProperty(value)
         dict.__setitem__(self, key, newvalue)
         self.modified = True
     
     def __delitem__(self, key):
         dict.__delitem__(self, key)
         self.modified = True
     
     def update(self, dikt):
         for k,v in dikt.iteritems():
             self[k] = v
     
     def pop(self, key):
         self.modified = True
         return dict.pop(self, key)
     
     def popitem(self):
         self.modified = True
         return dict.popitem(self)
     
     def clear(self):
         self.modified = True
         dict.clear(self)
     
     def subDict(self, *keys):
         d = {}
         for key in keys:
             d[key] = self[key]
         return d
     
 
 
 class EngineAPI(object):
     """This is the object through which the user can edit the `properties`
     attribute of an Engine.
     The Engine Properties object copies all object in and out of itself.
     See the EngineProperties object for details.
     """
     _fix=False
     def __init__(self, id):
         self.id = id
         self.properties = StrictDict()
         self._fix=True
     
     def __setattr__(self, k,v):
         if self._fix:
             raise error.KernelError("I am protected!")
         else:
             object.__setattr__(self, k, v)
     
     def __delattr__(self, key):
         raise error.KernelError("I am protected!")
     
 
 _apiDict = {}
 
 def get_engine(id):
     """Get the Engine API object, whcih currently just provides the properties 
     object, by ID"""
     global _apiDict
     if not _apiDict.get(id):
         _apiDict[id] = EngineAPI(id)
     return _apiDict[id]
 
 def drop_engine(id):
     """remove an engine"""
     global _apiDict
     if _apiDict.has_key(id):
         del _apiDict[id]
 
 class EngineService(object, service.Service):
     """Adapt a IPython shell into a IEngine implementing Twisted Service."""
     
     zi.implements(IEngineBase)
     name = 'EngineService'
     
     def __init__(self, shellClass=Interpreter, mpi=None):
         """Create an EngineService.
         
         shellClass: something that implements IInterpreter or core1
         mpi:        an mpi module that has rank and size attributes
         """
         self.shellClass = shellClass
         self.shell = self.shellClass()
         self.mpi = mpi
         self.id = None
         self.properties = get_engine(self.id).properties
         if self.mpi is not None:
             log.msg("MPI started with rank = %i and size = %i" % 
                 (self.mpi.rank, self.mpi.size))
             self.id = self.mpi.rank
         self._seedNamespace()
     
     # Make id a property so that the shell can get the updated id
         
     def _setID(self, id):
         self._id = id
         self.properties = get_engine(id).properties
         self.shell.push({'id': id})
     
     def _getID(self):
         return self._id
     
     id = property(_getID, _setID)
     
     def _seedNamespace(self):
         self.shell.push({'mpi': self.mpi, 'id' : self.id})
     
     def executeAndRaise(self, msg, callable, *args, **kwargs):
         """Call a method of self.shell and wrap any exception."""
         d = defer.Deferred()
         try:
             result = callable(*args, **kwargs)
         except:
             # This gives the following:
             # et=exception class
             # ev=exception class instance
             # tb=traceback object
             et,ev,tb = sys.exc_info()
             # This call adds attributes to the exception value
             et,ev,tb = self.shell.formatTraceback(et,ev,tb,msg)
             # Add another attribute
             ev._ipython_engine_info = msg
             f = failure.Failure(ev,et,None)
             d.errback(f)
         else:
             d.callback(result)
             
         return d
     
     # The IEngine methods.  See the interface for documentation.
     
     def execute(self, lines):
         msg = {'engineid':self.id,
                'method':'execute',
                'args':[lines]}
         d = self.executeAndRaise(msg, self.shell.execute, lines)
         d.addCallback(self.addIDToResult)
         return d
     
     def addIDToResult(self, result):
         result['id'] = self.id
         return result
     
     def push(self, namespace):
         msg = {'engineid':self.id,
                'method':'push',
                'args':[repr(namespace.keys())]}
         d = self.executeAndRaise(msg, self.shell.push, namespace)
         return d
     
     def pull(self, keys):
         msg = {'engineid':self.id,
                'method':'pull',
                'args':[repr(keys)]}
         d = self.executeAndRaise(msg, self.shell.pull, keys)
         return d
     
     def push_function(self, namespace):
         msg = {'engineid':self.id,
                'method':'push_function',
                'args':[repr(namespace.keys())]}
         d = self.executeAndRaise(msg, self.shell.push_function, namespace)
         return d
     
     def pull_function(self, keys):
         msg = {'engineid':self.id,
                'method':'pull_function',
                'args':[repr(keys)]}
         d = self.executeAndRaise(msg, self.shell.pull_function, keys)
         return d
     
     def get_result(self, i=None):
         msg = {'engineid':self.id,
                'method':'get_result',
                'args':[repr(i)]}
         d = self.executeAndRaise(msg, self.shell.getCommand, i)
         d.addCallback(self.addIDToResult)
         return d
     
     def reset(self):
         msg = {'engineid':self.id,
                'method':'reset',
                'args':[]}
         del self.shell
         self.shell = self.shellClass()
         self.properties.clear()
         d = self.executeAndRaise(msg, self._seedNamespace)
         return d
     
     def kill(self):
         drop_engine(self.id)
         try:
             reactor.stop()
         except RuntimeError:
             log.msg('The reactor was not running apparently.')
             return defer.fail()
         else:
             return defer.succeed(None)
     
     def keys(self):
         """Return a list of variables names in the users top level namespace.
         
         This used to return a dict of all the keys/repr(values) in the 
         user's namespace.  This was too much info for the ControllerService
         to handle so it is now just a list of keys.
         """
         
         remotes = []
         for k in self.shell.user_ns.iterkeys():
             if k not in ['__name__', '_ih', '_oh', '__builtins__',
                          'In', 'Out', '_', '__', '___', '__IP', 'input', 'raw_input']:
                 remotes.append(k)
         return defer.succeed(remotes)
     
     def set_properties(self, properties):
         msg = {'engineid':self.id,
                'method':'set_properties',
                'args':[repr(properties.keys())]}
         return self.executeAndRaise(msg, self.properties.update, properties)
     
     def get_properties(self, keys=None):
         msg = {'engineid':self.id,
                'method':'get_properties',
                'args':[repr(keys)]}
         if keys is None:
             keys = self.properties.keys()
         return self.executeAndRaise(msg, self.properties.subDict, *keys)
     
     def _doDel(self, keys):
         for key in keys:
             del self.properties[key]
     
     def del_properties(self, keys):
         msg = {'engineid':self.id,
                'method':'del_properties',
                'args':[repr(keys)]}
         return self.executeAndRaise(msg, self._doDel, keys)
     
     def _doHas(self, keys):
         return [self.properties.has_key(key) for key in keys]
     
     def has_properties(self, keys):
         msg = {'engineid':self.id,
                'method':'has_properties',
                'args':[repr(keys)]}
         return self.executeAndRaise(msg, self._doHas, keys)
     
     def clear_properties(self):
         msg = {'engineid':self.id,
                'method':'clear_properties',
                'args':[]}
         return self.executeAndRaise(msg, self.properties.clear)
     
     def push_serialized(self, sNamespace):
         msg = {'engineid':self.id,
                'method':'push_serialized',
                'args':[repr(sNamespace.keys())]}       
         ns = {}
         for k,v in sNamespace.iteritems():
             try:
                 unserialized = newserialized.IUnSerialized(v)
                 ns[k] = unserialized.getObject()
             except:
                 return defer.fail()
         return self.executeAndRaise(msg, self.shell.push, ns)
     
     def pull_serialized(self, keys):
         msg = {'engineid':self.id,
                'method':'pull_serialized',
                'args':[repr(keys)]}
         if isinstance(keys, str):
             keys = [keys]
         if len(keys)==1:
             d = self.executeAndRaise(msg, self.shell.pull, keys)
             d.addCallback(newserialized.serialize)
             return d
         elif len(keys)>1:
             d = self.executeAndRaise(msg, self.shell.pull, keys)         
             @d.addCallback
             def packThemUp(values):
                 serials = []
                 for v in values:
                     try:
                         serials.append(newserialized.serialize(v))
                     except:
                         return defer.fail(failure.Failure())
                 return serials
             return packThemUp
 
 
 def queue(methodToQueue):
     def queuedMethod(this, *args, **kwargs):
         name = methodToQueue.__name__
         return this.submitCommand(Command(name, *args, **kwargs))
     return queuedMethod
     
 class QueuedEngine(object):
     """Adapt an IEngineBase to an IEngineQueued by wrapping it.
     
     The resulting object will implement IEngineQueued which extends
     IEngineCore which extends (IEngineBase, IEngineSerialized). 
     
     This seems like the best way of handling it, but I am not sure.  The
     other option is to have the various base interfaces be used like
     mix-in intefaces.  The problem I have with this is adpatation is
     more difficult and complicated because there can be can multiple
     original and final Interfaces. 
     """
     
     zi.implements(IEngineQueued)
     
     def __init__(self, engine):
         """Create a QueuedEngine object from an engine
         
         engine:       An implementor of IEngineCore and IEngineSerialized
         keepUpToDate: whether to update the remote status when the 
                       queue is empty.  Defaults to False.
         """
         
         # This is the right way to do these tests rather than 
         # IEngineCore in list(zi.providedBy(engine)) which will only 
         # picks of the interfaces that are directly declared by engine.
         assert IEngineBase.providedBy(engine), \
             "engine passed to QueuedEngine doesn't provide IEngineBase"
             
         self.engine = engine
         self.id = engine.id
         self.queued = []
         self.history = {}
         self.engineStatus = {}
         self.currentCommand = None
         self.failureObservers = []
     
     def _get_properties(self):
         return self.engine.properties
     
     properties = property(_get_properties, lambda self, _: None)
     # Queue management methods.  You should not call these directly
     
     def submitCommand(self, cmd):
         """Submit command to queue."""
         
         d = defer.Deferred()
         cmd.setDeferred(d)
         if self.currentCommand is not None:
             if self.currentCommand.finished:
                 # log.msg("Running command immediately: %r" % cmd)
                 self.currentCommand = cmd
                 self.runCurrentCommand()
             else:  # command is still running  
                 # log.msg("Command is running: %r" % self.currentCommand)
                 # log.msg("Queueing: %r" % cmd)
                 self.queued.append(cmd)
         else:
             # log.msg("No current commands, running: %r" % cmd)
             self.currentCommand = cmd
             self.runCurrentCommand()
         return d
     
     def runCurrentCommand(self):
         """Run current command."""
         
         cmd = self.currentCommand
         f = getattr(self.engine, cmd.remoteMethod, None)
         if f:
             d = f(*cmd.args, **cmd.kwargs)
             if cmd.remoteMethod is 'execute':
                 d.addCallback(self.saveResult)
             d.addCallback(self.finishCommand)
             d.addErrback(self.abortCommand)
         else:
             return defer.fail(AttributeError(cmd.remoteMethod))
     
     def _flushQueue(self):
         """Pop next command in queue and run it."""
         
         if len(self.queued) > 0:
             self.currentCommand = self.queued.pop(0)
             self.runCurrentCommand()
     
     def saveResult(self, result):
         """Put the result in the history."""
         self.history[result['number']] = result
         return result
     
     def finishCommand(self, result):
         """Finish currrent command."""
         
         # The order of these commands is absolutely critical.
         self.currentCommand.handleResult(result)
         self.currentCommand.finished = True
         self._flushQueue()
         return result
     
     def abortCommand(self, reason):
         """Abort current command.
         
         This eats the Failure but first passes it onto the Deferred that the 
         user has.
         
         It also clear out the queue so subsequence commands don't run.
         """
 
         # The order of these 3 commands is absolutely critical.  The currentCommand
         # must first be marked as finished BEFORE the queue is cleared and before
         # the current command is sent the failure.
         # Also, the queue must be cleared BEFORE the current command is sent the Failure
         # otherwise the errback chain could trigger new commands to be added to the 
         # queue before we clear it.  We should clear ONLY the commands that were in
         # the queue when the error occured. 
         self.currentCommand.finished = True
         s = "%r %r %r" % (self.currentCommand.remoteMethod, self.currentCommand.args, self.currentCommand.kwargs)
         self.clear_queue(msg=s)
         self.currentCommand.handleError(reason)
         
         return None
     
     #---------------------------------------------------------------------------
     # IEngineCore methods
     #---------------------------------------------------------------------------
     
     @queue
     def execute(self, lines):
         pass
 
     @queue
     def push(self, namespace):
         pass      
     
     @queue
     def pull(self, keys):
         pass
         
     @queue
     def push_function(self, namespace):
         pass      
     
     @queue
     def pull_function(self, keys):
         pass        
 
     def get_result(self, i=None):
         if i is None:
             i = max(self.history.keys()+[None])
 
         cmd = self.history.get(i, None)
         # Uncomment this line to disable chaching of results
         #cmd = None
         if cmd is None:
             return self.submitCommand(Command('get_result', i))
         else:
             return defer.succeed(cmd)
         
     def reset(self):
         self.clear_queue()
         self.history = {}  # reset the cache - I am not sure we should do this
         return self.submitCommand(Command('reset'))
     
     def kill(self):
         self.clear_queue()
         return self.submitCommand(Command('kill'))
     
     @queue
     def keys(self):
         pass
     
     #---------------------------------------------------------------------------
     # IEngineSerialized methods
     #---------------------------------------------------------------------------
 
     @queue
     def push_serialized(self, namespace):
         pass
         
     @queue
     def pull_serialized(self, keys):
         pass
     
     #---------------------------------------------------------------------------
     # IEngineProperties methods
     #---------------------------------------------------------------------------
 
     @queue
     def set_properties(self, namespace):
         pass
         
     @queue
     def get_properties(self, keys=None):
         pass
     
     @queue
     def del_properties(self, keys):
         pass
     
     @queue
     def has_properties(self, keys):
         pass
     
     @queue
     def clear_properties(self):
         pass
     
     #---------------------------------------------------------------------------
     # IQueuedEngine methods
     #---------------------------------------------------------------------------
     
     def clear_queue(self, msg=''):
         """Clear the queue, but doesn't cancel the currently running commmand."""
         
         for cmd in self.queued:
             cmd.deferred.errback(failure.Failure(error.QueueCleared(msg)))
         self.queued = []
         return defer.succeed(None)
     
     def queue_status(self):
         if self.currentCommand is not None:
             if self.currentCommand.finished:
                 pending = repr(None)
             else:
                 pending = repr(self.currentCommand)
         else:
             pending = repr(None)
         dikt = {'queue':map(repr,self.queued), 'pending':pending}
         return defer.succeed(dikt)
         
     def register_failure_observer(self, obs):
         self.failureObservers.append(obs)
     
     def unregister_failure_observer(self, obs):
         self.failureObservers.remove(obs)
     
 
 # Now register QueuedEngine as an adpater class that makes an IEngineBase into a
 # IEngineQueued.  
 components.registerAdapter(QueuedEngine, IEngineBase, IEngineQueued)
     
 
 class Command(object):
     """A command object that encapslates queued commands.
     
     This class basically keeps track of a command that has been queued
     in a QueuedEngine.  It manages the deferreds and hold the method to be called
     and the arguments to that method.
     """
     
     
     def __init__(self, remoteMethod, *args, **kwargs):
         """Build a new Command object."""
         
         self.remoteMethod = remoteMethod
         self.args = args
         self.kwargs = kwargs
         self.finished = False
     
     def setDeferred(self, d):
         """Sets the deferred attribute of the Command."""  
           
         self.deferred = d
     
     def __repr__(self):
         if not self.args:
             args = ''
         else:
             args = str(self.args)[1:-2]  #cut off (...,)
         for k,v in self.kwargs.iteritems():
             if args:
                 args += ', '
             args += '%s=%r' %(k,v)
         return "%s(%s)" %(self.remoteMethod, args)
     
     def handleResult(self, result):
         """When the result is ready, relay it to self.deferred."""
         
         self.deferred.callback(result)
     
     def handleError(self, reason):
         """When an error has occured, relay it to self.deferred."""
         
         self.deferred.errback(reason)
 
 class ThreadedEngineService(EngineService):
-    """An EngineService subclass that defers execute commands to a separate thread.
+    """An EngineService subclass that defers execute commands to a separate 
+    thread.
     
-    ThreadedEngineService uses twisted.internet.threads.deferToThread to defer execute
-    requests to a separate thread. GUI frontends may want to use ThreadedEngineService as
-    the engine in an IPython.frontend.frontendbase.FrontEndBase subclass to prevent
+    ThreadedEngineService uses twisted.internet.threads.deferToThread to 
+    defer execute requests to a separate thread. GUI frontends may want to 
+    use ThreadedEngineService as the engine in an 
+    IPython.frontend.frontendbase.FrontEndBase subclass to prevent
     block execution from blocking the GUI thread.
     """
     
     zi.implements(IEngineBase)
 
     def __init__(self, shellClass=Interpreter, mpi=None):
         EngineService.__init__(self, shellClass, mpi)
     
     
     def execute(self, lines):
         # Only import this if we are going to use this class
         from twisted.internet import threads
         
         msg = {'engineid':self.id,
                'method':'execute',
                'args':[lines]}
         
         d = threads.deferToThread(self.shell.execute, lines)
         d.addCallback(self.addIDToResult)
         return d