Fixing installation related issues.

IPython/frontend/tests/test_prefilterfrontend.py

@@ -1,252 +1,252 b''
 # encoding: utf-8
 """
 Test process execution and IO redirection.
 """
 
 __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.
 #-------------------------------------------------------------------------------
 
 from copy import copy, deepcopy
 from cStringIO import StringIO
 import string
 
 from nose.tools import assert_equal
 
 from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
 from IPython.core.ipapi import get as get_ipython0
 from IPython.testing.plugin.ipdoctest import default_argv
 
 
 def safe_deepcopy(d):
     """ Deep copy every key of the given dict, when possible. Elsewhere
         do a copy.
     """
     copied_d = dict()
     for key, value in d.iteritems():
         try:
             copied_d[key] = deepcopy(value)
         except:
             try:
                 copied_d[key] = copy(value)
             except:
                 copied_d[key] = value
     return copied_d
 
 
 class TestPrefilterFrontEnd(PrefilterFrontEnd):
     
     input_prompt_template = string.Template('')
     output_prompt_template = string.Template('')
     banner = ''
 
     def __init__(self):
         self.out = StringIO()
         PrefilterFrontEnd.__init__(self,argv=default_argv())
         # Some more code for isolation (yeah, crazy)
         self._on_enter()
         self.out.flush()
         self.out.reset()
         self.out.truncate()
 
     def write(self, string, *args, **kwargs):
        self.out.write(string) 
 
     def _on_enter(self):
         self.input_buffer += '\n'
         PrefilterFrontEnd._on_enter(self)
 
 
 def isolate_ipython0(func):
     """ Decorator to isolate execution that involves an iptyhon0.
 
         Notes
         -----
 
         Apply only to functions with no arguments. Nose skips functions
         with arguments.
     """
     def my_func():
         iplib = get_ipython0()
         if iplib is None:
             return func()
         ipython0 = iplib.IP
         global_ns = safe_deepcopy(ipython0.user_global_ns)
         user_ns = safe_deepcopy(ipython0.user_ns)
         try:
             out = func()
         finally:
             ipython0.user_ns = user_ns
             ipython0.user_global_ns = global_ns
         # Undo the hack at creation of PrefilterFrontEnd
-        from IPythoncore. import iplib
+        from IPython.core import iplib
         iplib.InteractiveShell.isthreaded = False
         return out
 
     my_func.__name__ = func.__name__
     return my_func
 
 
 @isolate_ipython0
 def test_execution():
     """ Test execution of a command.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'print 1'
     f._on_enter()
     out_value = f.out.getvalue()
     assert_equal(out_value, '1\n')
 
 
 @isolate_ipython0
 def test_multiline():
     """ Test execution of a multiline command.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'if True:'
     f._on_enter()
     f.input_buffer += 'print 1'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, ''
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1\n'
     f = TestPrefilterFrontEnd()
     f.input_buffer='(1 +'
     f._on_enter()
     f.input_buffer += '0)'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, ''
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1\n'
 
 
 @isolate_ipython0
 def test_capture():
     """ Test the capture of output in different channels.
     """
     # Test on the OS-level stdout, stderr.
     f = TestPrefilterFrontEnd()
     f.input_buffer = \
             'import os; out=os.fdopen(1, "w"); out.write("1") ; out.flush()'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1'
     f = TestPrefilterFrontEnd()
     f.input_buffer = \
             'import os; out=os.fdopen(2, "w"); out.write("1") ; out.flush()'
     f._on_enter()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '1'
 
      
 @isolate_ipython0
 def test_magic():
     """ Test the magic expansion and history.
     
         This test is fairly fragile and will break when magics change.
     """
     f = TestPrefilterFrontEnd()
     # Before checking the interactive namespace, make sure it's clear (it can
     # otherwise pick up things stored in the user's local db)
     f.input_buffer += '%reset -f'
     f._on_enter()
     f.complete_current_input()
     # Now, run the %who magic and check output
     f.input_buffer += '%who'
     f._on_enter()
     out_value = f.out.getvalue()
     assert_equal(out_value, 'Interactive namespace is empty.\n')
 
 
 @isolate_ipython0
 def test_help():
     """ Test object inspection.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer += "def f():"
     f._on_enter()
     f.input_buffer += "'foobar'"
     f._on_enter()
     f.input_buffer += "pass"
     f._on_enter()
     f._on_enter()
     f.input_buffer += "f?"
     f._on_enter()
     assert 'traceback' not in f.last_result
     ## XXX: ipython doctest magic breaks this. I have no clue why
     #out_value = f.out.getvalue()
     #assert out_value.split()[-1] == 'foobar' 
 
 
 @isolate_ipython0
 def test_completion_simple():
     """ Test command-line completion on trivial examples.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'zzza = 1'
     f._on_enter()
     f.input_buffer = 'zzzb = 2'
     f._on_enter()
     f.input_buffer = 'zz'
     f.complete_current_input()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '\nzzza zzzb '
     yield assert_equal, f.input_buffer, 'zzz'
 
 
 @isolate_ipython0
 def test_completion_parenthesis():
     """ Test command-line completion when a parenthesis is open.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'zzza = 1'
     f._on_enter()
     f.input_buffer = 'zzzb = 2'
     f._on_enter()
     f.input_buffer = 'map(zz'
     f.complete_current_input()
     out_value = f.out.getvalue()
     yield assert_equal, out_value, '\nzzza zzzb '
     yield assert_equal, f.input_buffer, 'map(zzz'
 
 
 @isolate_ipython0
 def test_completion_indexing():
     """ Test command-line completion when indexing on objects.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'a = [0]'
     f._on_enter()
     f.input_buffer = 'a[0].'
     f.complete_current_input()
     assert_equal(f.input_buffer, 'a[0].__')
 
 
 @isolate_ipython0
 def test_completion_equal():
     """ Test command-line completion when the delimiter is "=", not " ".
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'a=1.'
     f.complete_current_input()
     assert_equal(f.input_buffer, 'a=1.__')
 
 
 
 if __name__ == '__main__':
     test_magic()
     test_help()
     test_execution()
     test_multiline()
     test_capture()
     test_completion_simple()
     test_completion_complex()

IPython/kernel/client.py

@@ -1,96 +1,96 b''
 # encoding: utf-8
 
 """This module contains blocking clients for the controller interfaces.
 
 Unlike the clients in `asyncclient.py`, the clients in this module are fully
 blocking.  This means that methods on the clients return the actual results
 rather than a deferred to the result.  Also, we manage the Twisted reactor
 for you.  This is done by running the reactor in a thread.
 
 The main classes in this module are:
 
     * MultiEngineClient
     * TaskClient
     * Task
     * CompositeError
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import sys
 
-# from IPython.tools import growl
+# from IPython.utils import growl
 # growl.start("IPython1 Client")
 
 
 from twisted.internet import reactor
 from IPython.kernel.clientconnector import ClientConnector
 from IPython.kernel.twistedutil import ReactorInThread
 from IPython.kernel.twistedutil import blockingCallFromThread
 
 # These enable various things 
 from IPython.kernel import codeutil
 import IPython.kernel.magic
 
 # Other things that the user will need
 from IPython.kernel.task import MapTask, StringTask
 from IPython.kernel.error import CompositeError
 
 #-------------------------------------------------------------------------------
 # Code
 #-------------------------------------------------------------------------------
 
 _client_tub = ClientConnector()
 
 
 def get_multiengine_client(furl_or_file=''):
     """Get the blocking MultiEngine client.
     
     :Parameters:
         furl_or_file : str
             A furl or a filename containing a furl.  If empty, the
             default furl_file will be used
             
     :Returns:
         The connected MultiEngineClient instance
     """
     client = blockingCallFromThread(_client_tub.get_multiengine_client, 
         furl_or_file)
     return client.adapt_to_blocking_client()
 
 def get_task_client(furl_or_file=''):
     """Get the blocking Task client.
     
     :Parameters:
         furl_or_file : str
             A furl or a filename containing a furl.  If empty, the
             default furl_file will be used
             
     :Returns:
         The connected TaskClient instance
     """
     client = blockingCallFromThread(_client_tub.get_task_client, 
         furl_or_file)
     return client.adapt_to_blocking_client()
 
 
 MultiEngineClient = get_multiengine_client
 TaskClient = get_task_client
 
 
 
 # Now we start the reactor in a thread
 rit = ReactorInThread()
 rit.setDaemon(True)
 rit.start()
  No newline at end of file

IPython/kernel/core/sync_traceback_trap.py

@@ -1,53 +1,53 b''
 # encoding: utf-8
 
 """Object to manage sys.excepthook().
 
 Synchronous version: prints errors when called.
 """
 
 __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 traceback_trap import TracebackTrap
-from IPython.ultraTB import ColorTB
+from IPython.core.ultratb import ColorTB
 
 class SyncTracebackTrap(TracebackTrap):
     """ TracebackTrap that displays immediatly the traceback in addition
     to capturing it. Useful in frontends, as without this traceback trap, 
     some tracebacks never get displayed.
     """
 
     def __init__(self, sync_formatter=None, formatters=None,
                                                     raiseException=True):
         """
         sync_formatter: Callable to display the traceback.
         formatters: A list of formatters to apply.
         """
         TracebackTrap.__init__(self, formatters=formatters)
         if sync_formatter is None:
             sync_formatter = ColorTB(color_scheme='LightBG')
         self.sync_formatter = sync_formatter
         self.raiseException = raiseException
 
 
     def hook(self, *args):
         """ This method actually implements the hook.
         """
         self.args = args
         if not self.raiseException:
             print self.sync_formatter(*self.args)
         else:
             raise
 
 
         
 

IPython/kernel/multiengine.py

@@ -1,753 +1,753 b''
 # encoding: utf-8
 # -*- test-case-name: IPython.kernel.test.test_multiengine -*-
 
 """Adapt the IPython ControllerServer to IMultiEngine.
 
 This module provides classes that adapt a ControllerService to the 
 IMultiEngine interface.  This interface is a basic interactive interface
 for working with a set of engines where it is desired to have explicit 
 access to each registered engine.  
 
 The classes here are exposed to the network in files like:
 
 * multienginevanilla.py
 * multienginepb.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
 #-------------------------------------------------------------------------------
 
 from new import instancemethod
 from types import FunctionType
 
 from twisted.application import service
 from twisted.internet import defer, reactor
 from twisted.python import log, components, failure
 from zope.interface import Interface, implements, Attribute
 
-from IPython.tools import growl
+from IPython.utils import growl
 from IPython.kernel.util import printer
 from IPython.kernel.twistedutil import gatherBoth
 from IPython.kernel import map as Map
 from IPython.kernel import error
 from IPython.kernel.pendingdeferred import PendingDeferredManager, two_phase
 from IPython.kernel.controllerservice import \
     ControllerAdapterBase, \
     ControllerService, \
     IControllerBase
 
 
 #-------------------------------------------------------------------------------
 # Interfaces for the MultiEngine representation of a controller
 #-------------------------------------------------------------------------------
 
 class IEngineMultiplexer(Interface):
     """Interface to multiple engines implementing IEngineCore/Serialized/Queued.
     
     This class simply acts as a multiplexer of methods that are in the 
     various IEngines* interfaces.  Thus the methods here are jut like those 
     in the IEngine* interfaces, but with an extra first argument, targets.  
     The targets argument can have the following forms:
     
     * targets = 10            # Engines are indexed by ints
     * targets = [0,1,2,3]     # A list of ints
     * targets = 'all'         # A string to indicate all targets
     
     If targets is bad in any way, an InvalidEngineID will be raised.  This
     includes engines not being registered.
     
     All IEngineMultiplexer multiplexer methods must return a Deferred to a list 
     with length equal to the number of targets.  The elements of the list will 
     correspond to the return of the corresponding IEngine method.
     
     Failures are aggressive, meaning that if an action fails for any target, 
     the overall action will fail immediately with that Failure.
     
     :Parameters:
         targets : int, list of ints, or 'all'
             Engine ids the action will apply to.
     
     :Returns: Deferred to a list of results for each engine.
     
     :Exception:
         InvalidEngineID
             If the targets argument is bad or engines aren't registered.
         NoEnginesRegistered
             If there are no engines registered and targets='all'
     """
         
     #---------------------------------------------------------------------------
     # Mutiplexed methods
     #---------------------------------------------------------------------------
      
     def execute(lines, targets='all'):
         """Execute lines of Python code on targets.
               
         See the class docstring for information about targets and possible
         exceptions this method can raise.
               
         :Parameters:
             lines : str
                 String of python code to be executed on targets.
         """
             
     def push(namespace, targets='all'):
         """Push dict namespace into the user's namespace on targets.
         
         See the class docstring for information about targets and possible
         exceptions this method can raise.
         
         :Parameters:
             namspace : dict
                 Dict of key value pairs to be put into the users namspace.
         """
         
     def pull(keys, targets='all'):
         """Pull values out of the user's namespace on targets by keys.
         
         See the class docstring for information about targets and possible
         exceptions this method can raise.
         
         :Parameters:
             keys : tuple of strings
                 Sequence of keys to be pulled from user's namespace.
         """
           
     def push_function(namespace, targets='all'):
         """"""
         
     def pull_function(keys, targets='all'):
         """"""
                 
     def get_result(i=None, targets='all'):
         """Get the result for command i from targets.
         
         See the class docstring for information about targets and possible
         exceptions this method can raise.
         
         :Parameters:
             i : int or None
                 Command index or None to indicate most recent command.                
         """
         
     def reset(targets='all'):
         """Reset targets.
         
         This clears the users namespace of the Engines, but won't cause
         modules to be reloaded.
         """
         
     def keys(targets='all'):
         """Get variable names defined in user's namespace on targets."""
         
     def kill(controller=False, targets='all'):
         """Kill the targets Engines and possibly the controller.
         
         :Parameters:
             controller : boolean
                 Should the controller be killed as well.  If so all the 
                 engines will be killed first no matter what targets is.
         """
         
     def push_serialized(namespace, targets='all'):
         """Push a namespace of Serialized objects to targets.
         
         :Parameters:
             namespace : dict
                 A dict whose keys are the variable names and whose values
                 are serialized version of the objects.
         """
         
     def pull_serialized(keys, targets='all'):
         """Pull Serialized objects by keys from targets.
         
         :Parameters:
             keys : tuple of strings
                 Sequence of variable names to pull as serialized objects.
         """
         
     def clear_queue(targets='all'):
         """Clear the queue of pending command for targets."""
         
     def queue_status(targets='all'):
         """Get the status of the queue on the targets."""
     
     def set_properties(properties, targets='all'):
         """set properties by key and value"""
     
     def get_properties(keys=None, targets='all'):
         """get a list of properties by `keys`, if no keys specified, get all"""
     
     def del_properties(keys, targets='all'):
         """delete properties by `keys`"""
     
     def has_properties(keys, targets='all'):
         """get a list of bool values for whether `properties` has `keys`"""
     
     def clear_properties(targets='all'):
         """clear the properties dict"""
 
 
 class IMultiEngine(IEngineMultiplexer):
     """A controller that exposes an explicit interface to all of its engines.
     
     This is the primary inteface for interactive usage.
     """
     
     def get_ids():
         """Return list of currently registered ids.
                 
         :Returns:  A Deferred to a list of registered engine ids.
         """
 
 
 
 #-------------------------------------------------------------------------------
 # Implementation of the core MultiEngine classes
 #-------------------------------------------------------------------------------
 
 class MultiEngine(ControllerAdapterBase):
     """The representation of a ControllerService as a IMultiEngine.
     
     Although it is not implemented currently, this class would be where a
     client/notification API is implemented.  It could inherit from something
     like results.NotifierParent and then use the notify method to send
     notifications.
     """
     
     implements(IMultiEngine)
     
     def __init(self, controller):
         ControllerAdapterBase.__init__(self, controller)
     
     #---------------------------------------------------------------------------
     # Helper methods
     #---------------------------------------------------------------------------
     
     def engineList(self, targets):
         """Parse the targets argument into a list of valid engine objects.
         
         :Parameters:
             targets : int, list of ints or 'all'
                 The targets argument to be parsed.
                 
         :Returns: List of engine objects.
         
         :Exception:
             InvalidEngineID
                 If targets is not valid or if an engine is not registered.
         """
         if isinstance(targets, int):
             if targets not in self.engines.keys():
                 log.msg("Engine with id %i is not registered" % targets)
                 raise error.InvalidEngineID("Engine with id %i is not registered" % targets)
             else: 
                 return [self.engines[targets]]
         elif isinstance(targets, (list, tuple)):
             for id in targets:
                 if id not in self.engines.keys():
                     log.msg("Engine with id %r is not registered" % id)
                     raise error.InvalidEngineID("Engine with id %r is not registered" % id)  
             return map(self.engines.get, targets)
         elif targets == 'all':
             eList = self.engines.values()
             if len(eList) == 0:
                 msg = """There are no engines registered.
                      Check the logs in ~/.ipython/log if you think there should have been."""
                 raise error.NoEnginesRegistered(msg)
             else:
                 return eList
         else:
             raise error.InvalidEngineID("targets argument is not an int, list of ints or 'all': %r"%targets)
     
     def _performOnEngines(self, methodName, *args, **kwargs):
         """Calls a method on engines and returns deferred to list of results.
         
         :Parameters:
             methodName : str
                 Name of the method to be called.
             targets : int, list of ints, 'all'
                 The targets argument to be parsed into a list of engine objects.
             args
                 The positional keyword arguments to be passed to the engines.
             kwargs
                 The keyword arguments passed to the method
                 
         :Returns: List of deferreds to the results on each engine
         
         :Exception:
             InvalidEngineID
                 If the targets argument is bad in any way.
             AttributeError
                 If the method doesn't exist on one of the engines.
         """
         targets = kwargs.pop('targets')
         log.msg("Performing %s on %r" % (methodName, targets))
         # log.msg("Performing %s(%r, %r) on %r" % (methodName, args, kwargs, targets))
         # This will and should raise if targets is not valid!
         engines = self.engineList(targets)
         dList = []
         for e in engines:
             meth = getattr(e, methodName, None)
             if meth is not None:
                 dList.append(meth(*args, **kwargs))
             else:
                 raise AttributeError("Engine %i does not have method %s" % (e.id, methodName))
         return dList
         
     def _performOnEnginesAndGatherBoth(self, methodName, *args, **kwargs):
         """Called _performOnEngines and wraps result/exception into deferred."""
         try:
             dList = self._performOnEngines(methodName, *args, **kwargs)
         except (error.InvalidEngineID, AttributeError, KeyError, error.NoEnginesRegistered):
             return defer.fail(failure.Failure())
         else:
             # Having fireOnOneErrback is causing problems with the determinacy
             # of the system.  Basically, once a single engine has errbacked, this
             # method returns.  In some cases, this will cause client to submit
             # another command.  Because the previous command is still running
             # on some engines, this command will be queued.  When those commands
             # then errback, the second command will raise QueueCleared.  Ahhh!
             d = gatherBoth(dList, 
                            fireOnOneErrback=0,
                            consumeErrors=1,
                            logErrors=0)
             d.addCallback(error.collect_exceptions, methodName)
             return d
               
     #---------------------------------------------------------------------------
     # General IMultiEngine methods
     #---------------------------------------------------------------------------
     
     def get_ids(self):
         return defer.succeed(self.engines.keys())
     
     #---------------------------------------------------------------------------
     # IEngineMultiplexer methods
     #---------------------------------------------------------------------------
     
     def execute(self, lines, targets='all'):
         return self._performOnEnginesAndGatherBoth('execute', lines, targets=targets)
     
     def push(self, ns, targets='all'):
         return self._performOnEnginesAndGatherBoth('push', ns, targets=targets)
         
     def pull(self, keys, targets='all'):
         return self._performOnEnginesAndGatherBoth('pull', keys, targets=targets)
     
     def push_function(self, ns, targets='all'):
         return self._performOnEnginesAndGatherBoth('push_function', ns, targets=targets)
         
     def pull_function(self, keys, targets='all'):
         return self._performOnEnginesAndGatherBoth('pull_function', keys, targets=targets)
     
     def get_result(self, i=None, targets='all'):
         return self._performOnEnginesAndGatherBoth('get_result', i, targets=targets)
     
     def reset(self, targets='all'):
         return self._performOnEnginesAndGatherBoth('reset', targets=targets)
     
     def keys(self, targets='all'):
         return self._performOnEnginesAndGatherBoth('keys', targets=targets)
     
     def kill(self, controller=False, targets='all'):
         if controller:
             targets = 'all'
         d = self._performOnEnginesAndGatherBoth('kill', targets=targets)
         if controller:
             log.msg("Killing controller")
             d.addCallback(lambda _: reactor.callLater(2.0, reactor.stop))
             # Consume any weird stuff coming back
             d.addBoth(lambda _: None)
         return d
     
     def push_serialized(self, namespace, targets='all'):
         for k, v in namespace.iteritems():
             log.msg("Pushed object %s is %f MB" % (k, v.getDataSize()))
         d = self._performOnEnginesAndGatherBoth('push_serialized', namespace, targets=targets)      
         return d
         
     def pull_serialized(self, keys, targets='all'):
         try:
             dList = self._performOnEngines('pull_serialized', keys, targets=targets)
         except (error.InvalidEngineID, AttributeError, error.NoEnginesRegistered):
             return defer.fail(failure.Failure())
         else:
             for d in dList:
                 d.addCallback(self._logSizes)
             d = gatherBoth(dList, 
                            fireOnOneErrback=0,
                            consumeErrors=1,
                            logErrors=0)
             d.addCallback(error.collect_exceptions, 'pull_serialized')
             return d  
                               
     def _logSizes(self, listOfSerialized):
         if isinstance(listOfSerialized, (list, tuple)):
             for s in listOfSerialized:
                 log.msg("Pulled object is %f MB" % s.getDataSize())
         else:
             log.msg("Pulled object is %f MB" % listOfSerialized.getDataSize())
         return listOfSerialized
     
     def clear_queue(self, targets='all'):
         return self._performOnEnginesAndGatherBoth('clear_queue', targets=targets)         
     
     def queue_status(self, targets='all'):
         log.msg("Getting queue status on %r" % targets)
         try:
             engines = self.engineList(targets)
         except (error.InvalidEngineID, AttributeError, error.NoEnginesRegistered):
             return defer.fail(failure.Failure())            
         else:
             dList = []
             for e in engines:
                 dList.append(e.queue_status().addCallback(lambda s:(e.id, s)))
             d = gatherBoth(dList, 
                            fireOnOneErrback=0,
                            consumeErrors=1,
                            logErrors=0)
             d.addCallback(error.collect_exceptions, 'queue_status')
             return d 
     
     def get_properties(self, keys=None, targets='all'):
         log.msg("Getting properties on %r" % targets)
         try:
             engines = self.engineList(targets)
         except (error.InvalidEngineID, AttributeError, error.NoEnginesRegistered):
             return defer.fail(failure.Failure())            
         else:
             dList = [e.get_properties(keys) for e in engines]
             d = gatherBoth(dList, 
                            fireOnOneErrback=0,
                            consumeErrors=1,
                            logErrors=0)
             d.addCallback(error.collect_exceptions, 'get_properties')
             return d
     
     def set_properties(self, properties, targets='all'):
         log.msg("Setting properties on %r" % targets)
         try:
             engines = self.engineList(targets)
         except (error.InvalidEngineID, AttributeError, error.NoEnginesRegistered):
             return defer.fail(failure.Failure())            
         else:
             dList = [e.set_properties(properties) for e in engines]
             d = gatherBoth(dList, 
                            fireOnOneErrback=0,
                            consumeErrors=1,
                            logErrors=0)
             d.addCallback(error.collect_exceptions, 'set_properties')
             return d
     
     def has_properties(self, keys, targets='all'):
         log.msg("Checking properties on %r" % targets)
         try:
             engines = self.engineList(targets)
         except (error.InvalidEngineID, AttributeError, error.NoEnginesRegistered):
             return defer.fail(failure.Failure())            
         else:
             dList = [e.has_properties(keys) for e in engines]
             d = gatherBoth(dList, 
                            fireOnOneErrback=0,
                            consumeErrors=1,
                            logErrors=0)
             d.addCallback(error.collect_exceptions, 'has_properties')
             return d
     
     def del_properties(self, keys, targets='all'):
         log.msg("Deleting properties on %r" % targets)
         try:
             engines = self.engineList(targets)
         except (error.InvalidEngineID, AttributeError, error.NoEnginesRegistered):
             return defer.fail(failure.Failure())            
         else:
             dList = [e.del_properties(keys) for e in engines]
             d = gatherBoth(dList, 
                            fireOnOneErrback=0,
                            consumeErrors=1,
                            logErrors=0)
             d.addCallback(error.collect_exceptions, 'del_properties')
             return d
     
     def clear_properties(self, targets='all'):
         log.msg("Clearing properties on %r" % targets)
         try:
             engines = self.engineList(targets)
         except (error.InvalidEngineID, AttributeError, error.NoEnginesRegistered):
             return defer.fail(failure.Failure())            
         else:
             dList = [e.clear_properties() for e in engines]
             d = gatherBoth(dList, 
                            fireOnOneErrback=0,
                            consumeErrors=1,
                            logErrors=0)
             d.addCallback(error.collect_exceptions, 'clear_properties')
             return d
 
 
 components.registerAdapter(MultiEngine,
                            IControllerBase, 
                            IMultiEngine)
 
 
 #-------------------------------------------------------------------------------
 # Interfaces for the Synchronous MultiEngine
 #-------------------------------------------------------------------------------
 
 class ISynchronousEngineMultiplexer(Interface):
     pass
 
 
 class ISynchronousMultiEngine(ISynchronousEngineMultiplexer):
     """Synchronous, two-phase version of IMultiEngine.
     
     Methods in this interface are identical to those of IMultiEngine, but they
     take one additional argument:
     
     execute(lines, targets='all') -> execute(lines, targets='all, block=True)
     
     :Parameters:
         block : boolean
             Should the method return a deferred to a deferredID or the 
             actual result.  If block=False a deferred to a deferredID is 
             returned and the user must call `get_pending_deferred` at a later
             point.  If block=True, a deferred to the actual result comes back.
     """
     def get_pending_deferred(deferredID, block=True):
         """"""
     
     def clear_pending_deferreds():
         """"""
 
 
 #-------------------------------------------------------------------------------
 # Implementation of the Synchronous MultiEngine
 #-------------------------------------------------------------------------------
 
 class SynchronousMultiEngine(PendingDeferredManager):
     """Adapt an `IMultiEngine` -> `ISynchronousMultiEngine`
     
     Warning, this class uses a decorator that currently uses **kwargs.  
     Because of this block must be passed as a kwarg, not positionally.
     """
     
     implements(ISynchronousMultiEngine)
     
     def __init__(self, multiengine):
         self.multiengine = multiengine
         PendingDeferredManager.__init__(self)
     
     #---------------------------------------------------------------------------
     # Decorated pending deferred methods
     #---------------------------------------------------------------------------
     
     @two_phase
     def execute(self, lines, targets='all'):
         d = self.multiengine.execute(lines, targets)
         return d
     
     @two_phase
     def push(self, namespace, targets='all'):
         return self.multiengine.push(namespace, targets)
     
     @two_phase
     def pull(self, keys, targets='all'):
         d = self.multiengine.pull(keys, targets)
         return d
     
     @two_phase
     def push_function(self, namespace, targets='all'):
         return self.multiengine.push_function(namespace, targets)
     
     @two_phase
     def pull_function(self, keys, targets='all'):
         d = self.multiengine.pull_function(keys, targets)
         return d
     
     @two_phase
     def get_result(self, i=None, targets='all'):
         return self.multiengine.get_result(i, targets='all')
     
     @two_phase
     def reset(self, targets='all'):
         return self.multiengine.reset(targets)
     
     @two_phase
     def keys(self, targets='all'):
         return self.multiengine.keys(targets)
     
     @two_phase
     def kill(self, controller=False, targets='all'):
         return self.multiengine.kill(controller, targets)
     
     @two_phase
     def push_serialized(self, namespace, targets='all'):
         return self.multiengine.push_serialized(namespace, targets)
     
     @two_phase
     def pull_serialized(self, keys, targets='all'):
         return self.multiengine.pull_serialized(keys, targets)
     
     @two_phase
     def clear_queue(self, targets='all'):
         return self.multiengine.clear_queue(targets)
     
     @two_phase
     def queue_status(self, targets='all'):
         return self.multiengine.queue_status(targets)
     
     @two_phase
     def set_properties(self, properties, targets='all'):
         return self.multiengine.set_properties(properties, targets)
     
     @two_phase
     def get_properties(self, keys=None, targets='all'):
         return self.multiengine.get_properties(keys, targets)
     
     @two_phase
     def has_properties(self, keys, targets='all'):
         return self.multiengine.has_properties(keys, targets)
     
     @two_phase
     def del_properties(self, keys, targets='all'):
         return self.multiengine.del_properties(keys, targets)
     
     @two_phase
     def clear_properties(self, targets='all'):
         return self.multiengine.clear_properties(targets)
     
     #---------------------------------------------------------------------------
     # IMultiEngine methods
     #---------------------------------------------------------------------------
     
     def get_ids(self):
         """Return a list of registered engine ids.
         
         Never use the two phase block/non-block stuff for this.
         """
         return self.multiengine.get_ids()
 
 
 components.registerAdapter(SynchronousMultiEngine, IMultiEngine, ISynchronousMultiEngine)
 
 
 #-------------------------------------------------------------------------------
 # Various high-level interfaces that can be used as MultiEngine mix-ins
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # IMultiEngineCoordinator
 #-------------------------------------------------------------------------------
 
 class IMultiEngineCoordinator(Interface):
     """Methods that work on multiple engines explicitly."""
        
     def scatter(key, seq, dist='b', flatten=False, targets='all'):
         """Partition and distribute a sequence to targets."""
         
     def gather(key, dist='b', targets='all'):
         """Gather object key from targets."""
     
     def raw_map(func, seqs, dist='b', targets='all'):
         """
         A parallelized version of Python's builtin `map` function.
         
         This has a slightly different syntax than the builtin `map`.
         This is needed because we need to have keyword arguments and thus
         can't use *args to capture all the sequences.  Instead, they must
         be passed in a list or tuple.
         
         The equivalence is:
         
         raw_map(func, seqs) -> map(func, seqs[0], seqs[1], ...)
         
         Most users will want to use parallel functions or the `mapper`
         and `map` methods for an API that follows that of the builtin
         `map`.
         """
 
 
 class ISynchronousMultiEngineCoordinator(IMultiEngineCoordinator):
     """Methods that work on multiple engines explicitly."""
 
     def scatter(key, seq, dist='b', flatten=False, targets='all', block=True):
         """Partition and distribute a sequence to targets."""
         
     def gather(key, dist='b', targets='all', block=True):
         """Gather object key from targets"""
     
     def raw_map(func, seqs, dist='b', targets='all', block=True):
         """
         A parallelized version of Python's builtin map.
         
         This has a slightly different syntax than the builtin `map`.
         This is needed because we need to have keyword arguments and thus
         can't use *args to capture all the sequences.  Instead, they must
         be passed in a list or tuple.
         
         raw_map(func, seqs) -> map(func, seqs[0], seqs[1], ...)
         
         Most users will want to use parallel functions or the `mapper`
         and `map` methods for an API that follows that of the builtin
         `map`.
         """
 
 
 #-------------------------------------------------------------------------------
 # IMultiEngineExtras
 #-------------------------------------------------------------------------------
 
 class IMultiEngineExtras(Interface):
     
     def zip_pull(targets, keys):
         """
         Pull, but return results in a different format from `pull`.
         
         This method basically returns zip(pull(targets, *keys)), with a few 
         edge cases handled differently.  Users of chainsaw will find this format 
         familiar.
         """
     
     def run(targets, fname):
         """Run a .py file on targets."""
 
 
 class ISynchronousMultiEngineExtras(IMultiEngineExtras):
     def zip_pull(targets, keys, block=True):
         """
         Pull, but return results in a different format from `pull`.
         
         This method basically returns zip(pull(targets, *keys)), with a few 
         edge cases handled differently.  Users of chainsaw will find this format 
         familiar.
         """
     
     def run(targets, fname, block=True):
         """Run a .py file on targets."""
 
 #-------------------------------------------------------------------------------
 # The full MultiEngine interface
 #-------------------------------------------------------------------------------
 
 class IFullMultiEngine(IMultiEngine, 
     IMultiEngineCoordinator, 
     IMultiEngineExtras):
     pass
 
 
 class IFullSynchronousMultiEngine(ISynchronousMultiEngine, 
     ISynchronousMultiEngineCoordinator,
     ISynchronousMultiEngineExtras):
     pass
 

IPython/kernel/pendingdeferred.py

@@ -1,178 +1,178 b''
 # encoding: utf-8
 # -*- test-case-name: IPython.kernel.test.test_pendingdeferred -*-
 
 """Classes to manage pending Deferreds.
 
 A pending deferred is a deferred that may or may not have fired.  This module
 is useful for taking a class whose methods return deferreds and wrapping it to
 provide API that keeps track of those deferreds for later retrieval.  See the
 tests for examples of its usage.
 """
 
 __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.application import service
 from twisted.internet import defer, reactor
 from twisted.python import log, components, failure
 from zope.interface import Interface, implements, Attribute
 
 from IPython.kernel.twistedutil import gatherBoth
 from IPython.kernel import error
 from IPython.external import guid
-from IPython.tools import growl
+from IPython.utils import growl
 
 class PendingDeferredManager(object):
     """A class to track pending deferreds.
     
     To track a pending deferred, the user of this class must first
     get a deferredID by calling `get_next_deferred_id`.  Then the user
     calls `save_pending_deferred` passing that id and the deferred to
     be tracked.  To later retrieve it, the user calls
     `get_pending_deferred` passing the id.
     """
     
     def __init__(self):
         """Manage pending deferreds."""
 
         self.results = {} # Populated when results are ready
         self.deferred_ids = [] # List of deferred ids I am managing
         self.deferreds_to_callback = {} # dict of lists of deferreds to callback
         
     def get_deferred_id(self):
         return guid.generate()
     
     def quick_has_id(self, deferred_id):
         return deferred_id in self.deferred_ids
     
     def _save_result(self, result, deferred_id):
         if self.quick_has_id(deferred_id):
             self.results[deferred_id] = result
             self._trigger_callbacks(deferred_id)
     
     def _trigger_callbacks(self, deferred_id):
         # Go through and call the waiting callbacks
         result = self.results.get(deferred_id)
         if result is not None:  # Only trigger if there is a result
             try:
                 d = self.deferreds_to_callback.pop(deferred_id)
             except KeyError:
                 d = None
             if d is not None:
                 if isinstance(result, failure.Failure):
                     d.errback(result)
                 else:
                     d.callback(result)
                 self.delete_pending_deferred(deferred_id)
                    
     def save_pending_deferred(self, d, deferred_id=None):
         """Save the result of a deferred for later retrieval.
         
         This works even if the deferred has not fired.
         
         Only callbacks and errbacks applied to d before this method
         is called will be called no the final result.
         """
         if deferred_id is None:
             deferred_id = self.get_deferred_id()
         self.deferred_ids.append(deferred_id)
         d.addBoth(self._save_result, deferred_id)
         return deferred_id
     
     def _protected_del(self, key, container):
         try:
             del container[key]
         except Exception:
             pass
     
     def delete_pending_deferred(self, deferred_id):
         """Remove a deferred I am tracking and add a null Errback.
         
         :Parameters:
             deferredID : str
                 The id of a deferred that I am tracking.
         """
         if self.quick_has_id(deferred_id):
             # First go through a errback any deferreds that are still waiting
             d = self.deferreds_to_callback.get(deferred_id)
             if d is not None:
                 d.errback(failure.Failure(error.AbortedPendingDeferredError("pending deferred has been deleted: %r"%deferred_id)))
             # Now delete all references to this deferred_id
             ind = self.deferred_ids.index(deferred_id)
             self._protected_del(ind, self.deferred_ids)
             self._protected_del(deferred_id, self.deferreds_to_callback)
             self._protected_del(deferred_id, self.results)            
         else:
             raise error.InvalidDeferredID('invalid deferred_id: %r' % deferred_id)
     
     def clear_pending_deferreds(self):
         """Remove all the deferreds I am tracking."""
         for did in self.deferred_ids:
             self.delete_pending_deferred(did)
         
     def _delete_and_pass_through(self, r, deferred_id):
         self.delete_pending_deferred(deferred_id)
         return r
         
     def get_pending_deferred(self, deferred_id, block):
         if not self.quick_has_id(deferred_id) or self.deferreds_to_callback.get(deferred_id) is not None:
             return defer.fail(failure.Failure(error.InvalidDeferredID('invalid deferred_id: %r' + deferred_id)))
         result = self.results.get(deferred_id)
         if result is not None:
             self.delete_pending_deferred(deferred_id)
             if isinstance(result, failure.Failure):
                 return defer.fail(result)
             else:
                 return defer.succeed(result)
         else:  # Result is not ready
             if block:
                 d = defer.Deferred()
                 self.deferreds_to_callback[deferred_id] = d
                 return d
             else:
                 return defer.fail(failure.Failure(error.ResultNotCompleted("result not completed: %r" % deferred_id)))
 
 def two_phase(wrapped_method):
     """Wrap methods that return a deferred into a two phase process.
     
     This transforms::
     
         foo(arg1, arg2, ...) -> foo(arg1, arg2,...,block=True).
     
     The wrapped method will then return a deferred to a deferred id.  This will
     only work on method of classes that inherit from `PendingDeferredManager`,
     as that class provides an API for 
     
     block is a boolean to determine if we should use the two phase process or
     just simply call the wrapped method.  At this point block does not have a
     default and it probably won't.
     """
     
     def wrapper_two_phase(pdm, *args, **kwargs):
         try:
             block = kwargs.pop('block')
         except KeyError:
             block = True  # The default if not specified
         if block:
             return wrapped_method(pdm, *args, **kwargs)
         else:
             d = wrapped_method(pdm, *args, **kwargs)
             deferred_id=pdm.save_pending_deferred(d)
             return defer.succeed(deferred_id)
     
     return wrapper_two_phase
                 
                 
             
             
                 

IPython/kernel/scripts/ipcontroller.py

@@ -1,416 +1,416 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
 """The IPython controller."""
 
 __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
 #-------------------------------------------------------------------------------
 
 # Python looks for an empty string at the beginning of sys.path to enable
 # importing from the cwd.
 import sys
 sys.path.insert(0, '')
 
 from optparse import OptionParser
 import os
 import time
 import tempfile
 
 from twisted.application import internet, service
 from twisted.internet import reactor, error, defer
 from twisted.python import log
 
 from IPython.kernel.fcutil import Tub, UnauthenticatedTub, have_crypto
 
-# from IPython.tools import growl
+# from IPython.utils import growl
 # growl.start("IPython1 Controller")
 
 from IPython.kernel.error import SecurityError
 from IPython.kernel import controllerservice
 from IPython.kernel.fcutil import check_furl_file_security
 
 # Create various ipython directories if they don't exist.
 # This must be done before IPython.kernel.config is imported.
 from IPython.core.iplib import user_setup
 from IPython.utils.genutils import get_ipython_dir, get_log_dir, get_security_dir
 if os.name == 'posix':
     rc_suffix = ''
 else:
     rc_suffix = '.ini'
 user_setup(get_ipython_dir(), rc_suffix, mode='install', interactive=False)
 get_log_dir()
 get_security_dir()
 
 from IPython.kernel.config import config_manager as kernel_config_manager
 from IPython.config.cutils import import_item
 
 
 #-------------------------------------------------------------------------------
 # Code
 #-------------------------------------------------------------------------------
 
 def get_temp_furlfile(filename):
     return tempfile.mktemp(dir=os.path.dirname(filename),
                            prefix=os.path.basename(filename))
 
 def make_tub(ip, port, secure, cert_file):
     """
     Create a listening tub given an ip, port, and cert_file location.
     
     :Parameters:
         ip : str
             The ip address that the tub should listen on.  Empty means all
         port : int
             The port that the tub should listen on.  A value of 0 means
             pick a random port
         secure: boolean
             Will the connection be secure (in the foolscap sense)
         cert_file:
             A filename of a file to be used for theSSL certificate
     """
     if secure:
         if have_crypto:
             tub = Tub(certFile=cert_file)
         else:
             raise SecurityError("""
 OpenSSL/pyOpenSSL is not available, so we can't run in secure mode.
 Try running without security using 'ipcontroller -xy'.
 """)
     else:
         tub = UnauthenticatedTub()
     
     # Set the strport based on the ip and port and start listening
     if ip == '':
         strport = "tcp:%i" % port
     else:
         strport = "tcp:%i:interface=%s" % (port, ip)
     listener = tub.listenOn(strport)
     
     return tub, listener
 
 def make_client_service(controller_service, config):
     """
     Create a service that will listen for clients.
     
     This service is simply a `foolscap.Tub` instance that has a set of Referenceables
     registered with it.
     """
 
     # Now create the foolscap tub
     ip = config['controller']['client_tub']['ip']
     port = config['controller']['client_tub'].as_int('port')
     location = config['controller']['client_tub']['location']
     secure = config['controller']['client_tub']['secure']
     cert_file = config['controller']['client_tub']['cert_file']
     client_tub, client_listener = make_tub(ip, port, secure, cert_file)
     
     # Set the location in the trivial case of localhost
     if ip == 'localhost' or ip == '127.0.0.1':
         location = "127.0.0.1"
     
     if not secure:
         log.msg("WARNING: you are running the controller with no client security")
     
     def set_location_and_register():
         """Set the location for the tub and return a deferred."""
 
         def register(empty, ref, furl_file):
             # We create and then move to make sure that when the file
             # appears to other processes, the buffer has the flushed
             # and the file has been closed
             temp_furl_file = get_temp_furlfile(furl_file)
             client_tub.registerReference(ref, furlFile=temp_furl_file)
             os.rename(temp_furl_file, furl_file)
         
         if location == '':
             d = client_tub.setLocationAutomatically()
         else:
             d = defer.maybeDeferred(client_tub.setLocation, "%s:%i" % (location, client_listener.getPortnum()))
         
         for ciname, ci in config['controller']['controller_interfaces'].iteritems():
             log.msg("Adapting Controller to interface: %s" % ciname)
             furl_file = ci['furl_file']
             log.msg("Saving furl for interface [%s] to file: %s" % (ciname, furl_file))
             check_furl_file_security(furl_file, secure)
             adapted_controller = import_item(ci['controller_interface'])(controller_service)
             d.addCallback(register, import_item(ci['fc_interface'])(adapted_controller), 
                 furl_file=ci['furl_file'])
     
     reactor.callWhenRunning(set_location_and_register)
     return client_tub
 
 
 def make_engine_service(controller_service, config):
     """
     Create a service that will listen for engines.
     
     This service is simply a `foolscap.Tub` instance that has a set of Referenceables
     registered with it.
     """
 
     # Now create the foolscap tub
     ip = config['controller']['engine_tub']['ip']
     port = config['controller']['engine_tub'].as_int('port')
     location = config['controller']['engine_tub']['location']
     secure = config['controller']['engine_tub']['secure']
     cert_file = config['controller']['engine_tub']['cert_file']
     engine_tub, engine_listener = make_tub(ip, port, secure, cert_file)
     
     # Set the location in the trivial case of localhost
     if ip == 'localhost' or ip == '127.0.0.1':
         location = "127.0.0.1"
     
     if not secure:
         log.msg("WARNING: you are running the controller with no engine security")
     
     def set_location_and_register():
         """Set the location for the tub and return a deferred."""
 
         def register(empty, ref, furl_file):
             # We create and then move to make sure that when the file
             # appears to other processes, the buffer has the flushed
             # and the file has been closed
             temp_furl_file = get_temp_furlfile(furl_file)
             engine_tub.registerReference(ref, furlFile=temp_furl_file)
             os.rename(temp_furl_file, furl_file)
         
         if location == '':
             d = engine_tub.setLocationAutomatically()
         else:
             d = defer.maybeDeferred(engine_tub.setLocation, "%s:%i" % (location, engine_listener.getPortnum()))
     
         furl_file = config['controller']['engine_furl_file']
         engine_fc_interface = import_item(config['controller']['engine_fc_interface'])
         log.msg("Saving furl for the engine to file: %s" % furl_file)
         check_furl_file_security(furl_file, secure)
         fc_controller = engine_fc_interface(controller_service)
         d.addCallback(register, fc_controller, furl_file=furl_file)
     
     reactor.callWhenRunning(set_location_and_register)
     return engine_tub
     
 def start_controller():
     """
     Start the controller by creating the service hierarchy and starting the reactor.
     
     This method does the following:
     
         * It starts the controller logging
         * In execute an import statement for the controller
         * It creates 2 `foolscap.Tub` instances for the client and the engines
           and registers `foolscap.Referenceables` with the tubs to expose the
           controller to engines and clients.
     """
     config = kernel_config_manager.get_config_obj()
     
     # Start logging
     logfile = config['controller']['logfile']
     if logfile:
         logfile = logfile + str(os.getpid()) + '.log'
         try:
             openLogFile = open(logfile, 'w')
         except:
             openLogFile = sys.stdout
     else:
         openLogFile = sys.stdout
     log.startLogging(openLogFile)
     
     # Execute any user defined import statements
     cis = config['controller']['import_statement']
     if cis:
         try:
             exec cis in globals(), locals()
         except:
             log.msg("Error running import_statement: %s" % cis)
     
     # Delete old furl files unless the reuse_furls is set
     reuse = config['controller']['reuse_furls']
     if not reuse:
         paths = (config['controller']['engine_furl_file'],
             config['controller']['controller_interfaces']['task']['furl_file'],
             config['controller']['controller_interfaces']['multiengine']['furl_file']
         )
         for p in paths:
             if os.path.isfile(p):
                 os.remove(p)
     
     # Create the service hierarchy
     main_service = service.MultiService()
     # The controller service
     controller_service = controllerservice.ControllerService()
     controller_service.setServiceParent(main_service)
     # The client tub and all its refereceables
     client_service = make_client_service(controller_service, config)
     client_service.setServiceParent(main_service)
     # The engine tub
     engine_service = make_engine_service(controller_service, config)
     engine_service.setServiceParent(main_service)
     # Start the controller service and set things running
     main_service.startService()
     reactor.run()
 
 def init_config():
     """
     Initialize the configuration using default and command line options.
     """
     
     parser = OptionParser("""ipcontroller [options]
 
 Start an IPython controller.
 
 Use the IPYTHONDIR environment variable to change your IPython directory 
 from the default of .ipython or _ipython.  The log and security 
 subdirectories of your IPython directory will be used by this script 
 for log files and security files.""")
     
     # Client related options
     parser.add_option(
         "--client-ip", 
         type="string",
         dest="client_ip",
         help="the IP address or hostname the controller will listen on for client connections"
     )
     parser.add_option(
         "--client-port", 
         type="int", 
         dest="client_port",
         help="the port the controller will listen on for client connections"
     )    
     parser.add_option(
         '--client-location',
         type="string",
         dest="client_location",
         help="hostname or ip for clients to connect to"
     )
     parser.add_option(
         "-x",
         action="store_false",
         dest="client_secure",
         help="turn off all client security"
     )
     parser.add_option(
         '--client-cert-file',
         type="string",
         dest="client_cert_file",
         help="file to store the client SSL certificate"
     )
     parser.add_option(
         '--task-furl-file',
         type="string",
         dest="task_furl_file",
         help="file to store the FURL for task clients to connect with"
     )
     parser.add_option(
         '--multiengine-furl-file',
         type="string",
         dest="multiengine_furl_file",
         help="file to store the FURL for multiengine clients to connect with"
     )
     # Engine related options
     parser.add_option(
         "--engine-ip", 
         type="string",
         dest="engine_ip",
         help="the IP address or hostname the controller will listen on for engine connections"
     )
     parser.add_option(
         "--engine-port", 
         type="int", 
         dest="engine_port",
         help="the port the controller will listen on for engine connections"
     )    
     parser.add_option(
         '--engine-location',
         type="string",
         dest="engine_location",
         help="hostname or ip for engines to connect to"
     )
     parser.add_option(
         "-y",
         action="store_false",
         dest="engine_secure",
         help="turn off all engine security"
     )
     parser.add_option(
         '--engine-cert-file',
         type="string",
         dest="engine_cert_file",
         help="file to store the engine SSL certificate"
     )
     parser.add_option(
         '--engine-furl-file',
         type="string",
         dest="engine_furl_file",
         help="file to store the FURL for engines to connect with"
     )
     parser.add_option(
         "-l", "--logfile",
         type="string",
         dest="logfile",
         help="log file name (default is stdout)"
     )
     parser.add_option(
         "-r",
         action="store_true",
         dest="reuse_furls",
         help="try to reuse all furl files"
     )
     
     (options, args) = parser.parse_args()
     
     config = kernel_config_manager.get_config_obj()
     
     # Update with command line options
     if options.client_ip is not None:
         config['controller']['client_tub']['ip'] = options.client_ip
     if options.client_port is not None:
         config['controller']['client_tub']['port'] = options.client_port
     if options.client_location is not None:
         config['controller']['client_tub']['location'] = options.client_location
     if options.client_secure is not None:
         config['controller']['client_tub']['secure'] = options.client_secure
     if options.client_cert_file is not None:
         config['controller']['client_tub']['cert_file'] = options.client_cert_file
     if options.task_furl_file is not None:
         config['controller']['controller_interfaces']['task']['furl_file'] = options.task_furl_file
     if options.multiengine_furl_file is not None:
         config['controller']['controller_interfaces']['multiengine']['furl_file'] = options.multiengine_furl_file
     if options.engine_ip is not None:
         config['controller']['engine_tub']['ip'] = options.engine_ip
     if options.engine_port is not None:
         config['controller']['engine_tub']['port'] = options.engine_port
     if options.engine_location is not None:
         config['controller']['engine_tub']['location'] = options.engine_location
     if options.engine_secure is not None:
         config['controller']['engine_tub']['secure'] = options.engine_secure
     if options.engine_cert_file is not None:
         config['controller']['engine_tub']['cert_file'] = options.engine_cert_file
     if options.engine_furl_file is not None:
         config['controller']['engine_furl_file'] = options.engine_furl_file
     if options.reuse_furls is not None:
             config['controller']['reuse_furls'] = options.reuse_furls
 
     if options.logfile is not None:
         config['controller']['logfile'] = options.logfile
     
     kernel_config_manager.update_config_obj(config)
 
 def main():
     """
     After creating the configuration information, start the controller.
     """
     init_config()
     start_controller()
     
 if __name__ == "__main__":
     main()

IPython/scripts/ipython

@@ -1,28 +1,28 b''
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """IPython -- An enhanced Interactive Python
 
 This is just the startup wrapper script, kept deliberately to a minimum.
 
 The shell's mainloop() takes an optional argument, sys_exit (default=0). If
 set to 1, it calls sys.exit() at exit time. You can use the following code in
 your PYTHONSTARTUP file:
 
 import IPython
 IPython.Shell.IPShell().mainloop(sys_exit=1)
 
 [or simply IPython.Shell.IPShell().mainloop(1) ]
 
 and IPython will be your working environment when you start python. The final
 sys.exit() call will make python exit transparently when IPython finishes, so
 you don't have an extra prompt to get out of.
 
 This is probably useful to developers who manage multiple Python versions and
 don't want to have correspondingly multiple IPython versions. Note that in
 this mode, there is no way to pass IPython any command-line options, as those
 are trapped first by Python itself.
 """
 
-import IPython.Shell
+import IPython.core.shell
 
-IPython.Shell.start().mainloop()
+IPython.core.shell.start().mainloop()

IPython/scripts/irunner

@@ -1,9 +1,9 b''
 #!/usr/bin/env python
 
 """Thin wrapper around the IPython irunner module.
 
 Run with --help for details, or see the irunner source."""
 
-from IPython import irunner
+from IPython.lib import irunner
 
 irunner.main()

IPython/scripts/pycolor

@@ -1,6 +1,6 b''
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """Simple wrapper around PyColorize, which colorizes python sources."""
 
-import IPython.PyColorize
-IPython.PyColorize.main()
+import IPython.utils.PyColorize
+IPython.utils.PyColorize.main()

MANIFEST.in

@@ -1,32 +1,36 b''
 include ipython.py
 include setupbase.py
 include setupegg.py
 
-graft scripts
-
 graft setupext
 
-graft IPython/UserConfig
-
 graft IPython/kernel
 graft IPython/config
+graft IPython/core
+graft IPython/deathrow
+graft IPython/external
+graft IPython/frontend
+graft IPython/gui
+graft IPython/lib
+graft IPython/quarantine
+graft IPython/scripts
 graft IPython/testing
-graft IPython/tools
+graft IPython/utils
 
 recursive-include IPython/Extensions igrid_help*
 
 graft docs
 exclude docs/\#*
 exclude docs/man/*.1
 
 # docs subdirs we want to skip
 prune docs/attic
 prune docs/build
 
 global-exclude *~
 global-exclude *.flc
 global-exclude *.pyc
 global-exclude .dircopy.log
 global-exclude .svn
 global-exclude .bzr
 global-exclude .hgignore

docs/source/conf.py

@@ -1,191 +1,191 b''
 # -*- coding: utf-8 -*-
 #
 # IPython documentation build configuration file.
 
 # NOTE: This file has been edited manually from the auto-generated one from
 # sphinx.  Do NOT delete and re-generate.  If any changes from sphinx are
 # needed, generate a scratch one and merge by hand any new fields needed.
 
 #
 # This file is execfile()d with the current directory set to its containing dir.
 #
 # The contents of this file are pickled, so don't put values in the namespace
 # that aren't pickleable (module imports are okay, they're removed automatically).
 #
 # All configuration values have a default value; values that are commented out
 # serve to show the default value.
 
 import sys, os
 
 # If your extensions are in another directory, add it here. If the directory
 # is relative to the documentation root, use os.path.abspath to make it
 # absolute, like shown here.
 sys.path.append(os.path.abspath('../sphinxext'))
 
 # Import support for ipython console session syntax highlighting (lives
 # in the sphinxext directory defined above)
 import ipython_console_highlighting
 
 # We load the ipython release info into a dict by explicit execution
 iprelease = {}
-execfile('../../IPython/Release.py',iprelease)
+execfile('../../IPython/core/release.py',iprelease)
 
 # General configuration
 # ---------------------
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = ['sphinx.ext.autodoc',
               'sphinx.ext.doctest',
               
               'only_directives',
               'inheritance_diagram',
               'ipython_console_highlighting', 
               # 'plot_directive', # disabled for now, needs matplotlib
               'numpydoc',  # to preprocess docstrings
               ]
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
 
 # The suffix of source filenames.
 source_suffix = '.txt'
 
 # The master toctree document.
 master_doc = 'index'
 
 # General substitutions.
 project = 'IPython'
 copyright = '2008, The IPython Development Team'
 
 # The default replacements for |version| and |release|, also used in various
 # other places throughout the built documents.
 #
 # The full version, including alpha/beta/rc tags.
 release = iprelease['version']
 # The short X.Y version.
 version = '.'.join(release.split('.',2)[:2])
 
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
 #today = ''
 # Else, today_fmt is used as the format for a strftime call.
 today_fmt = '%B %d, %Y'
 
 # List of documents that shouldn't be included in the build.
 #unused_docs = []
 
 # List of directories, relative to source directories, that shouldn't be searched
 # for source files.
 exclude_dirs = ['attic']
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
 #add_function_parentheses = True
 
 # If true, the current module name will be prepended to all description
 # unit titles (such as .. function::).
 #add_module_names = True
 
 # If true, sectionauthor and moduleauthor directives will be shown in the
 # output. They are ignored by default.
 #show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
 pygments_style = 'sphinx'
 
 
 # Options for HTML output
 # -----------------------
 
 # The style sheet to use for HTML and HTML Help pages. A file of that name
 # must exist either in Sphinx' static/ path, or in one of the custom paths
 # given in html_static_path.
 html_style = 'default.css'
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
 #html_title = None
 
 # The name of an image file (within the static path) to place at the top of
 # the sidebar.
 #html_logo = None
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ['_static']
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
 html_last_updated_fmt = '%b %d, %Y'
 
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
 #html_use_smartypants = True
 
 # Custom sidebar templates, maps document names to template names.
 #html_sidebars = {}
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
 #html_additional_pages = {}
 
 # If false, no module index is generated.
 #html_use_modindex = True
 
 # If true, the reST sources are included in the HTML build as _sources/<name>.
 #html_copy_source = True
 
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
 # base URL from which the finished HTML is served.
 #html_use_opensearch = ''
 
 # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
 #html_file_suffix = ''
 
 # Output file base name for HTML help builder.
 htmlhelp_basename = 'ipythondoc'
 
 
 # Options for LaTeX output
 # ------------------------
 
 # The paper size ('letter' or 'a4').
 latex_paper_size = 'letter'
 
 # The font size ('10pt', '11pt' or '12pt').
 latex_font_size = '11pt'
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, document class [howto/manual]).
 
 latex_documents = [ ('index', 'ipython.tex', 'IPython Documentation',
                      ur"""The IPython Development Team""",
                      'manual'),
                     ]
 
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.
 #latex_logo = None
 
 # For "manual" documents, if this is true, then toplevel headings are parts,
 # not chapters.
 #latex_use_parts = False
 
 # Additional stuff for the LaTeX preamble.
 #latex_preamble = ''
 
 # Documents to append as an appendix to all manuals.
 #latex_appendices = []
 
 # If false, no module index is generated.
 #latex_use_modindex = True
 
 
 # Cleanup
 # -------
 # delete release info to avoid pickling errors from sphinx
 
 del iprelease

docs/source/development/reorg.txt

@@ -1,261 +1,266 b''
 =============================
 IPython module reorganization
 =============================
 
 Currently, IPython has many top-level modules that serve many different purposes.
 The lack of organization make it very difficult for developers to work on IPython
 and understand its design. This document contains notes about how we will reorganize
 the modules into sub-packages.
 
 .. warning::
 
     This effort will possibly break third party packages that use IPython as
     a library or hack on the IPython internals.
 
 .. warning::
 
     This effort will result in the removal from IPython of certain modules
     that are not used anymore, don't currently work, are unmaintained, etc.
 
 
 Current subpackges
 ==================
 
 IPython currently has the following sub-packages:
 
 * :mod:`IPython.config`
 
 * :mod:`IPython.Extensions`
 
 * :mod:`IPython.external`
 
 * :mod:`IPython.frontend`
 
 * :mod:`IPython.gui`
 
 * :mod:`IPython.kernel`
 
 * :mod:`IPython.testing`
 
 * :mod:`IPython.tests`
 
 * :mod:`IPython.tools`
 
 * :mod:`IPython.UserConfig`
 
 New Subpackages to be created
 =============================
 
 We propose to create the following new sub-packages:
 
 * :mod:`IPython.core`. This sub-package will contain the core of the IPython
   interpreter, but none of its extended capabilities.
 
 * :mod:`IPython.lib`. IPython has many extended capabilities that are not part
   of the IPython core. These things will go here.  Any better names than 
   :mod:`IPython.lib`?
 
 * :mod:`IPython.utils`. This sub-package will contain anything that might
   eventually be found in the Python standard library, like things in
   :mod:`genutils`. Each sub-module in this sub-package should contain
   functions and classes that serve a single purpose.
 
 * :mod:`IPython.deathrow`. This is for code that is untested and/or rotting
   and needs to be removed from IPython. Eventually all this code will either
   i) be revived by someone willing to maintain it with tests and docs and
   re-included into IPython or 2) be removed from IPython proper, but put into
   a separate top-level (not IPython) package that we keep around. No new code
   will be allowed here.
 
 * :mod:`IPython.quarantine`.  This is for code that doesn't meet IPython's 
   standards, but that we plan on keeping.  To be moved out of this sub-package
   a module needs to have a maintainer, tests and documentation.
 
 Prodecure
 =========
 
 1. Move the file to its new location with its new name.
 2. Rename all import statements to reflect the change.
 3. Run PyFlakes on each changes module.
 3. Add tests/test_imports.py to test it.
 
 Need to modify iptests to properly skip modules that are no longer top
 level modules.
 
 Need to update the top level IPython/__init__.py file.
 
+Need to get installation working correctly.
+
+When running python setup.py sdist, the Sphinx API docs fail to build because
+of something going on with IPython.core.fakemodule
+
 Where things will be moved
 ==========================
 
 Top-level modules:
 
 * :file:`background_jobs.py`.  Move to :file:`IPython/lib/backgroundjobs.py`.
 
 * :file:`ColorANSI.py`.  Move to :file:`IPython/utils/coloransi.py`.
 
 * :file:`completer.py`.  Move to :file:`IPython/core/completer.py`.
 
 * :file:`ConfigLoader.py`.  Move to :file:`IPython/config/configloader.py`.
 
 * :file:`CrashHandler.py`.  Move to :file:`IPython/core/crashhandler`.
 
 * :file:`Debugger.py`.  Move to :file:`IPython/core/debugger.py`.
 
 * :file:`deep_reload.py`.  Move to :file:`IPython/lib/deepreload.py`.
 
 * :file:`demo.py`.  Move to :file:`IPython/lib/demo.py`.
 
 * :file:`DPyGetOpt.py`.  Move to :mod:`IPython.utils` and replace with newer options parser.
 
 * :file:`dtutils.py`.  Move to :file:`IPython.deathrow`.
 
 * :file:`excolors.py`.  Move to :file:`IPython.core` or :file:`IPython.config`.
   Maybe move to :mod:`IPython.lib` or :mod:`IPython.python`?
 
 * :file:`FakeModule.py`.  Move to :file:`IPython/core/fakemodule.py`.
 
 * :file:`generics.py`.  Move to :file:`IPython.python`.
 
 * :file:`genutils.py`.  Move to :file:`IPython.utils`.
 
 * :file:`Gnuplot2.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`GnuplotInteractive.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`GnuplotRuntime.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`numutils.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`twshell.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`Extensions`. This needs to be gone through separately.  Minimally,
   the package should be renamed to :file:`extensions`.
 
 * :file:`history.py`.  Move to :file:`IPython.core`.
 
 * :file:`hooks.py`.  Move to :file:`IPython.core`.
 
 * :file:`ipapi.py`.  Move to :file:`IPython.core`.
 
 * :file:`iplib.py`.  Move to :file:`IPython.core`.
 
 * :file:`ipmaker.py`:  Move to :file:`IPython.core`.
 
 * :file:`ipstruct.py`.  Move to :file:`IPython.python`.
 
 * :file:`irunner.py`.  Move to :file:`IPython.scripts`. ???
 
 * :file:`Itpl.py`. Move to :file:`deathrow/Itpl.py`. Copy already in
   :file:`IPython.external`.
 
 * :file:`Logger.py`.  Move to :file:`IPython/core/logger.py`.
 
 * :file:`macro.py`.  Move to :file:`IPython.core`.
 
 * :file:`Magic.py`.  Move to :file:`IPython/core/magic.py`.
 
 * :file:`OInspect.py`.  Move to :file:`IPython/core/oinspect.py`.
 
 * :file:`OutputTrap.py`.  Move to :file:`IPython/core/outputtrap.py`.
 
 * :file:`platutils.py`.  Move to :file:`IPython.python`.
 
 * :file:`platutils_dummy.py`.  Move to :file:`IPython.python`.
 
 * :file:`platutils_posix.py`.  Move to :file:`IPython.python`.
 
 * :file:`platutils_win32.py`.  Move to :file:`IPython.python`.
 
 * :file:`prefilter.py`:  Move to :file:`IPython.core`.
 
 * :file:`Prompts.py`.  Move to :file:`IPython/core/prompts.py` or
   :file:`IPython/frontend/prompts.py`.
 
 * :file:`PyColorize.py`. Replace with pygments? If not, move to
   :file:`IPython/core/pycolorize.py`. Maybe move to :mod:`IPython.lib` or
   :mod:`IPython.python`?
 
 * :file:`Release.py`.  Move to ??? or remove?
 
 * :file:`rlineimpl.py`.  Move to :file:`IPython.core`.
 
 * :file:`shadowns.py`.  Move to :file:`IPython.core`.
 
 * :file:`Shell.py`.  Move to :file:`IPython.core.shell.py` or
   :file:`IPython/frontend/shell.py`.
 
 * :file:`shellglobals.py`.  Move to :file:`IPython.core`.
 
 * :file:`strdispatch.py`.  Move to :file:`IPython.python`.
 
 * :file:`twshell.py`.  Move to :file:`IPython.sandbox`.
 
 * :file:`ultraTB.py`.  Move to :file:`IPython/core/ultratb.py`.
 
 * :file:`upgrade_dir.py`.  Move to :file:`IPython/utils/upgradedir.py`.
 
 * :file:`usage.py`.  Move to :file:`IPython.core`.
 
 * :file:`wildcard.py`.  Move to :file:`IPython.utils`.
 
 * :file:`winconsole.py`.  Move to :file:`IPython.utils`.
 
 Top-level sub-packages:
 
 * :file:`testing`.  Good where it is.
 
 * :file:`tests`.  Remove.
 
 * :file:`tools`.  Things in here need to be looked at and moved elsewhere like
     :file:`IPython.utils`.
 
 * :file:`UserConfig`.  Move to :file:`IPython.config.userconfig`.
 
 * :file:`config`.  Good where it is!
 
 * :file:`external`.  Good where it is!
 
 * :file:`frontend`.  Good where it is!
 
 * :file:`gui`.  Eventually this should be moved to a subdir of   
   :file:`IPython.frontend`.
 
 * :file:`kernel`.  Good where it is.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Other things
 ============
 
 When these files are moved around, a number of other things will happen at the same time:
 
 1. Test files will be created for each module in IPython. Minimally, all
    modules will be imported as a part of the test. This will serve as a 
    test of the module reorganization. These tests will be put into new
    :file:`tests` subdirectories that each package will have.
 
 2. PyFlakes and other code checkers will be run to look for problems.
 
 3. Modules will be renamed to comply with PEP 8 naming conventions:  all
    lowercase and no special characters like ``-`` or ``_``.
 
 4. Existing tests will be moved to the appropriate :file:`tests`
    subdirectories.
 
 
 
 

ipython.py

@@ -1,11 +1,11 b''
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """IPython -- An enhanced Interactive Python
 
 The actual ipython script to be installed with 'python setup.py install' is
 in './scripts' directory. This file is here (ipython source root directory)
 to facilitate non-root 'zero-installation' (just copy the source tree
 somewhere and run ipython.py) and development. """
 
-import IPython.Shell
-IPython.Shell.start().mainloop()
+import IPython.core.shell
+IPython.core.shell.start().mainloop()

setup.py

@@ -1,189 +1,190 b''
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """Setup script for IPython.
 
 Under Posix environments it works like a typical setup.py script. 
 Under Windows, the command sdist is not supported, since IPython 
 requires utilities which are not available under Windows."""
 
 #-------------------------------------------------------------------------------
 #  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
 #-------------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 import sys
 
 from glob import glob
 
 # BEFORE importing distutils, remove MANIFEST. distutils doesn't properly
 # update it when the contents of directories change.
 if os.path.exists('MANIFEST'): os.remove('MANIFEST')
 
 from distutils.core import setup
 
-# Local imports
 from IPython.utils.genutils import target_update
 
 from setupbase import (
     setup_args, 
     find_packages, 
     find_package_data, 
     find_scripts,
     find_data_files,
     check_for_dependencies
 )
 
 isfile = os.path.isfile
+pjoin = os.path.join
 
 #-------------------------------------------------------------------------------
 # Handle OS specific things
 #-------------------------------------------------------------------------------
 
 if os.name == 'posix':
     os_name = 'posix'
 elif os.name in ['nt','dos']:
     os_name = 'windows'
 else:
     print 'Unsupported operating system:',os.name
     sys.exit(1)
 
 # Under Windows, 'sdist' has not been supported.  Now that the docs build with
 # Sphinx it might work, but let's not turn it on until someone confirms that it
 # actually works.
 if os_name == 'windows' and 'sdist' in sys.argv:
     print 'The sdist command is not available under Windows.  Exiting.'
     sys.exit(1)
 
 #-------------------------------------------------------------------------------
 # Things related to the IPython documentation
 #-------------------------------------------------------------------------------
 
 # update the manuals when building a source dist
 if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):
     import textwrap
 
     # List of things to be updated. Each entry is a triplet of args for
     # target_update()
     to_update = [
                   # FIXME - Disabled for now: we need to redo an automatic way
                   # of generating the magic info inside the rst.                
                   #('docs/magic.tex',
                   #['IPython/Magic.py'],
                   #"cd doc && ./update_magic.sh" ),
                  
                  ('docs/man/ipython.1.gz',
                   ['docs/man/ipython.1'],
                   "cd docs/man && gzip -9c ipython.1 > ipython.1.gz"),
 
                  ('docs/man/pycolor.1.gz',
                   ['docs/man/pycolor.1'],
                   "cd docs/man && gzip -9c pycolor.1 > pycolor.1.gz"),
                  ]
 
     # Only build the docs if sphinx is present
     try:
         import sphinx
     except ImportError:
         pass
     else:
         # The Makefile calls the do_sphinx scripts to build html and pdf, so
         # just one target is enough to cover all manual generation
 
         # First, compute all the dependencies that can force us to rebuild the
         # docs.  Start with the main release file that contains metadata
-        docdeps = ['IPython/Release.py']
+        docdeps = ['IPython/core/release.py']
         # Inculde all the reST sources
         pjoin = os.path.join
         for dirpath,dirnames,filenames in os.walk('docs/source'):
             if dirpath in ['_static','_templates']:
                 continue
             docdeps += [ pjoin(dirpath,f) for f in filenames
                          if f.endswith('.txt') ]
         # and the examples
         for dirpath,dirnames,filenames in os.walk('docs/example'):
             docdeps += [ pjoin(dirpath,f) for f in filenames
                          if not f.endswith('~') ]
         # then, make them all dependencies for the main PDF (the html will get
         # auto-generated as well).
         to_update.append(
             ('docs/dist/ipython.pdf',
              docdeps,
              "cd docs && make dist")
             )
         
     [ target_update(*t) for t in to_update ]
 
     
 #---------------------------------------------------------------------------
 # Find all the packages, package data, scripts and data_files
 #---------------------------------------------------------------------------
 
 packages = find_packages()
 package_data = find_package_data()
 scripts = find_scripts()
 data_files = find_data_files()
 
 #---------------------------------------------------------------------------
 # Handle dependencies and setuptools specific things
 #---------------------------------------------------------------------------
 
 # This dict is used for passing extra arguments that are setuptools 
 # specific to setup
 setuptools_extra_args = {}
 
 if 'setuptools' in sys.modules:
     setuptools_extra_args['zip_safe'] = False
     setuptools_extra_args['entry_points'] = {
         'console_scripts': [
             'ipython = IPython.core.ipapi:launch_new_instance',
-            'pycolor = IPython.PyColorize:main',
+            'pycolor = IPython.utils.PyColorize:main',
             'ipcontroller = IPython.kernel.scripts.ipcontroller:main',
             'ipengine = IPython.kernel.scripts.ipengine:main',
             'ipcluster = IPython.kernel.scripts.ipcluster:main',
             'ipythonx = IPython.frontend.wx.ipythonx:main',
             'iptest = IPython.testing.iptest:main',
+            'irunner = IPython.lib.irunner:main'
         ]
     }
     setup_args['extras_require'] = dict(
         kernel = [
             'zope.interface>=3.4.1',
             'Twisted>=8.0.1',
             'foolscap>=0.2.6'
         ],
         doc='Sphinx>=0.3',
         test='nose>=0.10.1',
         security='pyOpenSSL>=0.6'
     )
     # Allow setuptools to handle the scripts
     scripts = []
 else:
     # package_data of setuptools was introduced to distutils in 2.4
-    cfgfiles = filter(isfile, glob('IPython/UserConfig/*'))
+    cfgfiles = filter(isfile, glob(pjoin('IPython','config','userconfig')))
     if sys.version_info < (2,4):
-        data_files.append(('lib', 'IPython/UserConfig', cfgfiles))
+        data_files.append(('lib', pjoin('IPython','config','userconfig'), cfgfiles))
     # If we are running without setuptools, call this function which will
     # check for dependencies an inform the user what is needed.  This is
     # just to make life easy for users.
     check_for_dependencies()
 
 
 #---------------------------------------------------------------------------
 # Do the actual setup now
 #---------------------------------------------------------------------------
 
 setup_args['packages'] = packages
 setup_args['package_data'] = package_data
 setup_args['scripts'] = scripts
 setup_args['data_files'] = data_files
 setup_args.update(setuptools_extra_args)
 
 if __name__ == '__main__':
     setup(**setup_args)

setupbase.py

@@ -1,279 +1,296 b''
 # encoding: utf-8
 
 """
 This module defines the things that are used in setup.py for building IPython
 
 This includes:
 
     * The basic arguments to setup
     * Functions for finding things like packages, package data, etc.
     * A function for checking dependencies.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import os, sys
 
 from glob import glob
 
 from setupext import install_data_ext
 
 #-------------------------------------------------------------------------------
 # Useful globals and utility functions
 #-------------------------------------------------------------------------------
 
 # A few handy globals
 isfile = os.path.isfile
 pjoin = os.path.join
 
 def oscmd(s):
     print ">", s
     os.system(s)
 
 # A little utility we'll need below, since glob() does NOT allow you to do
 # exclusion on multiple endings!
 def file_doesnt_endwith(test,endings):
     """Return true if test is a file and its name does NOT end with any
     of the strings listed in endings."""
     if not isfile(test):
         return False
     for e in endings:
         if test.endswith(e):
             return False
     return True
 
 #---------------------------------------------------------------------------
 # Basic project information
 #---------------------------------------------------------------------------
 
 # Release.py contains version, authors, license, url, keywords, etc.
-execfile(pjoin('IPython','Release.py'))
+execfile(pjoin('IPython','core','release.py'))
 
 # Create a dict with the basic information
 # This dict is eventually passed to setup after additional keys are added.
 setup_args = dict(
       name             = name,
       version          = version,
       description      = description,
       long_description = long_description,
       author           = author,
       author_email     = author_email,
       url              = url,
       download_url     = download_url,
       license          = license,
       platforms        = platforms,
       keywords         = keywords,
       cmdclass         = {'install_data': install_data_ext},
       )
 
 
 #---------------------------------------------------------------------------
 # Find packages
 #---------------------------------------------------------------------------
 
 def add_package(packages,pname,config=False,tests=False,scripts=False,
                 others=None):
     """
     Add a package to the list of packages, including certain subpackages.
     """
     packages.append('.'.join(['IPython',pname]))
     if config:
         packages.append('.'.join(['IPython',pname,'config']))
     if tests:
         packages.append('.'.join(['IPython',pname,'tests']))
     if scripts:
         packages.append('.'.join(['IPython',pname,'scripts']))
     if others is not None:
         for o in others:
             packages.append('.'.join(['IPython',pname,o]))
 
 def find_packages():
     """
     Find all of IPython's packages.
     """
     packages = ['IPython']
     add_package(packages, 'config', tests=True)
+    add_package(packages, 'config.userconfig')
+    add_package(packages, 'core', tests=True)
+    add_package(packages, 'deathrow', tests=True)
     add_package(packages , 'Extensions')
     add_package(packages, 'external')
-    add_package(packages, 'gui')
-    add_package(packages, 'gui.wx')
     add_package(packages, 'frontend', tests=True)
+    # Don't include the cocoa frontend for now as it is not stable
+    if sys.platform == 'darwin' and False:
+        add_package(packages, 'frontend.cocoa', tests=True, others=['plugin'])
+        add_package(packages, 'frontend.cocoa.examples')
+        add_package(packages, 'frontend.cocoa.examples.IPython1Sandbox')
+        add_package(packages, 'frontend.cocoa.examples.IPython1Sandbox.English.lproj')
     add_package(packages, 'frontend.process')
     add_package(packages, 'frontend.wx')
-    add_package(packages, 'frontend.cocoa', tests=True)
+    add_package(packages, 'gui')
+    add_package(packages, 'gui.wx')
     add_package(packages, 'kernel', config=True, tests=True, scripts=True)
     add_package(packages, 'kernel.core', config=True, tests=True)
+    add_package(packages, 'lib', tests=True)
+    add_package(packages, 'quarantine', tests=True)
+    add_package(packages, 'scripts')
     add_package(packages, 'testing', tests=True)
-    add_package(packages, 'tests')
     add_package(packages, 'testing.plugin', tests=False)
-    add_package(packages, 'tools', tests=True)
-    add_package(packages, 'UserConfig')
+    add_package(packages, 'utils', tests=True)
     return packages
 
 #---------------------------------------------------------------------------
 # Find package data
 #---------------------------------------------------------------------------
 
 def find_package_data():
     """
     Find IPython's package_data.
     """
     # This is not enough for these things to appear in an sdist.
     # We need to muck with the MANIFEST to get this to work
     package_data = {
-        'IPython.UserConfig' : ['*'],
-        'IPython.tools.tests' : ['*.txt'],
+        'IPython.config.userconfig' : ['*'],
         'IPython.testing' : ['*.txt']
     }
     return package_data
 
 
 #---------------------------------------------------------------------------
 # Find data files
 #---------------------------------------------------------------------------
 
 def make_dir_struct(tag,base,out_base):
     """Make the directory structure of all files below a starting dir.
 
     This is just a convenience routine to help build a nested directory
     hierarchy because distutils is too stupid to do this by itself.
 
     XXX - this needs a proper docstring!
     """
     
     # we'll use these a lot below
     lbase = len(base)
     pathsep = os.path.sep
     lpathsep = len(pathsep)
     
     out = []
     for (dirpath,dirnames,filenames) in os.walk(base):
         # we need to strip out the dirpath from the base to map it to the
         # output (installation) path.  This requires possibly stripping the
         # path separator, because otherwise pjoin will not work correctly
         # (pjoin('foo/','/bar') returns '/bar').
         
         dp_eff = dirpath[lbase:]
         if dp_eff.startswith(pathsep):
             dp_eff = dp_eff[lpathsep:]
         # The output path must be anchored at the out_base marker    
         out_path = pjoin(out_base,dp_eff)
         # Now we can generate the final filenames. Since os.walk only produces
         # filenames, we must join back with the dirpath to get full valid file
         # paths:
         pfiles = [pjoin(dirpath,f) for f in filenames]
         # Finally, generate the entry we need, which is a triple of (tag,output
         # path, files) for use as a data_files parameter in install_data.
         out.append((tag,out_path,pfiles))
 
     return out
     
 
 def find_data_files():
     """
     Find IPython's data_files.
 
     Most of these are docs.
     """
     
-    docdirbase  = 'share/doc/ipython'
-    manpagebase = 'share/man/man1'
-
+    docdirbase  = pjoin('share', 'doc', 'ipython')
+    manpagebase = pjoin('share', 'man', 'man1')
+    
     # Simple file lists can be made by hand
-    manpages  = filter(isfile, glob('docs/man/*.1.gz'))
-    igridhelpfiles = filter(isfile, glob('IPython/Extensions/igrid_help.*'))
+    manpages  = filter(isfile, glob(pjoin('docs','man','*.1.gz')))
+    igridhelpfiles = filter(isfile, glob(pjoin('IPython','Extensions','igrid_help.*')))
 
     # For nested structures, use the utility above
-    example_files = make_dir_struct('data','docs/examples',
-                                    pjoin(docdirbase,'examples'))
-    manual_files = make_dir_struct('data','docs/dist',pjoin(docdirbase,'manual'))
+    example_files = make_dir_struct(
+        'data',
+        pjoin('docs','examples'),
+        pjoin(docdirbase,'examples')
+    )
+    manual_files = make_dir_struct(
+        'data',
+        pjoin('docs','dist'),
+        pjoin(docdirbase,'manual')
+    )
 
     # And assemble the entire output list
     data_files = [ ('data',manpagebase, manpages),
                    ('data',pjoin(docdirbase,'extensions'),igridhelpfiles),
                    ] + manual_files + example_files
                  
     ## import pprint  # dbg
     ## print '*'*80
     ## print 'data files'
     ## pprint.pprint(data_files)
     ## print '*'*80
     
     return data_files
 
 #---------------------------------------------------------------------------
 # Find scripts
 #---------------------------------------------------------------------------
 
 def find_scripts():
     """
     Find IPython's scripts.
     """
-    scripts = ['IPython/kernel/scripts/ipengine',
-               'IPython/kernel/scripts/ipcontroller',
-               'IPython/kernel/scripts/ipcluster',
-               'scripts/ipython',
-               'scripts/ipythonx',
-               'scripts/ipython-wx',
-               'scripts/pycolor',
-               'scripts/irunner',
-               'scripts/iptest',
-               ]
+    kernel_scripts = pjoin('IPython','kernel','scripts')
+    main_scripts = pjoin('IPython','scripts')
+    scripts = [pjoin(kernel_scripts, 'ipengine'),
+               pjoin(kernel_scripts, 'ipcontroller'),
+               pjoin(kernel_scripts, 'ipcluster'),
+               pjoin(main_scripts, 'ipython'),
+               pjoin(main_scripts, 'ipythonx'),
+               pjoin(main_scripts, 'ipython-wx'),
+               pjoin(main_scripts, 'pycolor'),
+               pjoin(main_scripts, 'irunner'),
+               pjoin(main_scripts, 'iptest')
+              ]
     
     # Script to be run by the windows binary installer after the default setup
     # routine, to add shortcuts and similar windows-only things.  Windows
     # post-install scripts MUST reside in the scripts/ dir, otherwise distutils
     # doesn't find them.
     if 'bdist_wininst' in sys.argv:
         if len(sys.argv) > 2 and ('sdist' in sys.argv or 'bdist_rpm' in sys.argv):
             print >> sys.stderr,"ERROR: bdist_wininst must be run alone. Exiting."
             sys.exit(1)
-        scripts.append('scripts/ipython_win_post_install.py')
+        scripts.append(pjoin(main_scripts,'ipython_win_post_install.py'))
     
     return scripts
 
 #---------------------------------------------------------------------------
 # Verify all dependencies
 #---------------------------------------------------------------------------
 
 def check_for_dependencies():
     """Check for IPython's dependencies.
     
     This function should NOT be called if running under setuptools!
     """
     from setupext.setupext import (
         print_line, print_raw, print_status, print_message,
         check_for_zopeinterface, check_for_twisted,
         check_for_foolscap, check_for_pyopenssl,
         check_for_sphinx, check_for_pygments,
         check_for_nose, check_for_pexpect
     )
     print_line()
     print_raw("BUILDING IPYTHON")
     print_status('python', sys.version)
     print_status('platform', sys.platform)
     if sys.platform == 'win32':
         print_status('Windows version', sys.getwindowsversion())
     
     print_raw("")
     print_raw("OPTIONAL DEPENDENCIES")
 
     check_for_zopeinterface()
     check_for_twisted()
     check_for_foolscap()
     check_for_pyopenssl()
     check_for_sphinx()
     check_for_pygments()
     check_for_nose()
     check_for_pexpect()