Merge with upstream

IPython/completer.py

@@ -1,637 +1,640 b''
 """Word completion for IPython.
 
 This module is a fork of the rlcompleter module in the Python standard
 library.  The original enhancements made to rlcompleter have been sent
 upstream and were accepted as of Python 2.3, but we need a lot more
 functionality specific to IPython, so this module will continue to live as an
 IPython-specific utility.
 
 ---------------------------------------------------------------------------
 Original rlcompleter documentation:
 
 This requires the latest extension to the readline module (the
 completes keywords, built-ins and globals in __main__; when completing
 NAME.NAME..., it evaluates (!) the expression up to the last dot and
 completes its attributes.
 
 It's very cool to do "import string" type "string.", hit the
 completion key (twice), and see the list of names defined by the
 string module!
 
 Tip: to use the tab key as the completion key, call
 
     readline.parse_and_bind("tab: complete")
 
 Notes:
 
 - Exceptions raised by the completer function are *ignored* (and
 generally cause the completion to fail).  This is a feature -- since
 readline sets the tty device in raw (or cbreak) mode, printing a
 traceback wouldn't work well without some complicated hoopla to save,
 reset and restore the tty state.
 
 - The evaluation of the NAME.NAME... form may cause arbitrary
 application defined code to be executed if an object with a
 __getattr__ hook is found.  Since it is the responsibility of the
 application (or the user) to enable this feature, I consider this an
 acceptable risk.  More complicated expressions (e.g. function calls or
 indexing operations) are *not* evaluated.
 
 - GNU readline is also used by the built-in functions input() and
 raw_input(), and thus these also benefit/suffer from the completer
 features.  Clearly an interactive application can benefit by
 specifying its own completer function and using raw_input() for all
 its input.
 
 - When the original stdin is not a tty device, GNU readline is never
 used, and this module (and the readline module) are silently inactive.
 
 """
 
 #*****************************************************************************
 #
 # Since this file is essentially a minimally modified copy of the rlcompleter
 # module which is part of the standard Python distribution, I assume that the
 # proper procedure is to maintain its copyright as belonging to the Python
 # Software Foundation (in addition to my own, for all new code).
 #
 #       Copyright (C) 2001 Python Software Foundation, www.python.org
 #       Copyright (C) 2001-2006 Fernando Perez. <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #
 #*****************************************************************************
 
 import __builtin__
 import __main__
 import glob
 import keyword
 import os
 import re
 import shlex
 import sys
 import IPython.rlineimpl as readline    
 import itertools
 from IPython.ipstruct import Struct
 from IPython import ipapi
 from IPython import generics
 import types
 
 # Python 2.4 offers sets as a builtin
 try:
     set()
 except NameError:
     from sets import Set as set
 
 from IPython.genutils import debugx, dir2
 
 __all__ = ['Completer','IPCompleter']
 
 class Completer:
     def __init__(self,namespace=None,global_namespace=None):
         """Create a new completer for the command line.
 
         Completer([namespace,global_namespace]) -> completer instance.
 
         If unspecified, the default namespace where completions are performed
         is __main__ (technically, __main__.__dict__). Namespaces should be
         given as dictionaries.
 
         An optional second namespace can be given.  This allows the completer
         to handle cases where both the local and global scopes need to be
         distinguished.
 
         Completer instances should be used as the completion mechanism of
         readline via the set_completer() call:
 
         readline.set_completer(Completer(my_namespace).complete)
         """
 
         # Don't bind to namespace quite yet, but flag whether the user wants a
         # specific namespace or to use __main__.__dict__. This will allow us
         # to bind to __main__.__dict__ at completion time, not now.
         if namespace is None:
             self.use_main_ns = 1
         else:
             self.use_main_ns = 0
             self.namespace = namespace
 
         # The global namespace, if given, can be bound directly
         if global_namespace is None:
             self.global_namespace = {}
         else:
             self.global_namespace = global_namespace
 
     def complete(self, text, state):
         """Return the next possible completion for 'text'.
 
         This is called successively with state == 0, 1, 2, ... until it
         returns None.  The completion should begin with 'text'.
 
         """
         if self.use_main_ns:
             self.namespace = __main__.__dict__
             
         if state == 0:
             if "." in text:
                 self.matches = self.attr_matches(text)
             else:
                 self.matches = self.global_matches(text)
         try:
             return self.matches[state]
         except IndexError:
             return None
 
     def global_matches(self, text):
         """Compute matches when text is a simple name.
 
         Return a list of all keywords, built-in functions and names currently
         defined in self.namespace or self.global_namespace that match.
 
         """
         matches = []
         match_append = matches.append
         n = len(text)
         for lst in [keyword.kwlist,
                     __builtin__.__dict__.keys(),
                     self.namespace.keys(),
                     self.global_namespace.keys()]:
             for word in lst:
                 if word[:n] == text and word != "__builtins__":
                     match_append(word)
         return matches
 
     def attr_matches(self, text):
         """Compute matches when text contains a dot.
 
         Assuming the text is of the form NAME.NAME....[NAME], and is
         evaluatable in self.namespace or self.global_namespace, it will be
         evaluated and its attributes (as revealed by dir()) are used as
         possible completions.  (For class instances, class members are are
         also considered.)
 
         WARNING: this can still invoke arbitrary C code, if an object
         with a __getattr__ hook is evaluated.
 
         """
         import re
 
         # Another option, seems to work great. Catches things like ''.<tab>
         m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
 
         if not m:
             return []
         
         expr, attr = m.group(1, 3)
         try:
             obj = eval(expr, self.namespace)
         except:
             try:
                 obj = eval(expr, self.global_namespace)
             except:
                 return []
 
         words = dir2(obj)
         
         try:
             words = generics.complete_object(obj, words)
         except ipapi.TryNext:
             pass
         # Build match list to return
         n = len(attr)
         res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
         return res
 
 class IPCompleter(Completer):
     """Extension of the completer class with IPython-specific features"""
 
     def __init__(self,shell,namespace=None,global_namespace=None,
                  omit__names=0,alias_table=None):
         """IPCompleter() -> completer
 
         Return a completer object suitable for use by the readline library
         via readline.set_completer().
 
         Inputs:
 
         - shell: a pointer to the ipython shell itself.  This is needed
         because this completer knows about magic functions, and those can
         only be accessed via the ipython instance.
 
         - namespace: an optional dict where completions are performed.
 
         - global_namespace: secondary optional dict for completions, to
         handle cases (such as IPython embedded inside functions) where
         both Python scopes are visible.
 
         - The optional omit__names parameter sets the completer to omit the
         'magic' names (__magicname__) for python objects unless the text
         to be completed explicitly starts with one or more underscores.
 
         - If alias_table is supplied, it should be a dictionary of aliases
         to complete. """
 
         Completer.__init__(self,namespace,global_namespace)
         self.magic_prefix = shell.name+'.magic_'
         self.magic_escape = shell.ESC_MAGIC
         self.readline = readline
         delims = self.readline.get_completer_delims()
         delims = delims.replace(self.magic_escape,'')
         self.readline.set_completer_delims(delims)
         self.get_line_buffer = self.readline.get_line_buffer
         self.get_endidx = self.readline.get_endidx
         self.omit__names = omit__names
         self.merge_completions = shell.rc.readline_merge_completions        
         if alias_table is None:
             alias_table = {}
         self.alias_table = alias_table
         # Regexp to split filenames with spaces in them
         self.space_name_re = re.compile(r'([^\\] )')
         # Hold a local ref. to glob.glob for speed
         self.glob = glob.glob
 
         # Determine if we are running on 'dumb' terminals, like (X)Emacs
         # buffers, to avoid completion problems.
         term = os.environ.get('TERM','xterm')
         self.dumb_terminal = term in ['dumb','emacs']
         
         # Special handling of backslashes needed in win32 platforms
         if sys.platform == "win32":
             self.clean_glob = self._clean_glob_win32
         else:
             self.clean_glob = self._clean_glob
         self.matchers = [self.python_matches,
                          self.file_matches,
                          self.alias_matches,
                          self.python_func_kw_matches]
 
     
     # Code contributed by Alex Schmolck, for ipython/emacs integration
     def all_completions(self, text):
         """Return all possible completions for the benefit of emacs."""
 
         completions = []
         comp_append = completions.append
         try:
             for i in xrange(sys.maxint):
                 res = self.complete(text, i)
 
                 if not res: break
 
                 comp_append(res)
         #XXX workaround for ``notDefined.<tab>``
         except NameError:
             pass
         return completions
     # /end Alex Schmolck code.
 
     def _clean_glob(self,text):
         return self.glob("%s*" % text)
 
     def _clean_glob_win32(self,text):
         return [f.replace("\\","/")
                 for f in self.glob("%s*" % text)]            
 
     def file_matches(self, text):
         """Match filenames, expanding ~USER type strings.
 
         Most of the seemingly convoluted logic in this completer is an
         attempt to handle filenames with spaces in them.  And yet it's not
         quite perfect, because Python's readline doesn't expose all of the
         GNU readline details needed for this to be done correctly.
 
         For a filename with a space in it, the printed completions will be
         only the parts after what's already been typed (instead of the
         full completions, as is normally done).  I don't think with the
         current (as of Python 2.3) Python readline it's possible to do
         better."""
 
         #print 'Completer->file_matches: <%s>' % text # dbg
 
         # chars that require escaping with backslash - i.e. chars
         # that readline treats incorrectly as delimiters, but we
         # don't want to treat as delimiters in filename matching
         # when escaped with backslash
 
-        protectables = ' '
+        if sys.platform == 'win32':
+            protectables = ' '
+        else:
+            protectables = ' ()'
 
         if text.startswith('!'):
             text = text[1:]
             text_prefix = '!'
         else:
             text_prefix = ''
             
         def protect_filename(s):
             return "".join([(ch in protectables and '\\' + ch or ch)
                             for ch in s])
 
         def single_dir_expand(matches):
             "Recursively expand match lists containing a single dir."
             
             if len(matches) == 1 and os.path.isdir(matches[0]):
                 # Takes care of links to directories also.  Use '/'
                 # explicitly, even under Windows, so that name completions
                 # don't end up escaped.
                 d = matches[0]
                 if d[-1] in ['/','\\']:
                     d = d[:-1]
 
                 subdirs = os.listdir(d)
                 if subdirs:
                     matches = [ (d + '/' + p) for p in subdirs]
                     return single_dir_expand(matches)
                 else:
                     return matches
             else:
                 return matches
         
         lbuf = self.lbuf
         open_quotes = 0  # track strings with open quotes
         try:
             lsplit = shlex.split(lbuf)[-1]
         except ValueError:
             # typically an unmatched ", or backslash without escaped char.
             if lbuf.count('"')==1:
                 open_quotes = 1
                 lsplit = lbuf.split('"')[-1]
             elif lbuf.count("'")==1:
                 open_quotes = 1
                 lsplit = lbuf.split("'")[-1]
             else:
                 return []
         except IndexError:
             # tab pressed on empty line
             lsplit = ""
 
         if lsplit != protect_filename(lsplit):
             # if protectables are found, do matching on the whole escaped
             # name
             has_protectables = 1
             text0,text = text,lsplit
         else:
             has_protectables = 0
             text = os.path.expanduser(text)
 
         if text == "":
             return [text_prefix + protect_filename(f) for f in self.glob("*")]
 
         m0 = self.clean_glob(text.replace('\\',''))
         if has_protectables:
             # If we had protectables, we need to revert our changes to the
             # beginning of filename so that we don't double-write the part
             # of the filename we have so far
             len_lsplit = len(lsplit)
             matches = [text_prefix + text0 + 
                        protect_filename(f[len_lsplit:]) for f in m0]
         else:
             if open_quotes:
                 # if we have a string with an open quote, we don't need to
                 # protect the names at all (and we _shouldn't_, as it
                 # would cause bugs when the filesystem call is made).
                 matches = m0
             else:
                 matches = [text_prefix + 
                            protect_filename(f) for f in m0]
 
         #print 'mm',matches  # dbg
         return single_dir_expand(matches)
 
     def alias_matches(self, text):
         """Match internal system aliases"""        
         #print 'Completer->alias_matches:',text,'lb',self.lbuf # dbg
         
         # if we are not in the first 'item', alias matching 
         # doesn't make sense - unless we are starting with 'sudo' command.
         if ' ' in self.lbuf.lstrip() and not self.lbuf.lstrip().startswith('sudo'):
             return []
         text = os.path.expanduser(text)
         aliases =  self.alias_table.keys()
         if text == "":
             return aliases
         else:
             return [alias for alias in aliases if alias.startswith(text)]
 
     def python_matches(self,text):
         """Match attributes or global python names"""
 
         #print 'Completer->python_matches, txt=<%s>' % text # dbg
         if "." in text:
             try:
                 matches = self.attr_matches(text)
                 if text.endswith('.') and self.omit__names:
                     if self.omit__names == 1:
                         # true if txt is _not_ a __ name, false otherwise:
                         no__name = (lambda txt:
                                     re.match(r'.*\.__.*?__',txt) is None)
                     else:
                         # true if txt is _not_ a _ name, false otherwise:
                         no__name = (lambda txt:
                                     re.match(r'.*\._.*?',txt) is None)
                     matches = filter(no__name, matches)
             except NameError:
                 # catches <undefined attributes>.<tab>
                 matches = []
         else:
             matches = self.global_matches(text)
             # this is so completion finds magics when automagic is on:
             if (matches == [] and 
                  not text.startswith(os.sep) and
                  not ' ' in self.lbuf):
                 matches = self.attr_matches(self.magic_prefix+text)
         return matches
 
     def _default_arguments(self, obj):
         """Return the list of default arguments of obj if it is callable,
         or empty list otherwise."""
 
         if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
             # for classes, check for __init__,__new__
             if inspect.isclass(obj):
                 obj = (getattr(obj,'__init__',None) or
                        getattr(obj,'__new__',None))
             # for all others, check if they are __call__able
             elif hasattr(obj, '__call__'):
                 obj = obj.__call__
             # XXX: is there a way to handle the builtins ?
         try:
             args,_,_1,defaults = inspect.getargspec(obj)
             if defaults:
                 return args[-len(defaults):]
         except TypeError: pass
         return []
 
     def python_func_kw_matches(self,text):
         """Match named parameters (kwargs) of the last open function"""
 
         if "." in text: # a parameter cannot be dotted
             return []
         try: regexp = self.__funcParamsRegex
         except AttributeError:
             regexp = self.__funcParamsRegex = re.compile(r'''
                 '.*?' |    # single quoted strings or
                 ".*?" |    # double quoted strings or
                 \w+   |    # identifier
                 \S         # other characters
                 ''', re.VERBOSE | re.DOTALL)
         # 1. find the nearest identifier that comes before an unclosed
         # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
         tokens = regexp.findall(self.get_line_buffer())
         tokens.reverse()
         iterTokens = iter(tokens); openPar = 0
         for token in iterTokens:
             if token == ')':
                 openPar -= 1
             elif token == '(':
                 openPar += 1
                 if openPar > 0:
                     # found the last unclosed parenthesis
                     break
         else:
             return []
         # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
         ids = []
         isId = re.compile(r'\w+$').match
         while True:
             try:
                 ids.append(iterTokens.next())
                 if not isId(ids[-1]):
                     ids.pop(); break
                 if not iterTokens.next() == '.':
                     break
             except StopIteration:
                 break
         # lookup the candidate callable matches either using global_matches
         # or attr_matches for dotted names
         if len(ids) == 1:
             callableMatches = self.global_matches(ids[0])
         else:
             callableMatches = self.attr_matches('.'.join(ids[::-1]))
         argMatches = []
         for callableMatch in callableMatches:
             try: namedArgs = self._default_arguments(eval(callableMatch,
                                                          self.namespace))
             except: continue
             for namedArg in namedArgs:
                 if namedArg.startswith(text):
                     argMatches.append("%s=" %namedArg)
         return argMatches
 
     def dispatch_custom_completer(self,text):
         #print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
         line = self.full_lbuf        
         if not line.strip():
             return None
 
         event = Struct()
         event.line = line
         event.symbol = text
         cmd = line.split(None,1)[0]
         event.command = cmd
         #print "\ncustom:{%s]\n" % event # dbg
         
         # for foo etc, try also to find completer for %foo
         if not cmd.startswith(self.magic_escape):
             try_magic = self.custom_completers.s_matches(
               self.magic_escape + cmd)            
         else:
             try_magic = []
         
         
         for c in itertools.chain(
                                  self.custom_completers.s_matches(cmd),
                                  try_magic,
                                  self.custom_completers.flat_matches(self.lbuf)):
             #print "try",c # dbg
             try:
                 res = c(event)
                 # first, try case sensitive match
                 withcase = [r for r in res if r.startswith(text)]
                 if withcase:
                     return withcase
                 # if none, then case insensitive ones are ok too
                 return [r for r in res if r.lower().startswith(text.lower())]
             except ipapi.TryNext:
                 pass
             
         return None
                
     def complete(self, text, state,line_buffer=None):
         """Return the next possible completion for 'text'.
 
         This is called successively with state == 0, 1, 2, ... until it
         returns None.  The completion should begin with 'text'.
 
         :Keywords:
         - line_buffer: string
         If not given, the completer attempts to obtain the current line buffer
         via readline.  This keyword allows clients which are requesting for
         text completions in non-readline contexts to inform the completer of
         the entire text.
         """
 
         #print '\n*** COMPLETE: <%s> (%s)' % (text,state)  # dbg
 
         # if there is only a tab on a line with only whitespace, instead
         # of the mostly useless 'do you want to see all million
         # completions' message, just do the right thing and give the user
         # his tab!  Incidentally, this enables pasting of tabbed text from
         # an editor (as long as autoindent is off).
 
         # It should be noted that at least pyreadline still shows
         # file completions - is there a way around it?
         
         # don't apply this on 'dumb' terminals, such as emacs buffers, so we
         # don't interfere with their own tab-completion mechanism.
         if line_buffer is None:
             self.full_lbuf = self.get_line_buffer()
         else:
             self.full_lbuf = line_buffer
             
         if not (self.dumb_terminal or self.full_lbuf.strip()):
             self.readline.insert_text('\t')
             return None
         
         magic_escape = self.magic_escape
         magic_prefix = self.magic_prefix
 
         self.lbuf = self.full_lbuf[:self.get_endidx()]
 
         try:
             if text.startswith(magic_escape):
                 text = text.replace(magic_escape,magic_prefix)
             elif text.startswith('~'):
                 text = os.path.expanduser(text)
             if state == 0:
                 custom_res = self.dispatch_custom_completer(text)
                 if custom_res is not None:
                     # did custom completers produce something?
                     self.matches = custom_res
                 else:
                     # Extend the list of completions with the results of each
                     # matcher, so we return results to the user from all
                     # namespaces.
                     if self.merge_completions:
                         self.matches = []
                         for matcher in self.matchers:
                             self.matches.extend(matcher(text))
                     else:
                         for matcher in self.matchers:
                             self.matches = matcher(text)
                             if self.matches:
                                 break
                     def uniq(alist):
                         set = {}
                         return [set.setdefault(e,e) for e in alist if e not in set]
                     self.matches = uniq(self.matches)                
             try:
                 ret = self.matches[state].replace(magic_prefix,magic_escape)                
                 return ret
             except IndexError:
                 return None
         except:
             #from IPython.ultraTB import AutoFormattedTB; # dbg
             #tb=AutoFormattedTB('Verbose');tb() #dbg
             
             # If completion fails, don't annoy the user.
             return None

IPython/frontend/asyncfrontendbase.py

@@ -1,92 +1,76 b''
 """
 Base front end class for all async frontends.
 """
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 import uuid
 
-try:
-    from zope.interface import Interface, Attribute, implements, classProvides
-except ImportError, e:
-    e.message = """%s
-________________________________________________________________________________
-zope.interface is required to run asynchronous frontends.""" % e.message
-    e.args = (e.message, ) + e.args[1:]
 
-from frontendbase import FrontEndBase, IFrontEnd, IFrontEndFactory
-
-from IPython.kernel.engineservice import IEngineCore
+from zope.interface import Interface, Attribute, implements, classProvides
+from twisted.python.failure import Failure
+from IPython.frontend.frontendbase import FrontEndBase, IFrontEnd, IFrontEndFactory
 from IPython.kernel.core.history import FrontEndHistory
-
-try:
-    from twisted.python.failure import Failure
-except ImportError, e:
-    e.message = """%s
-________________________________________________________________________________
-twisted is required to run asynchronous frontends.""" % e.message
-    e.args = (e.message, ) + e.args[1:]
-
-
+from IPython.kernel.engineservice import IEngineCore
 
 
 class AsyncFrontEndBase(FrontEndBase):
     """
     Overrides FrontEndBase to wrap execute in a deferred result.
     All callbacks are made as callbacks on the deferred result.
     """
     
     implements(IFrontEnd)
     classProvides(IFrontEndFactory)
     
     def __init__(self, engine=None, history=None):
         assert(engine==None or IEngineCore.providedBy(engine))
         self.engine = IEngineCore(engine)
         if history is None:
                 self.history = FrontEndHistory(input_cache=[''])
         else:
             self.history = history
     
     
     def execute(self, block, blockID=None):
         """Execute the block and return the deferred result.
         
         Parameters:
             block : {str, AST}
             blockID : any
                 Caller may provide an ID to identify this block. 
                 result['blockID'] := blockID
         
         Result:
             Deferred result of self.interpreter.execute
         """
         
         if(not self.is_complete(block)):
             return Failure(Exception("Block is not compilable"))
         
         if(blockID == None):
             blockID = uuid.uuid4() #random UUID
         
         d = self.engine.execute(block)
         d.addCallback(self._add_history, block=block)
         d.addCallbacks(self._add_block_id_for_result,
                 errback=self._add_block_id_for_failure,
                 callbackArgs=(blockID,),
                 errbackArgs=(blockID,))
         d.addBoth(self.update_cell_prompt, blockID=blockID)
         d.addCallbacks(self.render_result, 
             errback=self.render_error)
         
         return d
     
 

IPython/frontend/cocoa/tests/test_cocoa_frontend.py

@@ -1,91 +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
-from IPython.frontend.cocoa.cocoa_frontend import IPythonCocoaController
-                                                    
-from Foundation import NSMakeRect
-from AppKit import NSTextView, NSScrollView                                                
+
+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:
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted, Foolscap and PyObjC")
 
 class TestIPythonCocoaControler(DeferredTestCase):
     """Tests for IPythonCocoaController"""
-    
+   
     def setUp(self):
         self.controller = IPythonCocoaController.alloc().init()
         self.engine = es.EngineService()
         self.engine.startService()
-    
-    
+   
     def tearDown(self):
         self.controller = None
         self.engine.stopService()
-    
+   
     def testControllerExecutesCode(self):
         code ="""5+5"""
         expected = Interpreter().execute(code)
         del expected['number']
         def removeNumberAndID(result):
             del result['number']
             del result['id']
             return result
         self.assertDeferredEquals(
             self.controller.execute(code).addCallback(removeNumberAndID), 
             expected)
-    
+   
     def testControllerMirrorsUserNSWithValuesAsStrings(self):
         code = """userns1=1;userns2=2"""
         def testControllerUserNS(result):
             self.assertEquals(self.controller.userNS['userns1'], 1)
             self.assertEquals(self.controller.userNS['userns2'], 2)
-        
+       
         self.controller.execute(code).addCallback(testControllerUserNS)
-    
-    
+   
+   
     def testControllerInstantiatesIEngine(self):
         self.assert_(es.IEngineBase.providedBy(self.controller.engine))
-    
+   
     def testControllerCompletesToken(self):
         code = """longNameVariable=10"""
         def testCompletes(result):
             self.assert_("longNameVariable" in result)
-        
+       
         def testCompleteToken(result):
             self.controller.complete("longNa").addCallback(testCompletes)
-        
+       
         self.controller.execute(code).addCallback(testCompletes)
-    
-    
+   
+   
     def testCurrentIndent(self):
         """test that current_indent_string returns current indent or None.
         Uses _indent_for_block for direct unit testing.
         """
-        
+       
         self.controller.tabUsesSpaces = True
         self.assert_(self.controller._indent_for_block("""a=3""") == None)
         self.assert_(self.controller._indent_for_block("") == None)
         block = """def test():\n    a=3"""
         self.assert_(self.controller._indent_for_block(block) == \
                     ' ' * self.controller.tabSpaces)
-        
+       
         block = """if(True):\n%sif(False):\n%spass""" % \
                     (' '*self.controller.tabSpaces,
                      2*' '*self.controller.tabSpaces)
         self.assert_(self.controller._indent_for_block(block) == \
                     2*(' '*self.controller.tabSpaces))
-    
+   

IPython/frontend/frontendbase.py

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

IPython/kernel/tests/multienginetest.py

@@ -1,828 +1,827 b''
 # encoding: utf-8
 
 """"""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from twisted.internet import defer
 
 from IPython.kernel import engineservice as es
 from IPython.kernel import multiengine as me
 from IPython.kernel import newserialized
-from IPython.kernel.error import NotDefined
 from IPython.testing import util
 from IPython.testing.parametric import parametric, Parametric
 from IPython.kernel import newserialized
 from IPython.kernel.util import printer
 from IPython.kernel.error import (InvalidEngineID,
     NoEnginesRegistered,
     CompositeError,
     InvalidDeferredID)
 from IPython.kernel.tests.engineservicetest import validCommands, invalidCommands
 from IPython.kernel.core.interpreter import Interpreter
 
 
 #-------------------------------------------------------------------------------
 # Base classes and utilities
 #-------------------------------------------------------------------------------
 
 class IMultiEngineBaseTestCase(object):
     """Basic utilities for working with multiengine tests.
 
     Some subclass should define:
 
     * self.multiengine
     * self.engines to keep track of engines for clean up"""
 
     def createShell(self):
         return Interpreter()
 
     def addEngine(self, n=1):
         for i in range(n):
             e = es.EngineService()
             e.startService()
             regDict = self.controller.register_engine(es.QueuedEngine(e), None)
             e.id = regDict['id']
             self.engines.append(e)
 
 
 def testf(x):
     return 2.0*x
 
 
 globala = 99
 
 
 def testg(x):
     return  globala*x
 
 
 def isdid(did):
     if not isinstance(did, str):
         return False
     if not len(did)==40:
         return False
     return True
 
 
 def _raise_it(f):
     try:
         f.raiseException()
     except CompositeError, e:
         e.raise_exception()
 
 #-------------------------------------------------------------------------------
 # IMultiEngineTestCase
 #-------------------------------------------------------------------------------
 
 class IMultiEngineTestCase(IMultiEngineBaseTestCase):
     """A test for any object that implements IEngineMultiplexer.
 
     self.multiengine must be defined and implement IEngineMultiplexer.
     """
 
     def testIMultiEngineInterface(self):
         """Does self.engine claim to implement IEngineCore?"""
         self.assert_(me.IEngineMultiplexer.providedBy(self.multiengine))
         self.assert_(me.IMultiEngine.providedBy(self.multiengine))
 
     def testIEngineMultiplexerInterfaceMethods(self):
         """Does self.engine have the methods and attributes in IEngineCore."""
         for m in list(me.IEngineMultiplexer):
             self.assert_(hasattr(self.multiengine, m))
 
     def testIEngineMultiplexerDeferreds(self):
         self.addEngine(1)
         d= self.multiengine.execute('a=5', targets=0)
         d.addCallback(lambda _: self.multiengine.push(dict(a=5),targets=0))
         d.addCallback(lambda _: self.multiengine.push(dict(a=5, b='asdf', c=[1,2,3]),targets=0))
         d.addCallback(lambda _: self.multiengine.pull(('a','b','c'),targets=0))
         d.addCallback(lambda _: self.multiengine.get_result(targets=0))
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.keys(targets=0))
         d.addCallback(lambda _: self.multiengine.push_serialized(dict(a=newserialized.serialize(10)),targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a',targets=0))
         d.addCallback(lambda _: self.multiengine.clear_queue(targets=0))
         d.addCallback(lambda _: self.multiengine.queue_status(targets=0))
         return d
 
     def testInvalidEngineID(self):
          self.addEngine(1)
          badID = 100
          d = self.multiengine.execute('a=5', targets=badID)
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.push(dict(a=5), targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.pull('a', targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.reset(targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.keys(targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.push_serialized(dict(a=newserialized.serialize(10)), targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          d.addCallback(lambda _: self.multiengine.queue_status(targets=badID))
          d.addErrback(lambda f: self.assertRaises(InvalidEngineID, f.raiseException))
          return d
 
     def testNoEnginesRegistered(self):
         badID = 'all'
         d= self.multiengine.execute('a=5', targets=badID)
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.push(dict(a=5), targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.pull('a', targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.get_result(targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.reset(targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.keys(targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.push_serialized(dict(a=newserialized.serialize(10)), targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         d.addCallback(lambda _: self.multiengine.queue_status(targets=badID))
         d.addErrback(lambda f: self.assertRaises(NoEnginesRegistered, f.raiseException))
         return d
 
     def runExecuteAll(self, d, cmd, shell):
         actual = shell.execute(cmd)
         d.addCallback(lambda _: self.multiengine.execute(cmd))
         def compare(result):
             for r in result:
                 actual['id'] = r['id']
                 self.assertEquals(r, actual)
         d.addCallback(compare)
 
     def testExecuteAll(self):
         self.addEngine(4)
         d= defer.Deferred()
         shell = Interpreter()
         for cmd in validCommands:
                 self.runExecuteAll(d, cmd, shell)
         d.callback(None)
         return d
 
     # The following two methods show how to do parametrized
     # tests.  This is really slick!  Same is used above.
     def runExecuteFailures(self, cmd, exc):
         self.addEngine(4)
         d= self.multiengine.execute(cmd)
         d.addErrback(lambda f: self.assertRaises(exc, _raise_it, f))
         return d
 
     @parametric
     def testExecuteFailuresMultiEng(cls):
         return [(cls.runExecuteFailures,cmd,exc) for
                 cmd,exc in invalidCommands]
 
     def testPushPull(self):
         self.addEngine(1)
         objs = [10,"hi there",1.2342354,{"p":(1,2)}]
         d= self.multiengine.push(dict(key=objs[0]), targets=0)
         d.addCallback(lambda _: self.multiengine.pull('key', targets=0))
         d.addCallback(lambda r: self.assertEquals(r, [objs[0]]))
         d.addCallback(lambda _: self.multiengine.push(dict(key=objs[1]), targets=0))
         d.addCallback(lambda _: self.multiengine.pull('key', targets=0))
         d.addCallback(lambda r: self.assertEquals(r, [objs[1]]))
         d.addCallback(lambda _: self.multiengine.push(dict(key=objs[2]), targets=0))
         d.addCallback(lambda _: self.multiengine.pull('key', targets=0))
         d.addCallback(lambda r: self.assertEquals(r, [objs[2]]))
         d.addCallback(lambda _: self.multiengine.push(dict(key=objs[3]), targets=0))
         d.addCallback(lambda _: self.multiengine.pull('key', targets=0))
         d.addCallback(lambda r: self.assertEquals(r, [objs[3]]))
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.pull('a', targets=0))
         d.addErrback(lambda f: self.assertRaises(NameError, _raise_it, f))
         d.addCallback(lambda _: self.multiengine.push(dict(a=10,b=20)))
         d.addCallback(lambda _: self.multiengine.pull(('a','b')))
         d.addCallback(lambda r: self.assertEquals(r, [[10,20]]))
         return d
 
     def testPushPullAll(self):
         self.addEngine(4)
         d= self.multiengine.push(dict(a=10))
         d.addCallback(lambda _: self.multiengine.pull('a'))
         d.addCallback(lambda r: self.assert_(r==[10,10,10,10]))
         d.addCallback(lambda _: self.multiengine.push(dict(a=10, b=20)))
         d.addCallback(lambda _: self.multiengine.pull(('a','b')))
         d.addCallback(lambda r: self.assert_(r==4*[[10,20]]))
         d.addCallback(lambda _: self.multiengine.push(dict(a=10, b=20), targets=0))
         d.addCallback(lambda _: self.multiengine.pull(('a','b'), targets=0))
         d.addCallback(lambda r: self.assert_(r==[[10,20]]))
         d.addCallback(lambda _: self.multiengine.push(dict(a=None, b=None), targets=0))
         d.addCallback(lambda _: self.multiengine.pull(('a','b'), targets=0))
         d.addCallback(lambda r: self.assert_(r==[[None,None]]))
         return d
 
     def testPushPullSerialized(self):
         self.addEngine(1)
         objs = [10,"hi there",1.2342354,{"p":(1,2)}]
         d= self.multiengine.push_serialized(dict(key=newserialized.serialize(objs[0])), targets=0)
         d.addCallback(lambda _: self.multiengine.pull_serialized('key', targets=0))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, objs[0]))
         d.addCallback(lambda _: self.multiengine.push_serialized(dict(key=newserialized.serialize(objs[1])), targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('key', targets=0))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, objs[1]))
         d.addCallback(lambda _: self.multiengine.push_serialized(dict(key=newserialized.serialize(objs[2])), targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('key', targets=0))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, objs[2]))
         d.addCallback(lambda _: self.multiengine.push_serialized(dict(key=newserialized.serialize(objs[3])), targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('key', targets=0))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, objs[3]))
         d.addCallback(lambda _: self.multiengine.push(dict(a=10,b=range(5)), targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized(('a','b'), targets=0))
         d.addCallback(lambda serial: [newserialized.IUnSerialized(s).getObject() for s in serial[0]])
         d.addCallback(lambda r: self.assertEquals(r, [10, range(5)]))
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=0))
         d.addErrback(lambda f: self.assertRaises(NameError, _raise_it, f))
         return d
 
         objs = [10,"hi there",1.2342354,{"p":(1,2)}]
         d= defer.succeed(None)
         for o in objs:
             self.multiengine.push_serialized(0, key=newserialized.serialize(o))
             value = self.multiengine.pull_serialized(0, 'key')
             value.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
             d = self.assertDeferredEquals(value,o,d)
         return d
 
     def runGetResultAll(self, d, cmd, shell):
         actual = shell.execute(cmd)
         d.addCallback(lambda _: self.multiengine.execute(cmd))
         d.addCallback(lambda _: self.multiengine.get_result())
         def compare(result):
             for r in result:
                 actual['id'] = r['id']
                 self.assertEquals(r, actual)
         d.addCallback(compare)
 
     def testGetResultAll(self):
         self.addEngine(4)
         d= defer.Deferred()
         shell = Interpreter()
         for cmd in validCommands:
                 self.runGetResultAll(d, cmd, shell)
         d.callback(None)
         return d
 
     def testGetResultDefault(self):
         self.addEngine(1)
         target = 0
         cmd = 'a=5'
         shell = self.createShell()
         shellResult = shell.execute(cmd)
         def popit(dikt, key):
             dikt.pop(key)
             return dikt
         d= self.multiengine.execute(cmd, targets=target)
         d.addCallback(lambda _: self.multiengine.get_result(targets=target))
         d.addCallback(lambda r: self.assertEquals(shellResult, popit(r[0],'id')))
         return d
 
     def testGetResultFailure(self):
         self.addEngine(1)
         d= self.multiengine.get_result(None, targets=0)
         d.addErrback(lambda f: self.assertRaises(IndexError, _raise_it, f))
         d.addCallback(lambda _: self.multiengine.get_result(10, targets=0))
         d.addErrback(lambda f: self.assertRaises(IndexError, _raise_it, f))
         return d
 
     def testPushFunction(self):
         self.addEngine(1)
         d= self.multiengine.push_function(dict(f=testf), targets=0)
         d.addCallback(lambda _: self.multiengine.execute('result = f(10)', targets=0))
         d.addCallback(lambda _: self.multiengine.pull('result', targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0], testf(10)))
         d.addCallback(lambda _: self.multiengine.push(dict(globala=globala), targets=0))
         d.addCallback(lambda _: self.multiengine.push_function(dict(g=testg), targets=0))
         d.addCallback(lambda _: self.multiengine.execute('result = g(10)', targets=0))
         d.addCallback(lambda _: self.multiengine.pull('result', targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0], testg(10)))
         return d
 
     def testPullFunction(self):
         self.addEngine(1)
         d= self.multiengine.push(dict(a=globala), targets=0)
         d.addCallback(lambda _: self.multiengine.push_function(dict(f=testf), targets=0))
         d.addCallback(lambda _: self.multiengine.pull_function('f', targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0](10), testf(10)))
         d.addCallback(lambda _: self.multiengine.execute("def g(x): return x*x", targets=0))
         d.addCallback(lambda _: self.multiengine.pull_function(('f','g'),targets=0))
         d.addCallback(lambda r: self.assertEquals((r[0][0](10),r[0][1](10)), (testf(10), 100)))
         return d
 
     def testPushFunctionAll(self):
         self.addEngine(4)
         d= self.multiengine.push_function(dict(f=testf))
         d.addCallback(lambda _: self.multiengine.execute('result = f(10)'))
         d.addCallback(lambda _: self.multiengine.pull('result'))
         d.addCallback(lambda r: self.assertEquals(r, 4*[testf(10)]))
         d.addCallback(lambda _: self.multiengine.push(dict(globala=globala)))
         d.addCallback(lambda _: self.multiengine.push_function(dict(testg=testg)))
         d.addCallback(lambda _: self.multiengine.execute('result = testg(10)'))
         d.addCallback(lambda _: self.multiengine.pull('result'))
         d.addCallback(lambda r: self.assertEquals(r, 4*[testg(10)]))
         return d
 
     def testPullFunctionAll(self):
         self.addEngine(4)
         d= self.multiengine.push_function(dict(f=testf))
         d.addCallback(lambda _: self.multiengine.pull_function('f'))
         d.addCallback(lambda r: self.assertEquals([func(10) for func in r], 4*[testf(10)]))
         return d
 
     def testGetIDs(self):
         self.addEngine(1)
         d= self.multiengine.get_ids()
         d.addCallback(lambda r: self.assertEquals(r, [0]))
         d.addCallback(lambda _: self.addEngine(3))
         d.addCallback(lambda _: self.multiengine.get_ids())
         d.addCallback(lambda r: self.assertEquals(r, [0,1,2,3]))
         return d
 
     def testClearQueue(self):
         self.addEngine(4)
         d= self.multiengine.clear_queue()
         d.addCallback(lambda r: self.assertEquals(r,4*[None]))
         return d
 
     def testQueueStatus(self):
         self.addEngine(4)
         d= self.multiengine.queue_status(targets=0)
         d.addCallback(lambda r: self.assert_(isinstance(r[0],tuple)))
         return d
 
     def testGetSetProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.get_properties())
         d.addCallback(lambda r: self.assertEquals(r, 4*[dikt]))
         d.addCallback(lambda r: self.multiengine.get_properties(('c',)))
         d.addCallback(lambda r: self.assertEquals(r, 4*[{'c': dikt['c']}]))
         d.addCallback(lambda r: self.multiengine.set_properties(dict(c=False)))
         d.addCallback(lambda r: self.multiengine.get_properties(('c', 'd')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[dict(c=False, d=None)]))
         return d
 
     def testClearProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.clear_properties())
         d.addCallback(lambda r: self.multiengine.get_properties())
         d.addCallback(lambda r: self.assertEquals(r, 4*[{}]))
         return d
 
     def testDelHasProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.del_properties(('b','e')))
         d.addCallback(lambda r: self.multiengine.has_properties(('a','b','c','d','e')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[True, False, True, True, False]]))
         return d
 
 Parametric(IMultiEngineTestCase)
 
 #-------------------------------------------------------------------------------
 # ISynchronousMultiEngineTestCase
 #-------------------------------------------------------------------------------
 
 class ISynchronousMultiEngineTestCase(IMultiEngineBaseTestCase):
 
     def testISynchronousMultiEngineInterface(self):
         """Does self.engine claim to implement IEngineCore?"""
         self.assert_(me.ISynchronousEngineMultiplexer.providedBy(self.multiengine))
         self.assert_(me.ISynchronousMultiEngine.providedBy(self.multiengine))
 
     def testExecute(self):
         self.addEngine(4)
         execute = self.multiengine.execute
         d= execute('a=5', targets=0, block=True)
         d.addCallback(lambda r: self.assert_(len(r)==1))
         d.addCallback(lambda _: execute('b=10'))
         d.addCallback(lambda r: self.assert_(len(r)==4))
         d.addCallback(lambda _: execute('c=30', block=False))
         d.addCallback(lambda did: self.assert_(isdid(did)))
         d.addCallback(lambda _: execute('d=[0,1,2]', block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assert_(len(r)==4))
         return d
 
     def testPushPull(self):
         data = dict(a=10, b=1.05, c=range(10), d={'e':(1,2),'f':'hi'})
         self.addEngine(4)
         push = self.multiengine.push
         pull = self.multiengine.pull
         d= push({'data':data}, targets=0)
         d.addCallback(lambda r: pull('data', targets=0))
         d.addCallback(lambda r: self.assertEqual(r,[data]))
         d.addCallback(lambda _: push({'data':data}))
         d.addCallback(lambda r: pull('data'))
         d.addCallback(lambda r: self.assertEqual(r,4*[data]))
         d.addCallback(lambda _: push({'data':data}, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda _: pull('data', block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEqual(r,4*[data]))
         d.addCallback(lambda _: push(dict(a=10,b=20)))
         d.addCallback(lambda _: pull(('a','b')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[10,20]]))
         return d
 
     def testPushPullFunction(self):
         self.addEngine(4)
         pushf = self.multiengine.push_function
         pullf = self.multiengine.pull_function
         push = self.multiengine.push
         pull = self.multiengine.pull
         execute = self.multiengine.execute
         d= pushf({'testf':testf}, targets=0)
         d.addCallback(lambda r: pullf('testf', targets=0))
         d.addCallback(lambda r: self.assertEqual(r[0](1.0), testf(1.0)))
         d.addCallback(lambda _: execute('r = testf(10)', targets=0))
         d.addCallback(lambda _: pull('r', targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0], testf(10)))
         d.addCallback(lambda _: pushf({'testf':testf}, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda _: pullf('testf', block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEqual(r[0](1.0), testf(1.0)))
         d.addCallback(lambda _: execute("def g(x): return x*x", targets=0))
         d.addCallback(lambda _: pullf(('testf','g'),targets=0))
         d.addCallback(lambda r: self.assertEquals((r[0][0](10),r[0][1](10)), (testf(10), 100)))
         return d
 
     def testGetResult(self):
         shell = Interpreter()
         result1 = shell.execute('a=10')
         result1['id'] = 0
         result2 = shell.execute('b=20')
         result2['id'] = 0
         execute= self.multiengine.execute
         get_result = self.multiengine.get_result
         self.addEngine(1)
         d= execute('a=10')
         d.addCallback(lambda _: get_result())
         d.addCallback(lambda r: self.assertEquals(r[0], result1))
         d.addCallback(lambda _: execute('b=20'))
         d.addCallback(lambda _: get_result(1))
         d.addCallback(lambda r: self.assertEquals(r[0], result1))
         d.addCallback(lambda _: get_result(2, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r[0], result2))
         return d
 
     def testResetAndKeys(self):
         self.addEngine(1)
 
         #Blocking mode
         d= self.multiengine.push(dict(a=10, b=20, c=range(10)), targets=0)
         d.addCallback(lambda _: self.multiengine.keys(targets=0))
         def keys_found(keys):
             self.assert_('a' in keys[0])
             self.assert_('b' in keys[0])
             self.assert_('b' in keys[0])
         d.addCallback(keys_found)
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.keys(targets=0))
         def keys_not_found(keys):
             self.assert_('a' not in keys[0])
             self.assert_('b' not in keys[0])
             self.assert_('b' not in keys[0])
         d.addCallback(keys_not_found)
 
         #Non-blocking mode
         d.addCallback(lambda _: self.multiengine.push(dict(a=10, b=20, c=range(10)), targets=0))
         d.addCallback(lambda _: self.multiengine.keys(targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         def keys_found(keys):
             self.assert_('a' in keys[0])
             self.assert_('b' in keys[0])
             self.assert_('b' in keys[0])
         d.addCallback(keys_found)
         d.addCallback(lambda _: self.multiengine.reset(targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda _: self.multiengine.keys(targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         def keys_not_found(keys):
             self.assert_('a' not in keys[0])
             self.assert_('b' not in keys[0])
             self.assert_('b' not in keys[0])
         d.addCallback(keys_not_found)
 
         return d
 
     def testPushPullSerialized(self):
         self.addEngine(1)
         dikt = dict(a=10,b='hi there',c=1.2345,d={'p':(1,2)})
         sdikt = {}
         for k,v in dikt.iteritems():
             sdikt[k] = newserialized.serialize(v)
         d= self.multiengine.push_serialized(dict(a=sdikt['a']), targets=0)
         d.addCallback(lambda _: self.multiengine.pull('a',targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0], dikt['a']))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=0))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, dikt['a']))
         d.addCallback(lambda _: self.multiengine.push_serialized(sdikt, targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized(sdikt.keys(), targets=0))
         d.addCallback(lambda serial: [newserialized.IUnSerialized(s).getObject() for s in serial[0]])
         d.addCallback(lambda r: self.assertEquals(r, dikt.values()))
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=0))
         d.addErrback(lambda f: self.assertRaises(NameError, _raise_it, f))
 
         #Non-blocking mode
         d.addCallback(lambda r: self.multiengine.push_serialized(dict(a=sdikt['a']), targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda _: self.multiengine.pull('a',targets=0))
         d.addCallback(lambda r: self.assertEquals(r[0], dikt['a']))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda serial: newserialized.IUnSerialized(serial[0]).getObject())
         d.addCallback(lambda r: self.assertEquals(r, dikt['a']))
         d.addCallback(lambda _: self.multiengine.push_serialized(sdikt, targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda _: self.multiengine.pull_serialized(sdikt.keys(), targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda serial: [newserialized.IUnSerialized(s).getObject() for s in serial[0]])
         d.addCallback(lambda r: self.assertEquals(r, dikt.values()))
         d.addCallback(lambda _: self.multiengine.reset(targets=0))
         d.addCallback(lambda _: self.multiengine.pull_serialized('a', targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addErrback(lambda f: self.assertRaises(NameError, _raise_it, f))
         return d
 
     def testClearQueue(self):
         self.addEngine(4)
         d= self.multiengine.clear_queue()
         d.addCallback(lambda r: self.multiengine.clear_queue(block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r,4*[None]))
         return d
 
     def testQueueStatus(self):
         self.addEngine(4)
         d= self.multiengine.queue_status(targets=0)
         d.addCallback(lambda r: self.assert_(isinstance(r[0],tuple)))
         d.addCallback(lambda r: self.multiengine.queue_status(targets=0, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assert_(isinstance(r[0],tuple)))
         return d
 
     def testGetIDs(self):
         self.addEngine(1)
         d= self.multiengine.get_ids()
         d.addCallback(lambda r: self.assertEquals(r, [0]))
         d.addCallback(lambda _: self.addEngine(3))
         d.addCallback(lambda _: self.multiengine.get_ids())
         d.addCallback(lambda r: self.assertEquals(r, [0,1,2,3]))
         return d
 
     def testGetSetProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.get_properties())
         d.addCallback(lambda r: self.assertEquals(r, 4*[dikt]))
         d.addCallback(lambda r: self.multiengine.get_properties(('c',)))
         d.addCallback(lambda r: self.assertEquals(r, 4*[{'c': dikt['c']}]))
         d.addCallback(lambda r: self.multiengine.set_properties(dict(c=False)))
         d.addCallback(lambda r: self.multiengine.get_properties(('c', 'd')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[dict(c=False, d=None)]))
 
         #Non-blocking
         d.addCallback(lambda r: self.multiengine.set_properties(dikt, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.get_properties(block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, 4*[dikt]))
         d.addCallback(lambda r: self.multiengine.get_properties(('c',), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, 4*[{'c': dikt['c']}]))
         d.addCallback(lambda r: self.multiengine.set_properties(dict(c=False), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.get_properties(('c', 'd'), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, 4*[dict(c=False, d=None)]))
         return d
 
     def testClearProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.clear_properties())
         d.addCallback(lambda r: self.multiengine.get_properties())
         d.addCallback(lambda r: self.assertEquals(r, 4*[{}]))
 
         #Non-blocking
         d.addCallback(lambda r: self.multiengine.set_properties(dikt, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.clear_properties(block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.get_properties(block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, 4*[{}]))
         return d
 
     def testDelHasProperties(self):
         self.addEngine(4)
         dikt = dict(a=5, b='asdf', c=True, d=None, e=range(5))
         d= self.multiengine.set_properties(dikt)
         d.addCallback(lambda r: self.multiengine.del_properties(('b','e')))
         d.addCallback(lambda r: self.multiengine.has_properties(('a','b','c','d','e')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[True, False, True, True, False]]))
 
         #Non-blocking
         d.addCallback(lambda r: self.multiengine.set_properties(dikt, block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.del_properties(('b','e'), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.has_properties(('a','b','c','d','e'), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[True, False, True, True, False]]))
         return d
 
     def test_clear_pending_deferreds(self):
         self.addEngine(4)
         did_list = []
         d= self.multiengine.execute('a=10',block=False)
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.push(dict(b=10),block=False))
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.pull(('a','b'),block=False))
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.clear_pending_deferreds())
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[0],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[1],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[2],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         return d
 
 #-------------------------------------------------------------------------------
 # Coordinator test cases
 #-------------------------------------------------------------------------------
 
 class IMultiEngineCoordinatorTestCase(object):
 
     def testScatterGather(self):
         self.addEngine(4)
         d= self.multiengine.scatter('a', range(16))
         d.addCallback(lambda r: self.multiengine.gather('a'))
         d.addCallback(lambda r: self.assertEquals(r, range(16)))
         d.addCallback(lambda _: self.multiengine.gather('asdf'))
         d.addErrback(lambda f: self.assertRaises(NameError, _raise_it, f))
         return d
 
     def testScatterGatherNumpy(self):
         try:
             import numpy
             from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
         except:
             return
         else:
             self.addEngine(4)
             a = numpy.arange(16)
             d = self.multiengine.scatter('a', a)
             d.addCallback(lambda r: self.multiengine.gather('a'))
             d.addCallback(lambda r: assert_array_equal(r, a))
             return d
 
     def testMap(self):
         self.addEngine(4)
         def f(x):
             return x**2
         data = range(16)
         d= self.multiengine.map(f, data)
         d.addCallback(lambda r: self.assertEquals(r,[f(x) for x in data]))
         return d
 
 
 class ISynchronousMultiEngineCoordinatorTestCase(IMultiEngineCoordinatorTestCase):
 
     def testScatterGatherNonblocking(self):
         self.addEngine(4)
         d= self.multiengine.scatter('a', range(16), block=False)
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.gather('a', block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assertEquals(r, range(16)))
         return d
     
     def testScatterGatherNumpyNonblocking(self):
         try:
             import numpy
             from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
         except:
             return
         else:
             self.addEngine(4)
             a = numpy.arange(16)
             d = self.multiengine.scatter('a', a, block=False)
             d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
             d.addCallback(lambda r: self.multiengine.gather('a', block=False))
             d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
             d.addCallback(lambda r: assert_array_equal(r, a))
             return d
     
     def test_clear_pending_deferreds(self):
         self.addEngine(4)
         did_list = []
         d= self.multiengine.scatter('a',range(16),block=False)
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.gather('a',block=False))
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.map(lambda x: x, range(16),block=False))
         d.addCallback(lambda did: did_list.append(did))
         d.addCallback(lambda _: self.multiengine.clear_pending_deferreds())
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[0],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[1],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         d.addCallback(lambda _: self.multiengine.get_pending_deferred(did_list[2],True))
         d.addErrback(lambda f: self.assertRaises(InvalidDeferredID, f.raiseException))
         return d
 
 #-------------------------------------------------------------------------------
 # Extras test cases
 #-------------------------------------------------------------------------------
 
 class IMultiEngineExtrasTestCase(object):
 
     def testZipPull(self):
         self.addEngine(4)
         d= self.multiengine.push(dict(a=10,b=20))
         d.addCallback(lambda r: self.multiengine.zip_pull(('a','b')))
         d.addCallback(lambda r: self.assert_(r, [4*[10],4*[20]]))
         return d
 
     def testRun(self):
         self.addEngine(4)
         import tempfile
         fname = tempfile.mktemp('foo.py')
         f= open(fname, 'w')
         f.write('a = 10\nb=30')
         f.close()
         d= self.multiengine.run(fname)
         d.addCallback(lambda r: self.multiengine.pull(('a','b')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[10,30]]))
         return d
 
 
 class ISynchronousMultiEngineExtrasTestCase(IMultiEngineExtrasTestCase):
 
     def testZipPullNonblocking(self):
         self.addEngine(4)
         d= self.multiengine.push(dict(a=10,b=20))
         d.addCallback(lambda r: self.multiengine.zip_pull(('a','b'), block=False))
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.assert_(r, [4*[10],4*[20]]))
         return d
 
     def testRunNonblocking(self):
         self.addEngine(4)
         import tempfile
         fname = tempfile.mktemp('foo.py')
         f= open(fname, 'w')
         f.write('a = 10\nb=30')
         f.close()
         d= self.multiengine.run(fname, block=False)
         d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
         d.addCallback(lambda r: self.multiengine.pull(('a','b')))
         d.addCallback(lambda r: self.assertEquals(r, 4*[[10,30]]))
         return d
 
 
 #-------------------------------------------------------------------------------
 # IFullSynchronousMultiEngineTestCase
 #-------------------------------------------------------------------------------
 
 class IFullSynchronousMultiEngineTestCase(ISynchronousMultiEngineTestCase,
     ISynchronousMultiEngineCoordinatorTestCase,
     ISynchronousMultiEngineExtrasTestCase):
     pass

IPython/kernel/tests/test_controllerservice.py

@@ -1,43 +1,44 b''
 # encoding: utf-8
 
 """This file contains unittests for the kernel.engineservice.py module.
 
 Things that should be tested:
 
  - Should the EngineService return Deferred objects?
  - Run the same tests that are run in shell.py.
  - Make sure that the Interface is really implemented.
  - The startService and stopService methods.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 try:
     from twisted.application.service import IService
     from IPython.kernel.controllerservice import ControllerService
     from IPython.kernel.tests import multienginetest as met
     from controllertest import IControllerCoreTestCase
     from IPython.testing.util import DeferredTestCase
 except ImportError:
-    pass
-else:
-    class BasicControllerServiceTest(DeferredTestCase,
-        IControllerCoreTestCase):
-    
-        def setUp(self):
-            self.controller  = ControllerService()
-            self.controller.startService()
-    
-        def tearDown(self):
-            self.controller.stopService()
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
+
+class BasicControllerServiceTest(DeferredTestCase,
+    IControllerCoreTestCase):
+
+    def setUp(self):
+        self.controller  = ControllerService()
+        self.controller.startService()
+
+    def tearDown(self):
+        self.controller.stopService()

IPython/kernel/tests/test_enginefc.py

@@ -1,92 +1,93 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
-else:
-    class EngineFCTest(DeferredTestCase, 
-                       IEngineCoreTestCase, 
-                       IEngineSerializedTestCase,
-                       IEngineQueuedTestCase
-                       ):
-        
-        zi.implements(IControllerBase)
-        
-        def setUp(self):
-        
-            # Start a server and append to self.servers
-            self.controller_reference = FCRemoteEngineRefFromService(self)
-            self.controller_tub = Tub()
-            self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
-            self.controller_tub.setLocation('127.0.0.1:10105')
-            
-            furl = self.controller_tub.registerReference(self.controller_reference)
-            self.controller_tub.startService()
-            
-            # Start an EngineService and append to services/client
-            self.engine_service = es.EngineService()
-            self.engine_service.startService()
-            self.engine_tub = Tub()
-            self.engine_tub.startService()
-            engine_connector = EngineConnector(self.engine_tub)
-            d = engine_connector.connect_to_controller(self.engine_service, furl)
-            # This deferred doesn't fire until after register_engine has returned and
-            # thus, self.engine has been defined and the tets can proceed.
-            return d
-        
-        def tearDown(self):
-            dlist = []
-            # Shut down the engine
-            d = self.engine_tub.stopService()
-            dlist.append(d)
-            # Shut down the controller
-            d = self.controller_tub.stopService()
-            dlist.append(d)
-            return defer.DeferredList(dlist)
-        
-        #---------------------------------------------------------------------------
-        # Make me look like a basic controller
-        #---------------------------------------------------------------------------
-        
-        def register_engine(self, engine_ref, id=None, ip=None, port=None, pid=None):
-            self.engine = IEngineQueued(IEngineBase(engine_ref))
-            return {'id':id}
-        
-        def unregister_engine(self, id):
-            pass
  No newline at end of file
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
+
+
+class EngineFCTest(DeferredTestCase, 
+                 IEngineCoreTestCase, 
+                 IEngineSerializedTestCase,
+                 IEngineQueuedTestCase
+                 ):
+ 
+  zi.implements(IControllerBase)
+ 
+  def setUp(self):
+ 
+      # Start a server and append to self.servers
+      self.controller_reference = FCRemoteEngineRefFromService(self)
+      self.controller_tub = Tub()
+      self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
+      self.controller_tub.setLocation('127.0.0.1:10105')
+     
+      furl = self.controller_tub.registerReference(self.controller_reference)
+      self.controller_tub.startService()
+     
+      # Start an EngineService and append to services/client
+      self.engine_service = es.EngineService()
+      self.engine_service.startService()
+      self.engine_tub = Tub()
+      self.engine_tub.startService()
+      engine_connector = EngineConnector(self.engine_tub)
+      d = engine_connector.connect_to_controller(self.engine_service, furl)
+      # This deferred doesn't fire until after register_engine has returned and
+      # thus, self.engine has been defined and the tets can proceed.
+      return d
+ 
+  def tearDown(self):
+      dlist = []
+      # Shut down the engine
+      d = self.engine_tub.stopService()
+      dlist.append(d)
+      # Shut down the controller
+      d = self.controller_tub.stopService()
+      dlist.append(d)
+      return defer.DeferredList(dlist)
+ 
+  #---------------------------------------------------------------------------
+  # Make me look like a basic controller
+  #---------------------------------------------------------------------------
+ 
+  def register_engine(self, engine_ref, id=None, ip=None, port=None, pid=None):
+      self.engine = IEngineQueued(IEngineBase(engine_ref))
+      return {'id':id}
+ 
+  def unregister_engine(self, id):
+      pass
  No newline at end of file

IPython/kernel/tests/test_engineservice.py

@@ -1,78 +1,80 b''
 # encoding: utf-8
 
 """This file contains unittests for the kernel.engineservice.py module.
 
 Things that should be tested:
 
  - Should the EngineService return Deferred objects?
  - Run the same tests that are run in shell.py.
  - Make sure that the Interface is really implemented.
  - The startService and stopService methods.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 try:
     from twisted.internet import defer
     from twisted.application.service import IService
     
     from IPython.kernel import engineservice as es
     from IPython.testing.util import DeferredTestCase
     from IPython.kernel.tests.engineservicetest import \
         IEngineCoreTestCase, \
         IEngineSerializedTestCase, \
         IEngineQueuedTestCase, \
         IEnginePropertiesTestCase
 except ImportError:
-    pass
-else:
-    class BasicEngineServiceTest(DeferredTestCase,
-                                 IEngineCoreTestCase, 
-                                 IEngineSerializedTestCase,
-                                 IEnginePropertiesTestCase):
-    
-        def setUp(self):
-            self.engine = es.EngineService()
-            self.engine.startService()
-    
-        def tearDown(self):
-            return self.engine.stopService()
-    
-    class ThreadedEngineServiceTest(DeferredTestCase,
-                                 IEngineCoreTestCase, 
-                                 IEngineSerializedTestCase,
-                                 IEnginePropertiesTestCase):
-    
-        def setUp(self):
-            self.engine = es.ThreadedEngineService()
-            self.engine.startService()
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")    
+
+
+class BasicEngineServiceTest(DeferredTestCase,
+                             IEngineCoreTestCase, 
+                             IEngineSerializedTestCase,
+                             IEnginePropertiesTestCase):
+
+    def setUp(self):
+        self.engine = es.EngineService()
+        self.engine.startService()
+
+    def tearDown(self):
+        return self.engine.stopService()
+
+class ThreadedEngineServiceTest(DeferredTestCase,
+                             IEngineCoreTestCase, 
+                             IEngineSerializedTestCase,
+                             IEnginePropertiesTestCase):
+
+    def setUp(self):
+        self.engine = es.ThreadedEngineService()
+        self.engine.startService()
+
+    def tearDown(self):
+        return self.engine.stopService()
+
+class QueuedEngineServiceTest(DeferredTestCase,
+                              IEngineCoreTestCase, 
+                              IEngineSerializedTestCase,
+                              IEnginePropertiesTestCase,
+                              IEngineQueuedTestCase):
+                          
+    def setUp(self):
+        self.rawEngine = es.EngineService()
+        self.rawEngine.startService()
+        self.engine = es.IEngineQueued(self.rawEngine)
     
-        def tearDown(self):
-            return self.engine.stopService()
-
-    class QueuedEngineServiceTest(DeferredTestCase,
-                                  IEngineCoreTestCase, 
-                                  IEngineSerializedTestCase,
-                                  IEnginePropertiesTestCase,
-                                  IEngineQueuedTestCase):
-                              
-        def setUp(self):
-            self.rawEngine = es.EngineService()
-            self.rawEngine.startService()
-            self.engine = es.IEngineQueued(self.rawEngine)
-        
-        def tearDown(self):
-            return self.rawEngine.stopService()
-
- 
+    def tearDown(self):
+        return self.rawEngine.stopService()
+
+

IPython/kernel/tests/test_multiengine.py

@@ -1,54 +1,56 b''
 # encoding: utf-8
 
 """"""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 try:
     from twisted.internet import defer
     from IPython.testing.util import DeferredTestCase
     from IPython.kernel.controllerservice import ControllerService
     from IPython.kernel import multiengine as me
     from IPython.kernel.tests.multienginetest import (IMultiEngineTestCase,
         ISynchronousMultiEngineTestCase)
 except ImportError:
-    pass
-else:    
-    class BasicMultiEngineTestCase(DeferredTestCase, IMultiEngineTestCase):
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
+
+ 
+class BasicMultiEngineTestCase(DeferredTestCase, IMultiEngineTestCase):
+
+    def setUp(self):
+        self.controller = ControllerService()
+        self.controller.startService()
+        self.multiengine = me.IMultiEngine(self.controller)
+        self.engines = []
     
-        def setUp(self):
-            self.controller = ControllerService()
-            self.controller.startService()
-            self.multiengine = me.IMultiEngine(self.controller)
-            self.engines = []
-        
-        def tearDown(self):
-            self.controller.stopService()
-            for e in self.engines:
-                e.stopService()
-
-
-    class SynchronousMultiEngineTestCase(DeferredTestCase, ISynchronousMultiEngineTestCase):
+    def tearDown(self):
+        self.controller.stopService()
+        for e in self.engines:
+            e.stopService()
+
+
+class SynchronousMultiEngineTestCase(DeferredTestCase, ISynchronousMultiEngineTestCase):
+
+    def setUp(self):
+        self.controller = ControllerService()
+        self.controller.startService()
+        self.multiengine = me.ISynchronousMultiEngine(me.IMultiEngine(self.controller))
+        self.engines = []
     
-        def setUp(self):
-            self.controller = ControllerService()
-            self.controller.startService()
-            self.multiengine = me.ISynchronousMultiEngine(me.IMultiEngine(self.controller))
-            self.engines = []
-        
-        def tearDown(self):
-            self.controller.stopService()
-            for e in self.engines:
-                e.stopService()
+    def tearDown(self):
+        self.controller.stopService()
+        for e in self.engines:
+            e.stopService()
 

IPython/kernel/tests/test_multienginefc.py

@@ -1,144 +1,144 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 try:
     from twisted.internet import defer, reactor
 
     from IPython.kernel.fcutil import Tub, UnauthenticatedTub
 
     from IPython.testing.util import DeferredTestCase
     from IPython.kernel.controllerservice import ControllerService
     from IPython.kernel.multiengine import IMultiEngine
     from IPython.kernel.tests.multienginetest import IFullSynchronousMultiEngineTestCase
     from IPython.kernel.multienginefc import IFCSynchronousMultiEngine
     from IPython.kernel import multiengine as me
     from IPython.kernel.clientconnector import ClientConnector
     from IPython.kernel.parallelfunction import ParallelFunction
     from IPython.kernel.error import CompositeError
     from IPython.kernel.util import printer
 except ImportError:
-    pass
-else:
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
     
-    def _raise_it(f):
-        try:
-            f.raiseException()
-        except CompositeError, e:
-            e.raise_exception()
+def _raise_it(f):
+    try:
+        f.raiseException()
+    except CompositeError, e:
+        e.raise_exception()
+
+
+class FullSynchronousMultiEngineTestCase(DeferredTestCase, IFullSynchronousMultiEngineTestCase):
+
+    def setUp(self):
     
+        self.engines = []
+            
+        self.controller = ControllerService()
+        self.controller.startService()
+        self.imultiengine = IMultiEngine(self.controller)
+        self.mec_referenceable = IFCSynchronousMultiEngine(self.imultiengine)
+
+        self.controller_tub = Tub()
+        self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
+        self.controller_tub.setLocation('127.0.0.1:10105')
     
-    class FullSynchronousMultiEngineTestCase(DeferredTestCase, IFullSynchronousMultiEngineTestCase):
+        furl = self.controller_tub.registerReference(self.mec_referenceable)
+        self.controller_tub.startService()
     
-        def setUp(self):
-        
-            self.engines = []
-                
-            self.controller = ControllerService()
-            self.controller.startService()
-            self.imultiengine = IMultiEngine(self.controller)
-            self.mec_referenceable = IFCSynchronousMultiEngine(self.imultiengine)
-
-            self.controller_tub = Tub()
-            self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
-            self.controller_tub.setLocation('127.0.0.1:10105')
-        
-            furl = self.controller_tub.registerReference(self.mec_referenceable)
-            self.controller_tub.startService()
-        
-            self.client_tub = ClientConnector()
-            d = self.client_tub.get_multiengine_client(furl)
-            d.addCallback(self.handle_got_client)
-            return d
-        
-        def handle_got_client(self, client):
-            self.multiengine = client
+        self.client_tub = ClientConnector()
+        d = self.client_tub.get_multiengine_client(furl)
+        d.addCallback(self.handle_got_client)
+        return d
     
-        def tearDown(self):
-            dlist = []
-            # Shut down the multiengine client
-            d = self.client_tub.tub.stopService()
-            dlist.append(d)
-            # Shut down the engines
-            for e in self.engines:
-                e.stopService()
-            # Shut down the controller
-            d = self.controller_tub.stopService()
-            d.addBoth(lambda _: self.controller.stopService())
-            dlist.append(d)
-            return defer.DeferredList(dlist)
+    def handle_got_client(self, client):
+        self.multiengine = client
+
+    def tearDown(self):
+        dlist = []
+        # Shut down the multiengine client
+        d = self.client_tub.tub.stopService()
+        dlist.append(d)
+        # Shut down the engines
+        for e in self.engines:
+            e.stopService()
+        # Shut down the controller
+        d = self.controller_tub.stopService()
+        d.addBoth(lambda _: self.controller.stopService())
+        dlist.append(d)
+        return defer.DeferredList(dlist)
 
-        def test_mapper(self):
-            self.addEngine(4)
-            m = self.multiengine.mapper()
-            self.assertEquals(m.multiengine,self.multiengine)
-            self.assertEquals(m.dist,'b')
-            self.assertEquals(m.targets,'all')
-            self.assertEquals(m.block,True)
-        
-        def test_map_default(self):
-            self.addEngine(4)
-            m = self.multiengine.mapper()
-            d = m.map(lambda x: 2*x, range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            d.addCallback(lambda _: self.multiengine.map(lambda x: 2*x, range(10)))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-        
-        def test_map_noblock(self):
-            self.addEngine(4)
-            m = self.multiengine.mapper(block=False)
-            d = m.map(lambda x: 2*x, range(10))
-            d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-                
-        def test_mapper_fail(self):
-            self.addEngine(4)
-            m = self.multiengine.mapper()
-            d = m.map(lambda x: 1/0, range(10))
-            d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
-            return d
-        
-        def test_parallel(self):
-            self.addEngine(4)
-            p = self.multiengine.parallel()
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 2*x
-            d = f(range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-        
-        def test_parallel_noblock(self):
-            self.addEngine(1)
-            p = self.multiengine.parallel(block=False)
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 2*x
-            d = f(range(10))
-            d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-        
-        def test_parallel_fail(self):
-            self.addEngine(4)
-            p = self.multiengine.parallel()
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 1/0
-            d = f(range(10))
-            d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
-            return d
  No newline at end of file
+    def test_mapper(self):
+        self.addEngine(4)
+        m = self.multiengine.mapper()
+        self.assertEquals(m.multiengine,self.multiengine)
+        self.assertEquals(m.dist,'b')
+        self.assertEquals(m.targets,'all')
+        self.assertEquals(m.block,True)
+    
+    def test_map_default(self):
+        self.addEngine(4)
+        m = self.multiengine.mapper()
+        d = m.map(lambda x: 2*x, range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        d.addCallback(lambda _: self.multiengine.map(lambda x: 2*x, range(10)))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
+    
+    def test_map_noblock(self):
+        self.addEngine(4)
+        m = self.multiengine.mapper(block=False)
+        d = m.map(lambda x: 2*x, range(10))
+        d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
+            
+    def test_mapper_fail(self):
+        self.addEngine(4)
+        m = self.multiengine.mapper()
+        d = m.map(lambda x: 1/0, range(10))
+        d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
+        return d
+    
+    def test_parallel(self):
+        self.addEngine(4)
+        p = self.multiengine.parallel()
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 2*x
+        d = f(range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
+    
+    def test_parallel_noblock(self):
+        self.addEngine(1)
+        p = self.multiengine.parallel(block=False)
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 2*x
+        d = f(range(10))
+        d.addCallback(lambda did: self.multiengine.get_pending_deferred(did, True))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
+    
+    def test_parallel_fail(self):
+        self.addEngine(4)
+        p = self.multiengine.parallel()
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 1/0
+        d = f(range(10))
+        d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
+        return d
  No newline at end of file

IPython/kernel/tests/test_newserialized.py

@@ -1,102 +1,102 b''
 # encoding: utf-8
 
 """This file contains unittests for the shell.py module."""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 try:
     import zope.interface as zi
     from twisted.trial import unittest
     from IPython.testing.util import DeferredTestCase
 
     from IPython.kernel.newserialized import \
         ISerialized, \
         IUnSerialized, \
         Serialized, \
         UnSerialized, \
         SerializeIt, \
         UnSerializeIt
 except ImportError:
-    pass
-else:
-    #-------------------------------------------------------------------------------
-    # Tests
-    #-------------------------------------------------------------------------------
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
+
+#-------------------------------------------------------------------------------
+# Tests
+#-------------------------------------------------------------------------------
+
+class SerializedTestCase(unittest.TestCase):
+
+    def setUp(self):
+        pass
     
-    class SerializedTestCase(unittest.TestCase):
+    def tearDown(self):
+        pass
     
-        def setUp(self):
-            pass
-        
-        def tearDown(self):
-            pass
-        
-        def testSerializedInterfaces(self):
+    def testSerializedInterfaces(self):
 
-            us = UnSerialized({'a':10, 'b':range(10)})
-            s = ISerialized(us)
-            uss = IUnSerialized(s)
-            self.assert_(ISerialized.providedBy(s))
-            self.assert_(IUnSerialized.providedBy(us))
-            self.assert_(IUnSerialized.providedBy(uss))
-            for m in list(ISerialized):
-                self.assert_(hasattr(s, m))
-            for m in list(IUnSerialized):
-                self.assert_(hasattr(us, m))
-            for m in list(IUnSerialized):
-                self.assert_(hasattr(uss, m))
+        us = UnSerialized({'a':10, 'b':range(10)})
+        s = ISerialized(us)
+        uss = IUnSerialized(s)
+        self.assert_(ISerialized.providedBy(s))
+        self.assert_(IUnSerialized.providedBy(us))
+        self.assert_(IUnSerialized.providedBy(uss))
+        for m in list(ISerialized):
+            self.assert_(hasattr(s, m))
+        for m in list(IUnSerialized):
+            self.assert_(hasattr(us, m))
+        for m in list(IUnSerialized):
+            self.assert_(hasattr(uss, m))
 
-        def testPickleSerialized(self):
-            obj = {'a':1.45345, 'b':'asdfsdf', 'c':10000L}
-            original = UnSerialized(obj)
-            originalSer = ISerialized(original)
-            firstData = originalSer.getData()
-            firstTD = originalSer.getTypeDescriptor()
-            firstMD = originalSer.getMetadata()
-            self.assert_(firstTD == 'pickle')
-            self.assert_(firstMD == {})
-            unSerialized = IUnSerialized(originalSer)
-            secondObj = unSerialized.getObject()
-            for k, v in secondObj.iteritems():
-                self.assert_(obj[k] == v)
-            secondSer = ISerialized(UnSerialized(secondObj))
-            self.assert_(firstData == secondSer.getData())
-            self.assert_(firstTD == secondSer.getTypeDescriptor() )
-            self.assert_(firstMD == secondSer.getMetadata())
+    def testPickleSerialized(self):
+        obj = {'a':1.45345, 'b':'asdfsdf', 'c':10000L}
+        original = UnSerialized(obj)
+        originalSer = ISerialized(original)
+        firstData = originalSer.getData()
+        firstTD = originalSer.getTypeDescriptor()
+        firstMD = originalSer.getMetadata()
+        self.assert_(firstTD == 'pickle')
+        self.assert_(firstMD == {})
+        unSerialized = IUnSerialized(originalSer)
+        secondObj = unSerialized.getObject()
+        for k, v in secondObj.iteritems():
+            self.assert_(obj[k] == v)
+        secondSer = ISerialized(UnSerialized(secondObj))
+        self.assert_(firstData == secondSer.getData())
+        self.assert_(firstTD == secondSer.getTypeDescriptor() )
+        self.assert_(firstMD == secondSer.getMetadata())
+    
+    def testNDArraySerialized(self):
+        try:
+            import numpy
+        except ImportError:
+            pass
+        else:
+            a = numpy.linspace(0.0, 1.0, 1000)
+            unSer1 = UnSerialized(a)
+            ser1 = ISerialized(unSer1)
+            td = ser1.getTypeDescriptor()
+            self.assert_(td == 'ndarray')
+            md = ser1.getMetadata()
+            self.assert_(md['shape'] == a.shape)
+            self.assert_(md['dtype'] == a.dtype.str)
+            buff = ser1.getData()
+            self.assert_(buff == numpy.getbuffer(a))
+            s = Serialized(buff, td, md)
+            us = IUnSerialized(s)
+            final = us.getObject()
+            self.assert_(numpy.getbuffer(a) == numpy.getbuffer(final))
+            self.assert_(a.dtype.str == final.dtype.str)
+            self.assert_(a.shape == final.shape)
+        
         
-        def testNDArraySerialized(self):
-            try:
-                import numpy
-            except ImportError:
-                pass
-            else:
-                a = numpy.linspace(0.0, 1.0, 1000)
-                unSer1 = UnSerialized(a)
-                ser1 = ISerialized(unSer1)
-                td = ser1.getTypeDescriptor()
-                self.assert_(td == 'ndarray')
-                md = ser1.getMetadata()
-                self.assert_(md['shape'] == a.shape)
-                self.assert_(md['dtype'] == a.dtype.str)
-                buff = ser1.getData()
-                self.assert_(buff == numpy.getbuffer(a))
-                s = Serialized(buff, td, md)
-                us = IUnSerialized(s)
-                final = us.getObject()
-                self.assert_(numpy.getbuffer(a) == numpy.getbuffer(final))
-                self.assert_(a.dtype.str == final.dtype.str)
-                self.assert_(a.shape == final.shape)
-            
-            
-    
  No newline at end of file

IPython/kernel/tests/test_pendingdeferred.py

@@ -1,186 +1,186 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
 """Tests for pendingdeferred.py"""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 try:
     from twisted.internet import defer
     from twisted.python import failure
 
     from IPython.testing.util import DeferredTestCase
     import IPython.kernel.pendingdeferred as pd
     from IPython.kernel import error
     from IPython.kernel.util import printer
 except ImportError:
-    pass
-else:
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
     
-    class Foo(object):
-    
-        def bar(self, bahz):
-            return defer.succeed('blahblah: %s' % bahz)
+class Foo(object):
 
-    class TwoPhaseFoo(pd.PendingDeferredManager):
-    
-        def __init__(self, foo):
-            self.foo = foo
-            pd.PendingDeferredManager.__init__(self)
+    def bar(self, bahz):
+        return defer.succeed('blahblah: %s' % bahz)
 
-        @pd.two_phase
-        def bar(self, bahz):
-            return self.foo.bar(bahz)
+class TwoPhaseFoo(pd.PendingDeferredManager):
 
-    class PendingDeferredManagerTest(DeferredTestCase):
-    
-        def setUp(self):
-            self.pdm = pd.PendingDeferredManager()
-        
-        def tearDown(self):
-            pass
-    
-        def testBasic(self):
-            dDict = {}
-            # Create 10 deferreds and save them
-            for i in range(10):
-                d = defer.Deferred()
-                did = self.pdm.save_pending_deferred(d)
-                dDict[did] = d
-            # Make sure they are begin saved
-            for k in dDict.keys():
-                self.assert_(self.pdm.quick_has_id(k))
-            # Get the pending deferred (block=True), then callback with 'foo' and compare
-            for did in dDict.keys()[0:5]:
-                d = self.pdm.get_pending_deferred(did,block=True)
-                dDict[did].callback('foo')
-                d.addCallback(lambda r: self.assert_(r=='foo'))
-            # Get the pending deferreds with (block=False) and make sure ResultNotCompleted is raised
-            for did in dDict.keys()[5:10]:
-                d = self.pdm.get_pending_deferred(did,block=False)
-                d.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
-            # Now callback the last 5, get them and compare.
-            for did in dDict.keys()[5:10]:
-                dDict[did].callback('foo')
-                d = self.pdm.get_pending_deferred(did,block=False)
-                d.addCallback(lambda r: self.assert_(r=='foo'))
-    
-        def test_save_then_delete(self):
-            d = defer.Deferred()
-            did = self.pdm.save_pending_deferred(d)
-            self.assert_(self.pdm.quick_has_id(did))
-            self.pdm.delete_pending_deferred(did)
-            self.assert_(not self.pdm.quick_has_id(did))
-    
-        def test_save_get_delete(self):
-            d = defer.Deferred()
-            did = self.pdm.save_pending_deferred(d)
-            d2 = self.pdm.get_pending_deferred(did,True)
-            d2.addErrback(lambda f: self.assertRaises(error.AbortedPendingDeferredError, f.raiseException))
-            self.pdm.delete_pending_deferred(did)
-            return d2
-   
-        def test_double_get(self):
-            d = defer.Deferred()
-            did = self.pdm.save_pending_deferred(d)
-            d2 = self.pdm.get_pending_deferred(did,True)
-            d3 = self.pdm.get_pending_deferred(did,True)
-            d3.addErrback(lambda f: self.assertRaises(error.InvalidDeferredID, f.raiseException))
-    
-        def test_get_after_callback(self):
-            d = defer.Deferred()
-            did = self.pdm.save_pending_deferred(d)
-            d.callback('foo')
-            d2 = self.pdm.get_pending_deferred(did,True)
-            d2.addCallback(lambda r: self.assertEquals(r,'foo'))
-            self.assert_(not self.pdm.quick_has_id(did))
+    def __init__(self, foo):
+        self.foo = foo
+        pd.PendingDeferredManager.__init__(self)
 
-        def test_get_before_callback(self):
-            d = defer.Deferred()
-            did = self.pdm.save_pending_deferred(d)
-            d2 = self.pdm.get_pending_deferred(did,True)
-            d.callback('foo')
-            d2.addCallback(lambda r: self.assertEquals(r,'foo'))
-            self.assert_(not self.pdm.quick_has_id(did))
-            d = defer.Deferred()
-            did = self.pdm.save_pending_deferred(d)
-            d2 = self.pdm.get_pending_deferred(did,True)
-            d2.addCallback(lambda r: self.assertEquals(r,'foo'))
-            d.callback('foo')
-            self.assert_(not self.pdm.quick_has_id(did))
-    
-        def test_get_after_errback(self):
-            class MyError(Exception):
-                pass
-            d = defer.Deferred()
-            did = self.pdm.save_pending_deferred(d)
-            d.errback(failure.Failure(MyError('foo')))
-            d2 = self.pdm.get_pending_deferred(did,True)
-            d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
-            self.assert_(not self.pdm.quick_has_id(did))
-
-        def test_get_before_errback(self):
-            class MyError(Exception):
-                pass
-            d = defer.Deferred()
-            did = self.pdm.save_pending_deferred(d)
-            d2 = self.pdm.get_pending_deferred(did,True)
-            d.errback(failure.Failure(MyError('foo')))
-            d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
-            self.assert_(not self.pdm.quick_has_id(did))
-            d = defer.Deferred()
-            did = self.pdm.save_pending_deferred(d)
-            d2 = self.pdm.get_pending_deferred(did,True)
-            d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
-            d.errback(failure.Failure(MyError('foo')))
-            self.assert_(not self.pdm.quick_has_id(did))
-        
-        def test_noresult_noblock(self):
-            d = defer.Deferred()
-            did = self.pdm.save_pending_deferred(d)
-            d2 = self.pdm.get_pending_deferred(did,False)
-            d2.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
+    @pd.two_phase
+    def bar(self, bahz):
+        return self.foo.bar(bahz)
 
-        def test_with_callbacks(self):
-            d = defer.Deferred()
-            d.addCallback(lambda r: r+' foo')
-            d.addCallback(lambda r: r+' bar')
-            did = self.pdm.save_pending_deferred(d)
-            d2 = self.pdm.get_pending_deferred(did,True)
-            d.callback('bam')
-            d2.addCallback(lambda r: self.assertEquals(r,'bam foo bar'))
+class PendingDeferredManagerTest(DeferredTestCase):
+
+    def setUp(self):
+        self.pdm = pd.PendingDeferredManager()
     
-        def test_with_errbacks(self):
-            class MyError(Exception):
-                pass
+    def tearDown(self):
+        pass
+
+    def testBasic(self):
+        dDict = {}
+        # Create 10 deferreds and save them
+        for i in range(10):
             d = defer.Deferred()
-            d.addCallback(lambda r: 'foo')
-            d.addErrback(lambda f: 'caught error')
             did = self.pdm.save_pending_deferred(d)
-            d2 = self.pdm.get_pending_deferred(did,True)
-            d.errback(failure.Failure(MyError('bam')))
-            d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
+            dDict[did] = d
+        # Make sure they are begin saved
+        for k in dDict.keys():
+            self.assert_(self.pdm.quick_has_id(k))
+        # Get the pending deferred (block=True), then callback with 'foo' and compare
+        for did in dDict.keys()[0:5]:
+            d = self.pdm.get_pending_deferred(did,block=True)
+            dDict[did].callback('foo')
+            d.addCallback(lambda r: self.assert_(r=='foo'))
+        # Get the pending deferreds with (block=False) and make sure ResultNotCompleted is raised
+        for did in dDict.keys()[5:10]:
+            d = self.pdm.get_pending_deferred(did,block=False)
+            d.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
+        # Now callback the last 5, get them and compare.
+        for did in dDict.keys()[5:10]:
+            dDict[did].callback('foo')
+            d = self.pdm.get_pending_deferred(did,block=False)
+            d.addCallback(lambda r: self.assert_(r=='foo'))
+
+    def test_save_then_delete(self):
+        d = defer.Deferred()
+        did = self.pdm.save_pending_deferred(d)
+        self.assert_(self.pdm.quick_has_id(did))
+        self.pdm.delete_pending_deferred(did)
+        self.assert_(not self.pdm.quick_has_id(did))
+
+    def test_save_get_delete(self):
+        d = defer.Deferred()
+        did = self.pdm.save_pending_deferred(d)
+        d2 = self.pdm.get_pending_deferred(did,True)
+        d2.addErrback(lambda f: self.assertRaises(error.AbortedPendingDeferredError, f.raiseException))
+        self.pdm.delete_pending_deferred(did)
+        return d2
+
+    def test_double_get(self):
+        d = defer.Deferred()
+        did = self.pdm.save_pending_deferred(d)
+        d2 = self.pdm.get_pending_deferred(did,True)
+        d3 = self.pdm.get_pending_deferred(did,True)
+        d3.addErrback(lambda f: self.assertRaises(error.InvalidDeferredID, f.raiseException))
+
+    def test_get_after_callback(self):
+        d = defer.Deferred()
+        did = self.pdm.save_pending_deferred(d)
+        d.callback('foo')
+        d2 = self.pdm.get_pending_deferred(did,True)
+        d2.addCallback(lambda r: self.assertEquals(r,'foo'))
+        self.assert_(not self.pdm.quick_has_id(did))
+
+    def test_get_before_callback(self):
+        d = defer.Deferred()
+        did = self.pdm.save_pending_deferred(d)
+        d2 = self.pdm.get_pending_deferred(did,True)
+        d.callback('foo')
+        d2.addCallback(lambda r: self.assertEquals(r,'foo'))
+        self.assert_(not self.pdm.quick_has_id(did))
+        d = defer.Deferred()
+        did = self.pdm.save_pending_deferred(d)
+        d2 = self.pdm.get_pending_deferred(did,True)
+        d2.addCallback(lambda r: self.assertEquals(r,'foo'))
+        d.callback('foo')
+        self.assert_(not self.pdm.quick_has_id(did))
+
+    def test_get_after_errback(self):
+        class MyError(Exception):
+            pass
+        d = defer.Deferred()
+        did = self.pdm.save_pending_deferred(d)
+        d.errback(failure.Failure(MyError('foo')))
+        d2 = self.pdm.get_pending_deferred(did,True)
+        d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
+        self.assert_(not self.pdm.quick_has_id(did))
+
+    def test_get_before_errback(self):
+        class MyError(Exception):
+            pass
+        d = defer.Deferred()
+        did = self.pdm.save_pending_deferred(d)
+        d2 = self.pdm.get_pending_deferred(did,True)
+        d.errback(failure.Failure(MyError('foo')))
+        d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
+        self.assert_(not self.pdm.quick_has_id(did))
+        d = defer.Deferred()
+        did = self.pdm.save_pending_deferred(d)
+        d2 = self.pdm.get_pending_deferred(did,True)
+        d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
+        d.errback(failure.Failure(MyError('foo')))
+        self.assert_(not self.pdm.quick_has_id(did))
     
-        def test_nested_deferreds(self):
-            d = defer.Deferred()
-            d2 = defer.Deferred()
-            d.addCallback(lambda r: d2)
-            did = self.pdm.save_pending_deferred(d)
-            d.callback('foo')
-            d3 = self.pdm.get_pending_deferred(did,False)
-            d3.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
-            d2.callback('bar')
-            d3 = self.pdm.get_pending_deferred(did,False)
-            d3.addCallback(lambda r: self.assertEquals(r,'bar'))
+    def test_noresult_noblock(self):
+        d = defer.Deferred()
+        did = self.pdm.save_pending_deferred(d)
+        d2 = self.pdm.get_pending_deferred(did,False)
+        d2.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
+
+    def test_with_callbacks(self):
+        d = defer.Deferred()
+        d.addCallback(lambda r: r+' foo')
+        d.addCallback(lambda r: r+' bar')
+        did = self.pdm.save_pending_deferred(d)
+        d2 = self.pdm.get_pending_deferred(did,True)
+        d.callback('bam')
+        d2.addCallback(lambda r: self.assertEquals(r,'bam foo bar'))
+
+    def test_with_errbacks(self):
+        class MyError(Exception):
+            pass
+        d = defer.Deferred()
+        d.addCallback(lambda r: 'foo')
+        d.addErrback(lambda f: 'caught error')
+        did = self.pdm.save_pending_deferred(d)
+        d2 = self.pdm.get_pending_deferred(did,True)
+        d.errback(failure.Failure(MyError('bam')))
+        d2.addErrback(lambda f: self.assertRaises(MyError, f.raiseException))
+
+    def test_nested_deferreds(self):
+        d = defer.Deferred()
+        d2 = defer.Deferred()
+        d.addCallback(lambda r: d2)
+        did = self.pdm.save_pending_deferred(d)
+        d.callback('foo')
+        d3 = self.pdm.get_pending_deferred(did,False)
+        d3.addErrback(lambda f: self.assertRaises(error.ResultNotCompleted, f.raiseException))
+        d2.callback('bar')
+        d3 = self.pdm.get_pending_deferred(did,False)
+        d3.addCallback(lambda r: self.assertEquals(r,'bar'))
 

IPython/kernel/tests/test_task.py

@@ -1,50 +1,51 b''
 # encoding: utf-8
 
 """This file contains unittests for the kernel.task.py module."""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 try:
     import time
 
     from twisted.internet import defer
     from twisted.trial import unittest
 
     from IPython.kernel import task, controllerservice as cs, engineservice as es
     from IPython.kernel.multiengine import IMultiEngine
     from IPython.testing.util import DeferredTestCase
     from IPython.kernel.tests.tasktest import ITaskControllerTestCase
 except ImportError:
-    pass
-else:
-    #-------------------------------------------------------------------------------
-    # Tests
-    #-------------------------------------------------------------------------------
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
 
-    class BasicTaskControllerTestCase(DeferredTestCase, ITaskControllerTestCase):
+#-------------------------------------------------------------------------------
+# Tests
+#-------------------------------------------------------------------------------
+
+class BasicTaskControllerTestCase(DeferredTestCase, ITaskControllerTestCase):
+
+    def setUp(self):
+        self.controller  = cs.ControllerService()
+        self.controller.startService()
+        self.multiengine = IMultiEngine(self.controller)
+        self.tc = task.ITaskController(self.controller)
+        self.tc.failurePenalty = 0
+        self.engines=[]
     
-        def setUp(self):
-            self.controller  = cs.ControllerService()
-            self.controller.startService()
-            self.multiengine = IMultiEngine(self.controller)
-            self.tc = task.ITaskController(self.controller)
-            self.tc.failurePenalty = 0
-            self.engines=[]
-        
-        def tearDown(self):
-            self.controller.stopService()
-            for e in self.engines:
-                e.stopService()
+    def tearDown(self):
+        self.controller.stopService()
+        for e in self.engines:
+            e.stopService()
 
 

IPython/kernel/tests/test_taskfc.py

@@ -1,161 +1,162 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 try:
     import time
 
     from twisted.internet import defer, reactor
 
     from IPython.kernel.fcutil import Tub, UnauthenticatedTub
 
     from IPython.kernel import task as taskmodule
     from IPython.kernel import controllerservice as cs
     import IPython.kernel.multiengine as me
     from IPython.testing.util import DeferredTestCase
     from IPython.kernel.multienginefc import IFCSynchronousMultiEngine
     from IPython.kernel.taskfc import IFCTaskController
     from IPython.kernel.util import printer
     from IPython.kernel.tests.tasktest import ITaskControllerTestCase
     from IPython.kernel.clientconnector import ClientConnector
     from IPython.kernel.error import CompositeError
     from IPython.kernel.parallelfunction import ParallelFunction
 except ImportError:
-    pass
-else:
+    import nose
+    raise nose.SkipTest("This test requires zope.interface, Twisted and Foolscap")
 
-    #-------------------------------------------------------------------------------
-    # Tests
-    #-------------------------------------------------------------------------------
 
-    def _raise_it(f):
-        try:
-            f.raiseException()
-        except CompositeError, e:
-            e.raise_exception()
+#-------------------------------------------------------------------------------
+# Tests
+#-------------------------------------------------------------------------------
 
-    class TaskTest(DeferredTestCase, ITaskControllerTestCase):
+def _raise_it(f):
+    try:
+        f.raiseException()
+    except CompositeError, e:
+        e.raise_exception()
 
-        def setUp(self):
-        
-            self.engines = []
-                
-            self.controller = cs.ControllerService()
-            self.controller.startService()
-            self.imultiengine = me.IMultiEngine(self.controller)
-            self.itc = taskmodule.ITaskController(self.controller)
-            self.itc.failurePenalty = 0
-        
-            self.mec_referenceable = IFCSynchronousMultiEngine(self.imultiengine)
-            self.tc_referenceable = IFCTaskController(self.itc)
-        
-            self.controller_tub = Tub()
-            self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
-            self.controller_tub.setLocation('127.0.0.1:10105')
-        
-            mec_furl = self.controller_tub.registerReference(self.mec_referenceable)
-            tc_furl = self.controller_tub.registerReference(self.tc_referenceable)
-            self.controller_tub.startService()
-        
-            self.client_tub = ClientConnector()
-            d = self.client_tub.get_multiengine_client(mec_furl)
-            d.addCallback(self.handle_mec_client)
-            d.addCallback(lambda _: self.client_tub.get_task_client(tc_furl))
-            d.addCallback(self.handle_tc_client)
-            return d
-        
-        def handle_mec_client(self, client):
-            self.multiengine = client
+class TaskTest(DeferredTestCase, ITaskControllerTestCase):
+
+    def setUp(self):
+    
+        self.engines = []
+            
+        self.controller = cs.ControllerService()
+        self.controller.startService()
+        self.imultiengine = me.IMultiEngine(self.controller)
+        self.itc = taskmodule.ITaskController(self.controller)
+        self.itc.failurePenalty = 0
+    
+        self.mec_referenceable = IFCSynchronousMultiEngine(self.imultiengine)
+        self.tc_referenceable = IFCTaskController(self.itc)
+    
+        self.controller_tub = Tub()
+        self.controller_tub.listenOn('tcp:10105:interface=127.0.0.1')
+        self.controller_tub.setLocation('127.0.0.1:10105')
+    
+        mec_furl = self.controller_tub.registerReference(self.mec_referenceable)
+        tc_furl = self.controller_tub.registerReference(self.tc_referenceable)
+        self.controller_tub.startService()
+    
+        self.client_tub = ClientConnector()
+        d = self.client_tub.get_multiengine_client(mec_furl)
+        d.addCallback(self.handle_mec_client)
+        d.addCallback(lambda _: self.client_tub.get_task_client(tc_furl))
+        d.addCallback(self.handle_tc_client)
+        return d
+    
+    def handle_mec_client(self, client):
+        self.multiengine = client
+
+    def handle_tc_client(self, client):
+        self.tc = client
+
+    def tearDown(self):
+        dlist = []
+        # Shut down the multiengine client
+        d = self.client_tub.tub.stopService()
+        dlist.append(d)
+        # Shut down the engines
+        for e in self.engines:
+            e.stopService()
+        # Shut down the controller
+        d = self.controller_tub.stopService()
+        d.addBoth(lambda _: self.controller.stopService())
+        dlist.append(d)
+        return defer.DeferredList(dlist)
+    
+    def test_mapper(self):
+        self.addEngine(1)
+        m = self.tc.mapper()
+        self.assertEquals(m.task_controller,self.tc)
+        self.assertEquals(m.clear_before,False)
+        self.assertEquals(m.clear_after,False)
+        self.assertEquals(m.retries,0)
+        self.assertEquals(m.recovery_task,None)
+        self.assertEquals(m.depend,None)
+        self.assertEquals(m.block,True)
+    
+    def test_map_default(self):
+        self.addEngine(1)
+        m = self.tc.mapper()
+        d = m.map(lambda x: 2*x, range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        d.addCallback(lambda _: self.tc.map(lambda x: 2*x, range(10)))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
+    
+    def test_map_noblock(self):
+        self.addEngine(1)
+        m = self.tc.mapper(block=False)
+        d = m.map(lambda x: 2*x, range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[x for x in range(10)]))
+        return d
+            
+    def test_mapper_fail(self):
+        self.addEngine(1)
+        m = self.tc.mapper()
+        d = m.map(lambda x: 1/0, range(10))
+        d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
+        return d
+    
+    def test_parallel(self):
+        self.addEngine(1)
+        p = self.tc.parallel()
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 2*x
+        d = f(range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
+        return d
     
-        def handle_tc_client(self, client):
-            self.tc = client
+    def test_parallel_noblock(self):
+        self.addEngine(1)
+        p = self.tc.parallel(block=False)
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 2*x
+        d = f(range(10))
+        d.addCallback(lambda r: self.assertEquals(r,[x for x in range(10)]))
+        return d
     
-        def tearDown(self):
-            dlist = []
-            # Shut down the multiengine client
-            d = self.client_tub.tub.stopService()
-            dlist.append(d)
-            # Shut down the engines
-            for e in self.engines:
-                e.stopService()
-            # Shut down the controller
-            d = self.controller_tub.stopService()
-            d.addBoth(lambda _: self.controller.stopService())
-            dlist.append(d)
-            return defer.DeferredList(dlist)
-        
-        def test_mapper(self):
-            self.addEngine(1)
-            m = self.tc.mapper()
-            self.assertEquals(m.task_controller,self.tc)
-            self.assertEquals(m.clear_before,False)
-            self.assertEquals(m.clear_after,False)
-            self.assertEquals(m.retries,0)
-            self.assertEquals(m.recovery_task,None)
-            self.assertEquals(m.depend,None)
-            self.assertEquals(m.block,True)
-        
-        def test_map_default(self):
-            self.addEngine(1)
-            m = self.tc.mapper()
-            d = m.map(lambda x: 2*x, range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            d.addCallback(lambda _: self.tc.map(lambda x: 2*x, range(10)))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-        
-        def test_map_noblock(self):
-            self.addEngine(1)
-            m = self.tc.mapper(block=False)
-            d = m.map(lambda x: 2*x, range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[x for x in range(10)]))
-            return d
-                
-        def test_mapper_fail(self):
-            self.addEngine(1)
-            m = self.tc.mapper()
-            d = m.map(lambda x: 1/0, range(10))
-            d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
-            return d
-        
-        def test_parallel(self):
-            self.addEngine(1)
-            p = self.tc.parallel()
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 2*x
-            d = f(range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[2*x for x in range(10)]))
-            return d
-        
-        def test_parallel_noblock(self):
-            self.addEngine(1)
-            p = self.tc.parallel(block=False)
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 2*x
-            d = f(range(10))
-            d.addCallback(lambda r: self.assertEquals(r,[x for x in range(10)]))
-            return d
-        
-        def test_parallel_fail(self):
-            self.addEngine(1)
-            p = self.tc.parallel()
-            self.assert_(isinstance(p, ParallelFunction))
-            @p
-            def f(x): return 1/0
-            d = f(range(10))
-            d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
-            return d
  No newline at end of file
+    def test_parallel_fail(self):
+        self.addEngine(1)
+        p = self.tc.parallel()
+        self.assert_(isinstance(p, ParallelFunction))
+        @p
+        def f(x): return 1/0
+        d = f(range(10))
+        d.addBoth(lambda f: self.assertRaises(ZeroDivisionError, _raise_it, f))
+        return d
  No newline at end of file

docs/source/development/development.txt

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

docs/source/install/basic.txt

@@ -1,272 +1,286 b''
 =============================
 Basic installation of IPython
 =============================
 
 Installation
 ============
 
 Instant instructions
 --------------------
 
 If you are of the impatient kind, under Linux/Unix simply untar/unzip
 the download, then install with 'python setup.py install'. Under
 Windows, double-click on the provided .exe binary installer.
 
 Then, take a look at Customization_ section for configuring things
 optimally and `Quick tips`_ for quick tips on efficient use of
 IPython. You can later refer to the rest of the manual for all the
 gory details.
 
 See the notes in upgrading_ section for upgrading IPython versions.
 
 
     Detailed Unix instructions (Linux, Mac OS X, etc.)
 
 For RPM based systems, simply install the supplied package in the usual
 manner. If you download the tar archive, the process is:
 
    1. Unzip/untar the ipython-XXX.tar.gz file wherever you want (XXX is
       the version number). It will make a directory called ipython-XXX.
       Change into that directory where you will find the files README
       and setup.py. Once you've completed the installation, you can
       safely remove this directory.
    2. If you are installing over a previous installation of version
       0.2.0 or earlier, first remove your $HOME/.ipython directory,
       since the configuration file format has changed somewhat (the '='
       were removed from all option specifications). Or you can call
       ipython with the -upgrade option and it will do this automatically
       for you.
    3. IPython uses distutils, so you can install it by simply typing at
       the system prompt (don't type the $)::
       
       	$ python setup.py install
       	
       Note that this assumes you have root access to your machine. If
       you don't have root access or don't want IPython to go in the
       default python directories, you'll need to use the ``--home`` option
       (or ``--prefix``). For example::
       
       	$ python setup.py install --home $HOME/local
       	
       will install IPython into $HOME/local and its subdirectories
       (creating them if necessary).
       You can type::
       
       	$ python setup.py --help
       	
       for more details.
       
       Note that if you change the default location for ``--home`` at
       installation, IPython may end up installed at a location which is
       not part of your $PYTHONPATH environment variable. In this case,
       you'll need to configure this variable to include the actual
       directory where the IPython/ directory ended (typically the value
       you give to ``--home`` plus /lib/python).
 
 
 Mac OSX information
 -------------------
 
 Under OSX, there is a choice you need to make. Apple ships its own build
-of Python, which lives in the core OSX filesystem hierarchy. You can
+of Python, which lives in the core OSX filesystem hierarchy (/System/Library/Frameworks/Python.framework). You can
 also manually install a separate Python, either purely by hand
-(typically in /usr/local) or by using Fink, which puts everything under
-/sw. Which route to follow is a matter of personal preference, as I've
-seen users who favor each of the approaches. Here I will simply list the
-known installation issues under OSX, along with their solutions.
+(typically in /usr/local), by using Fink or DarwinPorts, which put everything under /sw or /opt respectively, or using the python.org "Framework" python, which installs a framework similar to the system python in /Library/Frameworks. The Enthought Python Distribution (http://www.enthought.com/products/epd.php), uses the python.org "Framework" python and thus also installs into /Library/Frameworks. Which route to follow is a matter of personal preference, as I've seen users who favor each of the approaches. 
+
+For users of OS X 10.5 (Leopard), the system python installation contains support for `DTrace`_, a kernel-level profiling system integrated into OS X 10.5. This facility provides significant advantage to developers and users interested in high-performance computing by using the system python.
+
+.. _DTrace: http://www.apple.com/macosx/technology/unix.html
+
+IPython is known to work with all the above installation options. As such, we do not endorse one choice over the others. Here we will simply list the known installation issues under OSX, along with their solutions.
 
 This page: http://geosci.uchicago.edu/~tobis/pylab.html contains
 information on this topic, with additional details on how to make
 IPython and matplotlib play nicely under OSX.
 
-To run IPython and readline on OSX "Leopard" system python, see the 
-wiki page at http://ipython.scipy.org/moin/InstallationOSXLeopard
-
 
-GUI problems
-------------
+GUI problems (older versions of OS X)
+-------------------------------------
 
-The following instructions apply to an install of IPython under OSX from
-unpacking the .tar.gz distribution and installing it for the default
-Python interpreter shipped by Apple. If you are using a fink install,
-fink will take care of these details for you, by installing IPython
-against fink's Python.
+The following instructions apply to an install of IPython under OSX before OS X 10.5 (users of OS X 10.5 see [#]_ ) by unpacking the .tar.gz distribution and installing it for the default Python interpreter shipped by Apple. If you are using a fink or DarwinPorts install, they will take care of these details for you, by installing IPython against their Python.
 
 IPython offers various forms of support for interacting with graphical
 applications from the command line, from simple Tk apps (which are in
 principle always supported by Python) to interactive control of WX, Qt
 and GTK apps. Under OSX, however, this requires that ipython is
 installed by calling the special pythonw script at installation time,
 which takes care of coordinating things with Apple's graphical environment.
 
 So when installing under OSX, it is best to use the following command:: 
 
 	$ sudo pythonw setup.py install --install-scripts=/usr/local/bin
 
-or
+or::
 
 	$ sudo pythonw setup.py install --install-scripts=/usr/bin
 	
 depending on where you like to keep hand-installed executables.
 
 The resulting script will have an appropriate shebang line (the first
 line in the script whic begins with #!...) such that the ipython
 interpreter can interact with the OS X GUI. If the installed version
 does not work and has a shebang line that points to, for example, just
 /usr/bin/python, then you might have a stale, cached version in your
 build/scripts-<python-version> directory. Delete that directory and
 rerun the setup.py.
 
 It is also a good idea to use the special flag ``--install-scripts`` as
 indicated above, to ensure that the ipython scripts end up in a location
 which is part of your $PATH. Otherwise Apple's Python will put the
 scripts in an internal directory not available by default at the command
 line (if you use /usr/local/bin, you need to make sure this is in your
 $PATH, which may not be true by default).
 
+.. [#] Users of OS X 10.5 who choose to use the system-installed python should install IPython using ``sudo python setupegg.py install`` from the IPython source directory or from `PyPI`_ using ``sudo easy_install ipython``.
+
+.. _PyPI: http://pypi.python.org/pypi
 
 Readline problems
 -----------------
 
-By default, the Python version shipped by Apple does not include the
-readline library, so central to IPython's behavior. If you install
+By default, the Python version shipped by Apple before OS X 10.5 does not include the readline library, so central to IPython's behavior. If you install
 IPython against Apple's Python, you will not have arrow keys, tab
 completion, etc. For Mac OSX 10.3 (Panther), you can find a prebuilt
 readline library here:
 http://pythonmac.org/packages/readline-5.0-py2.3-macosx10.3.zip
 
 If you are using OSX 10.4 (Tiger), after installing this package you
 need to either:
 
    1. move readline.so from /Library/Python/2.3 to
       /Library/Python/2.3/site-packages, or
    2. install http://pythonmac.org/packages/TigerPython23Compat.pkg.zip
 
-Users installing against Fink's Python or a properly hand-built one
-should not have this problem.
 
+Beginning with OS X 10.5, Apple's python installation uses libedit, a BSD-licensed not-quite-compatible readline replacement. As of IPython 0.9, many of the issues related to the differences between readline and libedit have been resolved. If you find that you are experiencing readline-related issues (e.g. problems with tab-completion, history movement, or line editing), you can install Ludwig Schwartz's readline package which effectively replaces libedit with readline for packages installed via setuptools. If you installed IPython from the source directory using::
+
+	sudo python setupegg.py
+
+or from PyPI with::
+
+	sudo easy_install ipython
+
+then you can install the readline egg via [#]_::
+
+	sudo easy_install readline
+
+If needed, the readline egg can be build and installed from source (see the 
+wiki page at http://ipython.scipy.org/moin/InstallationOSXLeopard).
+
+Users installing against Fink or DarwinPorts's Python or a properly hand-built python installation should not have this problem.
+
+.. [#] If you have installed SVN 1.5, you will also to install a patch to setuptools before installing the readline egg. Use ``sudo easy_install http://www.jaraco.com/ASP/eggs/setuptools-0.6c8_svn15fix.egg``.
 
 DarwinPorts
 -----------
 
 I report here a message from an OSX user, who suggests an alternative
 means of using IPython under this operating system with good results.
 Please let me know of any updates that may be useful for this section.
 His message is reproduced verbatim below:
 
     From: Markus Banfi <markus.banfi-AT-mospheira.net> 
 
     As a MacOS X (10.4.2) user I prefer to install software using
     DawinPorts instead of Fink. I had no problems installing ipython
     with DarwinPorts. It's just: 
 
     sudo port install py-ipython 
 
     It automatically resolved all dependencies (python24, readline,
     py-readline). So far I did not encounter any problems with the
     DarwinPorts port of ipython. 
 
 
 
 Windows instructions
 --------------------
 
 Some of IPython's very useful features are:
 
     * Integrated readline support (Tab-based file, object and attribute
       completion, input history across sessions, editable command line,
       etc.)
     * Coloring of prompts, code and tracebacks.
 
 .. _pyreadline:
 
 These, by default, are only available under Unix-like operating systems.
 However, thanks to Gary Bishop's work, Windows XP/2k users can also
 benefit from them. His readline library originally implemented both GNU
 readline functionality and color support, so that IPython under Windows
 XP/2k can be as friendly and powerful as under Unix-like environments.
 
 This library, now named PyReadline, has been absorbed by the IPython
 team (Jörgen Stenarson, in particular), and it continues to be developed
 with new features, as well as being distributed directly from the
 IPython site.
 
 The PyReadline extension requires CTypes and the windows IPython
 installer needs PyWin32, so in all you need:
 
    1. PyWin32 from http://sourceforge.net/projects/pywin32.
    2. PyReadline for Windows from
       http://ipython.scipy.org/moin/PyReadline/Intro. That page contains
       further details on using and configuring the system to your liking.
    3. Finally, only if you are using Python 2.3 or 2.4, you need CTypes
       from http://starship.python.net/crew/theller/ctypes(you must use
       version 0.9.1 or newer). This package is included in Python 2.5,
       so you don't need to manually get it if your Python version is 2.5
       or newer.
 
 Warning about a broken readline-like library: several users have
 reported problems stemming from using the pseudo-readline library at
 http://newcenturycomputers.net/projects/readline.html. This is a broken
 library which, while called readline, only implements an incomplete
 subset of the readline API. Since it is still called readline, it fools
 IPython's detection mechanisms and causes unpredictable crashes later.
 If you wish to use IPython under Windows, you must NOT use this library,
 which for all purposes is (at least as of version 1.6) terminally broken.
 
 
 Installation procedure
 ----------------------
 
 Once you have the above installed, from the IPython download directory
 grab the ipython-XXX.win32.exe file, where XXX represents the version
 number. This is a regular windows executable installer, which you can
 simply double-click to install. It will add an entry for IPython to your
 Start Menu, as well as registering IPython in the Windows list of
 applications, so you can later uninstall it from the Control Panel.
 
 IPython tries to install the configuration information in a directory
 named .ipython (_ipython under Windows) located in your 'home'
 directory. IPython sets this directory by looking for a HOME environment
 variable; if such a variable does not exist, it uses HOMEDRIVE\HOMEPATH
 (these are always defined by Windows). This typically gives something
 like C:\Documents and Settings\YourUserName, but your local details may
 vary. In this directory you will find all the files that configure
 IPython's defaults, and you can put there your profiles and extensions.
 This directory is automatically added by IPython to sys.path, so
 anything you place there can be found by import statements.
 
 
 Upgrading
 ---------
 
 For an IPython upgrade, you should first uninstall the previous version.
 This will ensure that all files and directories (such as the
 documentation) which carry embedded version strings in their names are
 properly removed.
 
 
 Manual installation under Win32
 -------------------------------
 
 In case the automatic installer does not work for some reason, you can
 download the ipython-XXX.tar.gz file, which contains the full IPython
 source distribution (the popular WinZip can read .tar.gz files). After
 uncompressing the archive, you can install it at a command terminal just
 like any other Python module, by using 'python setup.py install'.
 
 After the installation, run the supplied win32_manual_post_install.py
 script, which creates the necessary Start Menu shortcuts for you.
 
 
 .. upgrading:
 
 Upgrading from a previous version
 ---------------------------------
 
 If you are upgrading from a previous version of IPython, you may want
 to upgrade the contents of your ~/.ipython directory. Just run
 %upgrade, look at the diffs and delete the suggested files manually,
 if you think you can lose the old versions. %upgrade will never
 overwrite or delete anything.