ready for wrapped_execute

IPython/frontend/cocoa/cocoa_frontend.py

@@ -1,505 +1,479 b''
 # encoding: utf-8
 # -*- test-case-name: IPython.frontend.cocoa.tests.test_cocoa_frontend -*-
 
 """PyObjC classes to provide a Cocoa frontend to the 
 IPython.kernel.engineservice.IEngineBase.
 
 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.
 
 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 sys
 import objc
 import uuid
 
 from Foundation import NSObject, NSMutableArray, NSMutableDictionary,\
                         NSLog, NSNotificationCenter, NSMakeRange,\
                         NSLocalizedString, NSIntersectionRange,\
                         NSString, NSAutoreleasePool
                         
 from AppKit import NSApplicationWillTerminateNotification, NSBeep,\
                     NSTextView, NSRulerView, NSVerticalRuler
 
 from pprint import saferepr
 
 import IPython
 from IPython.kernel.engineservice import ThreadedEngineService
 from IPython.frontend.frontendbase import AsyncFrontEndBase
 
 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?
 #   2. integrate Xgrid launching of engines
         
 class AutoreleasePoolWrappedThreadedEngineService(ThreadedEngineService):
     """Wrap all blocks in an NSAutoreleasePool"""
     
     def wrapped_execute(self, msg, lines):
         """wrapped_execute"""
         try:
             p = NSAutoreleasePool.alloc().init()
-            result = self.shell.execute(lines)
-        except Exception,e:
-            # 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
-            
-            # Create a new exception with the new attributes
-            e = et(ev._ipython_traceback_text)
-            e._ipython_engine_info = msg
-            
-            # Re-raise
-            raise e
+            result = super(AutoreleasePoolWrappedThreadedEngineService,
+                            self).wrapped_execute(msg, lines)
         finally:
             p.drain()
         
         return result
     
-    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.wrapped_execute, msg, lines)
-        d.addCallback(self.addIDToResult)
-        return d
 
 
 class IPythonCocoaController(NSObject, AsyncFrontEndBase):
     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()
         AsyncFrontEndBase.__init__(self,
                     engine=AutoreleasePoolWrappedThreadedEngineService())
         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.next_block_ID()
         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
         nc = NSNotificationCenter.defaultCenter()
         nc.addObserver_selector_name_object_(
                                     self,
                                     'appWillTerminate:',
                                     NSApplicationWillTerminateNotification,
                                     None)
         
         self.textView.setDelegate_(self)
         self.textView.enclosingScrollView().setHasVerticalRuler_(True)
         r = NSRulerView.alloc().initWithScrollView_orientation_(
                                         self.textView.enclosingScrollView(),
                                         NSVerticalRuler)
         self.verticalRulerView = r
         self.verticalRulerView.setClientView_(self.textView)
         self._start_cli_banner()
     
     
     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 
         IPython.kernel.engineservice.IEngineBase.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._engine_done)
         d.addCallback(self._update_user_ns)
         
         return d
     
     
     def push_(self, namespace):
         """Push dictionary of key=>values to python namespace"""
         
         self.waitingForEngine = True
         self.willChangeValueForKey_('commandHistory')
         d = self.engine.push(namespace)
         d.addBoth(self._engine_done)
         d.addCallback(self._update_user_ns)
     
     
     def pull_(self, keys):
         """Pull keys from python namespace"""
         
         self.waitingForEngine = True
         result = blockingCallFromThread(self.engine.pull, keys)
         self.waitingForEngine = False
     
     @objc.signature('v@:@I')
     def executeFileAtPath_encoding_(self, path, encoding):
         """Execute file at path in an empty namespace. Update the engine
         user_ns with the resulting locals."""
         
         lines,err = NSString.stringWithContentsOfFile_encoding_error_(
             path,
             encoding,
             None)
         self.engine.execute(lines)
     
     
     def _engine_done(self, x):
         self.waitingForEngine = False
         self.didChangeValueForKey_('commandHistory')
         return x
     
     def _update_user_ns(self, result):
         """Update self.userNS from self.engine's namespace"""
         d = self.engine.keys()
         d.addCallback(self._get_engine_namespace_values_for_keys)
         
         return result
     
     
     def _get_engine_namespace_values_for_keys(self, keys):
         d = self.engine.pull(keys)
         d.addCallback(self._store_engine_namespace_values, keys=keys)
     
     
     def _store_engine_namespace_values(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 update_cell_prompt(self, result, blockID=None):
         if(isinstance(result, Failure)):
             self.insert_text(self.input_prompt(),
                 textRange=NSMakeRange(self.blockRanges[blockID].location,0),
                 scrollToVisible=False
                 )
         else:
             self.insert_text(self.input_prompt(number=result['number']),
                 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.current_block_range()
         self.insert_text('\n' +
                 self.output_prompt(number=result['number']) +
                 result.get('display',{}).get('pprint','') +
                 '\n\n',
                 textRange=NSMakeRange(inputRange.location+inputRange.length,
                                     0))
         return result
     
         
     def render_error(self, failure):
         self.insert_text('\n' +
                         self.output_prompt() +
                         '\n' +
                         failure.getErrorMessage() +
                         '\n\n')
         self.start_new_block()
         return failure
     
     
     def _start_cli_banner(self):
         """Print banner"""
         
         banner = """IPython1 %s -- An enhanced Interactive Python.""" % \
                     IPython.__version__
         
         self.insert_text(banner + '\n\n')
     
     
     def start_new_block(self):
         """"""
         
         self.currentBlockID = self.next_block_ID()
     
     
     
     def next_block_ID(self):
         
         return uuid.uuid4()
     
     def current_block_range(self):
         return self.blockRanges.get(self.currentBlockID, 
                         NSMakeRange(self.textView.textStorage().length(), 
                         0))
     
     def current_block(self):
         """The current block's text"""
         
         return self.text_for_range(self.current_block_range())
     
     def text_for_range(self, textRange):
         """text_for_range"""
         
         ts = self.textView.textStorage()
         return ts.string().substringWithRange_(textRange)
     
     def current_line(self):
         block = self.text_for_range(self.current_block_range())
         block = block.split('\n')
         return block[-1]
     
     
     def insert_text(self, string=None, textRange=None, scrollToVisible=True):
         """Insert text into textView at textRange, updating blockRanges 
         as necessary
         """
         
         if(textRange == None):
             #range for end of text
             textRange = NSMakeRange(self.textView.textStorage().length(), 0) 
         
         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)
         self.textView.setSelectedRange_(
             NSMakeRange(textRange.location+len(string), 0))
         if(scrollToVisible):
             self.textView.scrollRangeToVisible_(textRange)
         
     
     
     
     def replace_current_block_with_string(self, textView, string):
         textView.replaceCharactersInRange_withString_(
                                                 self.current_block_range(),
                                                 string)
         self.current_block_range().length = len(string)
         r = NSMakeRange(textView.textStorage().length(), 0)
         textView.scrollRangeToVisible_(r)
         textView.setSelectedRange_(r)
     
     
     def current_indent_string(self):
         """returns string for indent or None if no indent"""
         
         return self._indent_for_block(self.current_block())
     
     
     def _indent_for_block(self, block):
         lines = block.split('\n')
         if(len(lines) > 1):
             currentIndent = len(lines[-1]) - len(lines[-1].lstrip())
             if(currentIndent == 0):
                 currentIndent = self.tabSpaces
         
             if(self.tabUsesSpaces):
                 result = ' ' * currentIndent
             else:
                 result = '\t' * (currentIndent/self.tabSpaces)
         else:
             result = None
         
         return result
     
     
     # NSTextView delegate methods...
     def textView_doCommandBySelector_(self, textView, selector):
         assert(textView == self.textView)
         NSLog("textView_doCommandBySelector_: "+selector)
         
         
         if(selector == 'insertNewline:'):
             indent = self.current_indent_string()
             if(indent):
                 line = indent + self.current_line()
             else:
                 line = self.current_line()
             
             if(self.is_complete(self.current_block())):
                 self.execute(self.current_block(),
                                 blockID=self.currentBlockID)
                 self.start_new_block()
                 
                 return True
             
             return False
         
         elif(selector == 'moveUp:'):
             prevBlock = self.get_history_previous(self.current_block())
             if(prevBlock != None):
                 self.replace_current_block_with_string(textView, prevBlock)
             else:
                 NSBeep()
             return True
         
         elif(selector == 'moveDown:'):
             nextBlock = self.get_history_next()
             if(nextBlock != None):
                 self.replace_current_block_with_string(textView, nextBlock)
             else:
                 NSBeep()
             return True
         
         elif(selector == 'moveToBeginningOfParagraph:'):
             textView.setSelectedRange_(NSMakeRange(
                                         self.current_block_range().location, 
                                         0))
             return True
         elif(selector == 'moveToEndOfParagraph:'):
             textView.setSelectedRange_(NSMakeRange(
                                     self.current_block_range().location + \
                                     self.current_block_range().length, 0))
             return True
         elif(selector == 'deleteToEndOfParagraph:'):
             if(textView.selectedRange().location <= \
                 self.current_block_range().location):
                 # Intersect the selected range with the current line range
                 if(self.current_block_range().length < 0):
                     self.blockRanges[self.currentBlockID].length = 0
             
                 r = NSIntersectionRange(textView.rangesForUserTextChange()[0],
                                         self.current_block_range())
                 
                 if(r.length > 0): #no intersection
                     textView.setSelectedRange_(r)
             
             return False # don't actually handle the delete
         
         elif(selector == 'insertTab:'):
             if(len(self.current_line().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.current_block_range().location):
                 return True
             else:
                 self.current_block_range().length-=1
                 return False
         return False
     
     
     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.
         """
         
         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.current_block_range().location):
                 self.insert_text(s)
                 allow = False
             
             
             self.blockRanges.setdefault(self.currentBlockID, 
                                         self.current_block_range()).length +=\
                                          len(s)
         
         return allow
     
     def textView_completions_forPartialWordRange_indexOfSelectedItem_(self, 
         textView, words, charRange, index):
         try:
             ts = textView.textStorage()
             token = ts.string().substringWithRange_(charRange)
             completions = blockingCallFromThread(self.complete, token)
         except:
             completions = objc.nil
             NSBeep()
         
         return (completions,0)
     
 

IPython/frontend/frontendbase.py

@@ -1,407 +1,403 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.
 
 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
 
 try:
     from zope.interface import Interface, Attribute, implements, classProvides
 except ImportError:
     #zope.interface is not available
     Interface = object
     def Attribute(name, doc): pass
     def implements(interface): pass
     def classProvides(interface): pass
 
 from IPython.kernel.core.history import FrontEndHistory
 from IPython.kernel.core.util import Bunch
 from IPython.kernel.engineservice import IEngineCore
 
-try:
-    from twisted.python.failure import Failure
-except ImportError:
-    #Twisted not available
-    Failure = Exception
 
 ##############################################################################
 # 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(Interface):
     """Factory interface for frontends."""
     
     def __call__(engine=None, history=None):
         """
         Parameters:
         interpreter : IPython.kernel.engineservice.IEngineCore
         """
         
         pass
 
 
 
 class IFrontEnd(Interface):
     """Interface for frontends. All methods return t.i.d.Deferred"""
     
     Attribute("input_prompt_template", "string.Template instance\
                 substituteable with execute result.")
     Attribute("output_prompt_template", "string.Template instance\
                 substituteable with execute result.")
     Attribute("continuation_prompt_template", "string.Template instance\
                 substituteable with execute result.")
     
     def update_cell_prompt(result, blockID=None):
         """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/errback,
         implementations should return result when finished.
         
         Result is a result dict in case of success, and a
         twisted.python.util.failure.Failure in case of an error
         """
         
         pass
     
     
     def render_result(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.
         
         Parameters:
             result : dict (result of IEngineBase.execute )
                 blockID = result['blockID']
         
         Result:
             Output of frontend rendering
         """
         
         pass
     
     def render_error(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.
         
         blockID = failure.blockID
         """
         
         pass
     
     
     def input_prompt(number=''):
         """Returns the input prompt by subsituting into 
         self.input_prompt_template
         """
         pass
     
     def output_prompt(number=''):
         """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
         """
         
         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?
     """
     
     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, shell=None, history=None):
         self.shell = shell
         if history is None:
                 self.history = FrontEndHistory(input_cache=[''])
         else:
             self.history = history
         
     
     def input_prompt(self, number=''):
         """Returns the current input prompt
         
         It would be great to use ipython1.core.prompts.Prompt1 here
         """
         return self.input_prompt_template.safe_substitute({'number':number})
     
     
     def continuation_prompt(self):
         """Returns the current continuation prompt"""
         
         return self.continuation_prompt_template.safe_substitute()
     
     def output_prompt(self, number=''):
         """Returns the output prompt for result"""
         
         return self.output_prompt_template.safe_substitute({'number':number})
     
     
     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 the 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)):
             raise Exception("Block is not compilable")
         
         if(blockID == None):
             blockID = uuid.uuid4() #random UUID
         
         try:
             result = self.shell.execute(block)
         except Exception,e:
             e = self._add_block_id_for_failure(e, blockID=blockID)
             e = self.update_cell_prompt(e, blockID=blockID)
             e = self.render_error(e)
         else:
             result = self._add_block_id_for_result(result, blockID=blockID)
             result = self.update_cell_prompt(result, blockID=blockID)
             result = self.render_result(result)
         
         return result
     
     
     def _add_block_id_for_result(self, result, blockID):
         """Add the blockID to result or failure. Unfortunatley, we have to 
         treat failures differently than result dicts.
         """
         
         result['blockID'] = blockID
         
         return result
     
     def _add_block_id_for_failure(self, failure, blockID):
         """_add_block_id_for_failure"""
         
         failure.blockID = blockID
         return failure
     
     
     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, blockID=None):
         """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.
         """
         
         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.
         """
         
         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.
         """
         
         return failure
     
 
 
 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)):
+            from twisted.python.failure import Failure
             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