updates for frontendbase API. Cocoa plugin functional in Objective-C app

IPython/frontend/cocoa/cocoa_frontend.py

@@ -29,7 +29,8 b' import uuid'
 
 from Foundation import NSObject, NSMutableArray, NSMutableDictionary,\
                         NSLog, NSNotificationCenter, NSMakeRange,\
-                        NSLocalizedString, NSIntersectionRange
+                        NSLocalizedString, NSIntersectionRange,\
+                        NSString, NSAutoreleasePool
                         
 from AppKit import NSApplicationWillTerminateNotification, NSBeep,\
                     NSTextView, NSRulerView, NSVerticalRuler
@@ -52,7 +53,29 b' from twisted.python.failure import Failure'
 #       ThreadedEngineService?
 #   2. integrate Xgrid launching of engines
         
+class AutoreleasePoolWrappedThreadedEngineService(ThreadedEngineService):
+    """Wrap all blocks in an NSAutoreleasePool"""
     
+    def wrapped_execute(self, lines):
+        """wrapped_execute"""
+        
+        p = NSAutoreleasePool.alloc().init()
+        result = self.shell.execute(lines)
+        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, lines)
+        d.addCallback(self.addIDToResult)
+        return d
 
 
 class IPythonCocoaController(NSObject, FrontEndBase):
@@ -62,7 +85,8 b' class IPythonCocoaController(NSObject, FrontEndBase):'
     
     def init(self):
         self = super(IPythonCocoaController, self).init()
-        FrontEndBase.__init__(self, engine=ThreadedEngineService())
+        FrontEndBase.__init__(self,
+                    engine=AutoreleasePoolWrappedThreadedEngineService())
         if(self != None):
             self._common_init()
         
@@ -133,13 +157,42 b' class IPythonCocoaController(NSObject, FrontEndBase):'
     def execute(self, block, blockID=None):
         self.waitingForEngine = True
         self.willChangeValueForKey_('commandHistory')
-        d = super(IPythonCocoaController, self).execute(block, blockID)
+        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
+    
+    def executeFileAtPath_(self, path):
+        """Execute file at path in an empty namespace. Update the engine
+        user_ns with the resulting locals."""
+        
+        lines,err = NSString.stringWithContentsOfFile_encoding_error_(
+            path,
+            NSString.defaultCStringEncoding(),
+            None)
+        self.engine.execute(lines)
+    
+    
     def _engine_done(self, x):
         self.waitingForEngine = False
         self.didChangeValueForKey_('commandHistory')
@@ -166,14 +219,14 b' class IPythonCocoaController(NSObject, FrontEndBase):'
         self.didChangeValueForKey_('userNS')
     
     
-    def update_cell_prompt(self, result):
+    def update_cell_prompt(self, result, blockID=None):
         if(isinstance(result, Failure)):
-            blockID = result.blockID
+            self.insert_text(self.input_prompt(),
+                textRange=NSMakeRange(self.blockRanges[blockID].location,0),
+                scrollToVisible=False
+                )
         else:
-            blockID = result['blockID']
-        
-        
-        self.insert_text(self.input_prompt(result=result),
+            self.insert_text(self.input_prompt(number=result['number']),
                 textRange=NSMakeRange(self.blockRanges[blockID].location,0),
                 scrollToVisible=False
                 )

IPython/frontend/cocoa/plugin/Makefile

@@ -2,4 +2,5 b' include ./plugins.mk'
 
 all : dist/IPythonCocoaController.plugin
 
-dist/IPythonCocoaController.plugin : ./FrontendLoader.py ./setup.py
  No newline at end of file
+dist/IPythonCocoaController.plugin : ./IPythonCocoaFrontendLoader.py\
+ ./setup.py
  No newline at end of file

IPython/frontend/cocoa/plugin/plugins.mk

@@ -1,5 +1,4 b''
 %.plugin::
-	mkdir -p plugin
 	rm -rf dist/$(notdir $@)
 	rm -rf build dist && \
 	python setup.py py2app -s

IPython/frontend/cocoa/plugin/setup.py

@@ -25,10 +25,10 b' infoPlist = dict('
 )
 
 setup(
-	plugin=['FrontendLoader.py'],
+	plugin=['IPythonCocoaFrontendLoader.py'],
     setup_requires=['py2app'],
 	options=dict(py2app=dict(
 		plist=infoPlist,
-		excludes=['IPython']
+		excludes=['IPython','twisted']
 	)),
 )
  No newline at end of file

IPython/frontend/frontendbase.py

@@ -66,23 +66,20 b' class IFrontEnd(zi.Interface):'
     zi.Attribute("continuation_prompt_template", "string.Template instance\
                 substituteable with execute result.")
     
-    def update_cell_prompt(self, 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,
+        twisted.internet.defer.Deferred's callback/errback,
         implementations should return result when finished.
         
-        NB: 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']
+        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(self, result):
+    
+    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 
@@ -90,6 +87,7 b' class IFrontEnd(zi.Interface):'
         
         Parameters:
             result : dict (result of IEngineBase.execute )
+                blockID = result['blockID']
         
         Result:
             Output of frontend rendering
@@ -97,22 +95,24 b' class IFrontEnd(zi.Interface):'
         
         pass
     
-    def render_error(self, failure):
+    def render_error(failure):
         """Subclasses must override to render the failure. Since this method 
-        ill be called as a twisted.internet.defer.Deferred's callback, 
+        will be called as a twisted.internet.defer.Deferred's callback, 
         implementations should return result when finished.
+        
+        blockID = failure.blockID
         """
         
         pass
     
     
-    def input_prompt(result={}):
+    def input_prompt(number=None):
         """Returns the input prompt by subsituting into 
         self.input_prompt_template
         """
         pass
     
-    def output_prompt(result):
+    def output_prompt(number=None):
         """Returns the output prompt by subsituting into 
         self.output_prompt_template
         """
@@ -180,15 +180,12 b' class FrontEndBase(object):'
             self.history = history
         
     
-    def input_prompt(self, result={}):
+    def input_prompt(self, number=None):
         """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)
+        return self.input_prompt_template.safe_substitute({'number':number})
     
     
     def continuation_prompt(self):
@@ -196,10 +193,10 b' class FrontEndBase(object):'
         
         return self.continuation_prompt_template.safe_substitute()
     
-    def output_prompt(self, result):
+    def output_prompt(self, number=None):
         """Returns the output prompt for result"""
         
-        return self.output_prompt_template.safe_substitute(result)
+        return self.output_prompt_template.safe_substitute({'number':number})
     
     
     def is_complete(self, block):
@@ -259,25 +256,33 b' class FrontEndBase(object):'
         
         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)
+        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
     
     
-    def _add_block_id(self, result, blockID):
+    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.
         """
         
-        if(isinstance(result, Failure)):
-            result.blockID = blockID
-        else:
-            result['blockID'] = blockID
+        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"""
         
@@ -313,20 +318,11 b' class FrontEndBase(object):'
     # Subclasses probably want to override these methods...
     ###
     
-    def update_cell_prompt(self, result):
+    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.
-        
-        NB: 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
@@ -344,7 +340,8 b' class FrontEndBase(object):'
     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."""
+        implementations should return result when finished.
+        """
         
         return failure
     

IPython/frontend/tests/test_frontendbase.py

@@ -28,7 +28,7 b' class FrontEndCallbackChecker(frontendbase.FrontEndBase):'
         self.renderResultCalled = False
         self.renderErrorCalled = False
     
-    def update_cell_prompt(self, result):
+    def update_cell_prompt(self, result, blockID=None):
         self.updateCalled = True
         return result