Changed a bunch of modules to NOT have the x permission bit set.

IPython/frontend/cocoa/tests/test_cocoa_frontend.py

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

IPython/frontend/frontendbase.py

@@ -1,359 +1,358 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
 
 from zopeinterface import Interface, Attribute, implements, classProvides
 
 from IPython.kernel.core.history import FrontEndHistory
 from IPython.kernel.core.util import Bunch
-from IPython.kernel.engineservice import IEngineCore
 
 ##############################################################################
 # 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]:  '
 
 ##############################################################################
 # Interface definitions
 ##############################################################################
 
 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. 
 
         In asynchronous frontends, this method will be called as a
         twisted.internet.defer.Deferred's callback/errback.
         Implementations should thus 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. 
         
         In asynchronous frontend, since this method will be called as a
         twisted.internet.defer.Deferred's callback. Implementations
         should thus 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(current_block):
         """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
     
     def complete(self, line):
         """Returns the list of possible completions, and the completed
             line.
 
         The input argument is the full line to be completed. This method
         returns both the line completed as much as possible, and the list
         of further possible completions (full words).
         """
         pass
 
 
 ##############################################################################
 # Base class for all the frontends. 
 ##############################################################################
 
 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
     
     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, current_block):
         """ 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+1 == len(self.history.input_cache)):
                 self.history.input_cache[self.history_cursor] = current_block
             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. 
 
         This method only really makes sens in asyncrhonous frontend.
         Since this method will be called as a 
         twisted.internet.defer.Deferred's callback, implementations should 
         return result when finished.
         """
         
         raise NotImplementedError
     
     
     def render_result(self, result):
         """Subclasses must override to render result. 
         
         In asynchronous frontends, this method will be called as a
         twisted.internet.defer.Deferred's callback. Implementations
         should thus return result when finished.
         """
         
         raise NotImplementedError
     
     
     def render_error(self, failure):
         """Subclasses must override to render the failure. 
         
         In asynchronous frontends, this method will be called as a
         twisted.internet.defer.Deferred's callback. Implementations
         should thus return result when finished.
         """
         
         raise NotImplementedError
 

IPython/frontend/tests/test_frontendbase.py

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

IPython/kernel/tests/test_enginefc.py

@@ -1,92 +1,91 b''
 # encoding: utf-8
 
 """This file contains unittests for the enginepb.py module."""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 try:
     from twisted.python import components
     from twisted.internet import reactor, defer
     from twisted.spread import pb
     from twisted.internet.base import DelayedCall
     DelayedCall.debug = True
 
     import zope.interface as zi
 
     from IPython.kernel.fcutil import Tub, UnauthenticatedTub
     from IPython.kernel import engineservice as es
     from IPython.testing.util import DeferredTestCase
     from IPython.kernel.controllerservice import IControllerBase
     from IPython.kernel.enginefc import FCRemoteEngineRefFromService, IEngineBase
     from IPython.kernel.engineservice import IEngineQueued
     from IPython.kernel.engineconnector import EngineConnector
     
     from IPython.kernel.tests.engineservicetest import \
         IEngineCoreTestCase, \
         IEngineSerializedTestCase, \
         IEngineQueuedTestCase
 except ImportError:
-    print "we got an error!!!"
-    raise
+	pass
 else:
     class EngineFCTest(DeferredTestCase, 
                        IEngineCoreTestCase, 
                        IEngineSerializedTestCase,
                        IEngineQueuedTestCase
                        ):
         
         zi.implements(IControllerBase)
         
         def setUp(self):
         
             # Start a server and append to self.servers
             self.controller_reference = FCRemoteEngineRefFromService(self)
             self.controller_tub = Tub()
             self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
             self.controller_tub.setLocation('127.0.0.1:10105')
             
             furl = self.controller_tub.registerReference(self.controller_reference)
             self.controller_tub.startService()
             
             # Start an EngineService and append to services/client
             self.engine_service = es.EngineService()
             self.engine_service.startService()
             self.engine_tub = Tub()
             self.engine_tub.startService()
             engine_connector = EngineConnector(self.engine_tub)
             d = engine_connector.connect_to_controller(self.engine_service, furl)
             # This deferred doesn't fire until after register_engine has returned and
             # thus, self.engine has been defined and the tets can proceed.
             return d
         
         def tearDown(self):
             dlist = []
             # Shut down the engine
             d = self.engine_tub.stopService()
             dlist.append(d)
             # Shut down the controller
             d = self.controller_tub.stopService()
             dlist.append(d)
             return defer.DeferredList(dlist)
         
         #---------------------------------------------------------------------------
         # Make me look like a basic controller
         #---------------------------------------------------------------------------
         
         def register_engine(self, engine_ref, id=None, ip=None, port=None, pid=None):
             self.engine = IEngineQueued(IEngineBase(engine_ref))
             return {'id':id}
         
         def unregister_engine(self, id):
             pass
  No newline at end of file