Work on ipcontroller.

* The IPControllerApp now uses ApplicationWithDir to manage the app_dir.
* The setup.py script and ipcontroller script have been updated to use
  the new IPControllerApp.
* launch_new_instance created and being used.

IPython/core/application.py

@@ -1,334 +1,430 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 An application for IPython
 
 Authors:
 
 * Brian Granger
 * Fernando Perez
 
 Notes
 -----
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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 logging
 import os
+
 import sys
 import traceback
 from copy import deepcopy
 
+from IPython.core import release
 from IPython.utils.genutils import get_ipython_dir, filefind
 from IPython.config.loader import (
     PyFileConfigLoader,
     ArgParseConfigLoader,
     Config,
     NoConfigDefault
 )
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 
-class IPythonArgParseConfigLoader(ArgParseConfigLoader):
+class BaseAppArgParseConfigLoader(ArgParseConfigLoader):
     """Default command line options for IPython based applications."""
 
     def _add_other_arguments(self):
         self.parser.add_argument('-ipythondir', '--ipython-dir', 
             dest='Global.ipythondir',type=str,
             help='Set to override default location of Global.ipythondir.',
             default=NoConfigDefault,
             metavar='Global.ipythondir')
         self.parser.add_argument('-p','-profile', '--profile',
             dest='Global.profile',type=str,
             help='The string name of the ipython profile to be used.',
             default=NoConfigDefault,
             metavar='Global.profile')
         self.parser.add_argument('-log_level', '--log-level',
             dest="Global.log_level",type=int,
             help='Set the log level (0,10,20,30,40,50).  Default is 30.',
             default=NoConfigDefault)
         self.parser.add_argument('-config_file', '--config-file',
             dest='Global.config_file',type=str,
             help='Set the config file name to override default.',
             default=NoConfigDefault,
             metavar='Global.config_file')
 
 
 class ApplicationError(Exception):
     pass
 
 
 class Application(object):
     """Load a config, construct an app and run it.
     """
 
     config_file_name = 'ipython_config.py'
     name = 'ipython'
+    description = 'IPython: an enhanced interactive Python shell.'
     default_log_level = logging.WARN
     
 
     def __init__(self):
         self.init_logger()
         self.default_config_file_name = self.config_file_name
 
     def init_logger(self):
         self.log = logging.getLogger(self.__class__.__name__)
         # This is used as the default until the command line arguments are read.
         self.log.setLevel(self.default_log_level)
         self._log_handler = logging.StreamHandler()
         self._log_formatter = logging.Formatter("[%(name)s] %(message)s")
         self._log_handler.setFormatter(self._log_formatter)
         self.log.addHandler(self._log_handler)
 
     def _set_log_level(self, level):
         self.log.setLevel(level)
 
     def _get_log_level(self):
         return self.log.level
 
     log_level = property(_get_log_level, _set_log_level)
 
     def start(self):
         """Start the application."""
         self.attempt(self.create_default_config)
         self.log_default_config()
         self.set_default_config_log_level()
         self.attempt(self.pre_load_command_line_config)
         self.attempt(self.load_command_line_config, action='abort')
         self.set_command_line_config_log_level()
         self.attempt(self.post_load_command_line_config)
         self.log_command_line_config()
         self.attempt(self.find_ipythondir)
         self.attempt(self.find_config_file_name)
         self.attempt(self.find_config_file_paths)
         self.attempt(self.pre_load_file_config)
         self.attempt(self.load_file_config)
         self.set_file_config_log_level()
         self.attempt(self.post_load_file_config)
         self.log_file_config()
         self.attempt(self.merge_configs)
         self.log_master_config()
         self.attempt(self.pre_construct)
         self.attempt(self.construct)
         self.attempt(self.post_construct)
         self.attempt(self.start_app)
 
     #-------------------------------------------------------------------------
     # Various stages of Application creation
     #-------------------------------------------------------------------------
 
     def create_default_config(self):
         """Create defaults that can't be set elsewhere.
 
         For the most part, we try to set default in the class attributes
         of Components.  But, defaults the top-level Application (which is
         not a HasTraitlets or Component) are not set in this way.  Instead
         we set them here.  The Global section is for variables like this that
         don't belong to a particular component.
         """
         self.default_config = Config()
         self.default_config.Global.ipythondir = get_ipython_dir()
+        self.default_config.Global.log_level = self.log_level
 
     def log_default_config(self):
         self.log.debug('Default config loaded:')
         self.log.debug(repr(self.default_config))
 
     def set_default_config_log_level(self):
         try:
             self.log_level = self.default_config.Global.log_level
         except AttributeError:
             # Fallback to the default_log_level class attribute
             pass
 
     def create_command_line_config(self):
         """Create and return a command line config loader."""
-        return IPythonArgParseConfigLoader(description=self.name)
+        return BaseAppArgParseConfigLoader(
+            description=self.description, 
+            version=release.version
+        )
 
     def pre_load_command_line_config(self):
         """Do actions just before loading the command line config."""
         pass
 
     def load_command_line_config(self):
         """Load the command line config."""
         loader = self.create_command_line_config()
         self.command_line_config = loader.load_config()
         self.extra_args = loader.get_extra_args()
 
     def set_command_line_config_log_level(self):
         try:
             self.log_level = self.command_line_config.Global.log_level
         except AttributeError:
             pass
 
     def post_load_command_line_config(self):
         """Do actions just after loading the command line config."""
         pass
 
     def log_command_line_config(self):
         self.log.debug("Command line config loaded:")
         self.log.debug(repr(self.command_line_config))
 
     def find_ipythondir(self):
         """Set the IPython directory.
 
         This sets ``self.ipythondir``, but the actual value that is passed
         to the application is kept in either ``self.default_config`` or
         ``self.command_line_config``.  This also added ``self.ipythondir`` to
         ``sys.path`` so config files there can be references by other config
         files.
         """
 
         try:
             self.ipythondir = self.command_line_config.Global.ipythondir
         except AttributeError:
             self.ipythondir = self.default_config.Global.ipythondir
         sys.path.append(os.path.abspath(self.ipythondir))
         if not os.path.isdir(self.ipythondir):
             os.makedirs(self.ipythondir, mode=0777)
         self.log.debug("IPYTHONDIR set to: %s" % self.ipythondir)
 
     def find_config_file_name(self):
         """Find the config file name for this application.
 
         This must set ``self.config_file_name`` to the filename of the
         config file to use (just the filename). The search paths for the
         config file are set in :meth:`find_config_file_paths` and then passed
         to the config file loader where they are resolved to an absolute path.
 
         If a profile has been set at the command line, this will resolve
         it.
         """
 
         try:
             self.config_file_name = self.command_line_config.Global.config_file
         except AttributeError:
             pass
 
         try:
             self.profile_name = self.command_line_config.Global.profile
             name_parts = self.config_file_name.split('.')
             name_parts.insert(1, '_' + self.profile_name + '.')
             self.config_file_name = ''.join(name_parts)
         except AttributeError:
             pass
 
     def find_config_file_paths(self):
         """Set the search paths for resolving the config file.
 
         This must set ``self.config_file_paths`` to a sequence of search
         paths to pass to the config file loader.
         """
         self.config_file_paths = (os.getcwd(), self.ipythondir)
 
     def pre_load_file_config(self):
         """Do actions before the config file is loaded."""
         pass
 
     def load_file_config(self):
         """Load the config file.
         
         This tries to load the config file from disk.  If successful, the
         ``CONFIG_FILE`` config variable is set to the resolved config file
         location.  If not successful, an empty config is used.
         """
         self.log.debug("Attempting to load config file: <%s>" % self.config_file_name)
         loader = PyFileConfigLoader(self.config_file_name,
                                     path=self.config_file_paths)
         try:
             self.file_config = loader.load_config()
             self.file_config.Global.config_file = loader.full_filename
         except IOError:
             # Only warn if the default config file was NOT being used.
             if not self.config_file_name==self.default_config_file_name:
                 self.log.warn("Config file not found, skipping: <%s>" % \
                                self.config_file_name, exc_info=True)
             self.file_config = Config()
         except:
             self.log.warn("Error loading config file: <%s>" % \
                            self.config_file_name, exc_info=True)
             self.file_config = Config()
 
     def set_file_config_log_level(self):
         # We need to keeep self.log_level updated.  But we only use the value
         # of the file_config if a value was not specified at the command
         # line, because the command line overrides everything.
         if not hasattr(self.command_line_config.Global, 'log_level'):
             try:
                 self.log_level = self.file_config.Global.log_level
             except AttributeError:
                 pass # Use existing value
 
     def post_load_file_config(self):
         """Do actions after the config file is loaded."""
         pass
 
     def log_file_config(self):
         if hasattr(self.file_config.Global, 'config_file'):
             self.log.debug("Config file loaded: <%s>" % self.file_config.Global.config_file)
             self.log.debug(repr(self.file_config))
 
     def merge_configs(self):
         """Merge the default, command line and file config objects."""
         config = Config()
         config._merge(self.default_config)
         config._merge(self.file_config)
         config._merge(self.command_line_config)
         self.master_config = config
 
     def log_master_config(self):
         self.log.debug("Master config created:")
         self.log.debug(repr(self.master_config))
 
     def pre_construct(self):
         """Do actions after the config has been built, but before construct."""
         pass
 
     def construct(self):
         """Construct the main components that make up this app."""
         self.log.debug("Constructing components for application")
 
     def post_construct(self):
         """Do actions after construct, but before starting the app."""
         pass
 
     def start_app(self):
         """Actually start the app."""
         self.log.debug("Starting application")
 
     #-------------------------------------------------------------------------
     # Utility methods
     #-------------------------------------------------------------------------
 
     def abort(self):
         """Abort the starting of the application."""
         self.log.critical("Aborting application: %s" % self.name, exc_info=True)
         sys.exit(1)
 
     def exit(self):
         self.log.critical("Aborting application: %s" % self.name)
         sys.exit(1)
 
     def attempt(self, func, action='abort'):
         try:
             func()
         except SystemExit:
             self.exit()
         except:
             if action == 'abort':
                 self.abort()
             elif action == 'exit':
                 self.exit()
       
+
+class AppWithDirArgParseConfigLoader(ArgParseConfigLoader):
+    """Default command line options for IPython based applications."""
+
+    def _add_other_arguments(self):
+        self.parser.add_argument('-ipythondir', '--ipython-dir', 
+            dest='Global.ipythondir',type=str,
+            help='Set to override default location of Global.ipythondir.',
+            default=NoConfigDefault,
+            metavar='Global.ipythondir')
+        self.parser.add_argument('-p','-profile', '--profile',
+            dest='Global.profile',type=str,
+            help='The string name of the ipython profile to be used.',
+            default=NoConfigDefault,
+            metavar='Global.profile')
+        self.parser.add_argument('-log_level', '--log-level',
+            dest="Global.log_level",type=int,
+            help='Set the log level (0,10,20,30,40,50).  Default is 30.',
+            default=NoConfigDefault)
+        self.parser.add_argument('-app_dir', '--app-dir',
+            dest='Global.app_dir',type=str,
+            help='Set the application directory where everything for this '
+            'application will be found (including the config file).',
+            default=NoConfigDefault,
+            metavar='Global.app_dir')
+
+
+class ApplicationWithDir(Application):
+
+    name = 'appname'
+    description = 'Application: foo and bar it.'
+    config_file_name = 'appname_config.py' 
+    default_log_level = logging.WARN
+
+    def create_default_config(self):
+        super(ApplicationWithDir, self).create_default_config()
+        self.default_config.Global.profile = 'default'
+        self.default_config.Global.app_dir = ''
+
+    def create_command_line_config(self):
+        """Create and return a command line config loader."""
+        return AppWithDirArgParseConfigLoader(
+            description=self.description, 
+            version=release.version
+        )
+
+    def find_config_file_name(self):
+        """Find the config file name for this application."""
+        self.find_app_dir()
+        self.create_app_dir()
+
+    def find_app_dir(self):
+        """This resolves into full paths, the app directory.
+
+        This method must set ``self.app_dir`` to the full path of
+        the directory.
+        """
+        # Instead, first look for an explicit app_dir
+        try:
+            self.app_dir = self.command_line_config.Global.app_dir
+        except AttributeError:
+            self.app_dir = self.default_config.Global.app_dir
+        self.app_dir = os.path.expandvars(os.path.expanduser(self.app_dir))
+        if not self.app_dir:
+            # Then look for a profile
+            try:
+                self.profile = self.command_line_config.Global.profile
+            except AttributeError:
+                self.profile = self.default_config.Global.profile
+            app_dir_name = 'cluster_' + self.profile
+            try_this = os.path.join(os.getcwd(), app_dir_name)
+            if os.path.isdir(try_this):
+                self.app_dir = try_this
+            else:
+                self.app_dir = os.path.join(self.ipythondir, app_dir_name)
+        # These have to be set because they could be different from the one
+        # that we just computed.  Because command line has the highest
+        # priority, this will always end up in the master_config.
+        self.default_config.Global.app_dir = self.app_dir
+        self.command_line_config.Global.app_dir = self.app_dir
+
+    def create_app_dir(self):
+        """Make sure that the cluster, security and log dirs exist."""
+        if not os.path.isdir(self.app_dir):
+            os.makedirs(self.app_dir, mode=0777)
+
+    def find_config_file_paths(self):
+        """Set the search paths for resolving the config file."""
+        self.config_file_paths = (self.app_dir,)

IPython/core/ipapp.py

@@ -1,546 +1,545 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 The main IPython application object
 
 Authors:
 
 * Brian Granger
 * Fernando Perez
 
 Notes
 -----
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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 logging
 import os
 import sys
 import warnings
 
-from IPython.core.application import Application, IPythonArgParseConfigLoader
+from IPython.core.application import Application, BaseAppArgParseConfigLoader
 from IPython.core import release
 from IPython.core.iplib import InteractiveShell
 from IPython.config.loader import (
     NoConfigDefault, 
     Config,
     ConfigError,
     PyFileConfigLoader
 )
 
 from IPython.lib import inputhook
 
 from IPython.utils.ipstruct import Struct
 from IPython.utils.genutils import filefind, get_ipython_dir
 
 #-----------------------------------------------------------------------------
 # Utilities and helpers
 #-----------------------------------------------------------------------------
 
 
 ipython_desc = """
 A Python shell with automatic history (input and output), dynamic object
 introspection, easier configuration, command completion, access to the system
 shell and more.
 """
 
 def pylab_warning():
     msg = """
 
 IPython's -pylab mode has been disabled until matplotlib supports this version
 of IPython.  This version of IPython has greatly improved GUI integration that 
 matplotlib will soon be able to take advantage of.  This will eventually
 result in greater stability and a richer API for matplotlib under IPython.
 However during this transition, you will either need to use an older version
 of IPython, or do the following to use matplotlib interactively::
 
     import matplotlib
     matplotlib.interactive(True)
     matplotlib.use('wxagg')  # adjust for your backend
     %gui -a wx               # adjust for your GUI
     from matplotlib import pyplot as plt
 
 See the %gui magic for information on the new interface.
 """
     warnings.warn(msg, category=DeprecationWarning, stacklevel=1)
 
 
 #-----------------------------------------------------------------------------
 # Main classes and functions
 #-----------------------------------------------------------------------------
 
 cl_args = (
     (('-autocall',), dict(
         type=int, dest='InteractiveShell.autocall', default=NoConfigDefault,
         help='Set the autocall value (0,1,2).',
         metavar='InteractiveShell.autocall')
     ),
     (('-autoindent',), dict(
         action='store_true', dest='InteractiveShell.autoindent', default=NoConfigDefault,
         help='Turn on autoindenting.')
     ),
     (('-noautoindent',), dict(
         action='store_false', dest='InteractiveShell.autoindent', default=NoConfigDefault,
         help='Turn off autoindenting.')
     ),
     (('-automagic',), dict(
         action='store_true', dest='InteractiveShell.automagic', default=NoConfigDefault,
         help='Turn on the auto calling of magic commands.')
     ),
     (('-noautomagic',), dict(
         action='store_false', dest='InteractiveShell.automagic', default=NoConfigDefault,
         help='Turn off the auto calling of magic commands.')
     ),
     (('-autoedit_syntax',), dict(
         action='store_true', dest='InteractiveShell.autoedit_syntax', default=NoConfigDefault,
         help='Turn on auto editing of files with syntax errors.')
     ),
     (('-noautoedit_syntax',), dict(
         action='store_false', dest='InteractiveShell.autoedit_syntax', default=NoConfigDefault,
         help='Turn off auto editing of files with syntax errors.')
     ),
     (('-banner',), dict(
         action='store_true', dest='Global.display_banner', default=NoConfigDefault,
         help='Display a banner upon starting IPython.')
     ),
     (('-nobanner',), dict(
         action='store_false', dest='Global.display_banner', default=NoConfigDefault,
         help="Don't display a banner upon starting IPython.")
     ),
     (('-cache_size',), dict(
         type=int, dest='InteractiveShell.cache_size', default=NoConfigDefault,
         help="Set the size of the output cache.",
         metavar='InteractiveShell.cache_size')
     ),
     (('-classic',), dict(
         action='store_true', dest='Global.classic', default=NoConfigDefault,
         help="Gives IPython a similar feel to the classic Python prompt.")
     ),
     (('-colors',), dict(
         type=str, dest='InteractiveShell.colors', default=NoConfigDefault,
         help="Set the color scheme (NoColor, Linux, and LightBG).",
         metavar='InteractiveShell.colors')
     ),
     (('-color_info',), dict(
         action='store_true', dest='InteractiveShell.color_info', default=NoConfigDefault,
         help="Enable using colors for info related things.")
     ),
     (('-nocolor_info',), dict(
         action='store_false', dest='InteractiveShell.color_info', default=NoConfigDefault,
         help="Disable using colors for info related things.")
     ),
     (('-confirm_exit',), dict(
         action='store_true', dest='InteractiveShell.confirm_exit', default=NoConfigDefault,
         help="Prompt the user when existing.")
     ),
     (('-noconfirm_exit',), dict(
         action='store_false', dest='InteractiveShell.confirm_exit', default=NoConfigDefault,
         help="Don't prompt the user when existing.")
     ),
     (('-deep_reload',), dict(
         action='store_true', dest='InteractiveShell.deep_reload', default=NoConfigDefault,
         help="Enable deep (recursive) reloading by default.")
     ),
     (('-nodeep_reload',), dict(
         action='store_false', dest='InteractiveShell.deep_reload', default=NoConfigDefault,
         help="Disable deep (recursive) reloading by default.")
     ),
     (('-editor',), dict(
         type=str, dest='InteractiveShell.editor', default=NoConfigDefault,
         help="Set the editor used by IPython (default to $EDITOR/vi/notepad).",
         metavar='InteractiveShell.editor')
     ),
     (('-log','-l'), dict(
         action='store_true', dest='InteractiveShell.logstart', default=NoConfigDefault,
         help="Start logging to the default file (./ipython_log.py).")
     ),
     (('-logfile','-lf'), dict(
         type=str, dest='InteractiveShell.logfile', default=NoConfigDefault,
         help="Start logging to logfile.",
         metavar='InteractiveShell.logfile')
     ),
     (('-logappend','-la'), dict(
         type=str, dest='InteractiveShell.logappend', default=NoConfigDefault,
         help="Start logging to logappend in append mode.",
         metavar='InteractiveShell.logfile')
     ),
     (('-pdb',), dict(
         action='store_true', dest='InteractiveShell.pdb', default=NoConfigDefault,
         help="Enable auto calling the pdb debugger after every exception.")
     ),
     (('-nopdb',), dict(
         action='store_false', dest='InteractiveShell.pdb', default=NoConfigDefault,
         help="Disable auto calling the pdb debugger after every exception.")
     ),
     (('-pprint',), dict(
         action='store_true', dest='InteractiveShell.pprint', default=NoConfigDefault,
         help="Enable auto pretty printing of results.")
     ),
     (('-nopprint',), dict(
         action='store_false', dest='InteractiveShell.pprint', default=NoConfigDefault,
         help="Disable auto auto pretty printing of results.")
     ),
     (('-prompt_in1','-pi1'), dict(
         type=str, dest='InteractiveShell.prompt_in1', default=NoConfigDefault,
         help="Set the main input prompt ('In [\#]: ')",
         metavar='InteractiveShell.prompt_in1')
     ),
     (('-prompt_in2','-pi2'), dict(
         type=str, dest='InteractiveShell.prompt_in2', default=NoConfigDefault,
         help="Set the secondary input prompt (' .\D.: ')",
         metavar='InteractiveShell.prompt_in2')
     ),
     (('-prompt_out','-po'), dict(
         type=str, dest='InteractiveShell.prompt_out', default=NoConfigDefault,
         help="Set the output prompt ('Out[\#]:')",
         metavar='InteractiveShell.prompt_out')
     ),
     (('-quick',), dict(
         action='store_true', dest='Global.quick', default=NoConfigDefault,
         help="Enable quick startup with no config files.")
     ),
     (('-readline',), dict(
         action='store_true', dest='InteractiveShell.readline_use', default=NoConfigDefault,
         help="Enable readline for command line usage.")
     ),
     (('-noreadline',), dict(
         action='store_false', dest='InteractiveShell.readline_use', default=NoConfigDefault,
         help="Disable readline for command line usage.")
     ),
     (('-screen_length','-sl'), dict(
         type=int, dest='InteractiveShell.screen_length', default=NoConfigDefault,
         help='Number of lines on screen, used to control printing of long strings.',
         metavar='InteractiveShell.screen_length')
     ),
     (('-separate_in','-si'), dict(
         type=str, dest='InteractiveShell.separate_in', default=NoConfigDefault,
         help="Separator before input prompts.  Default '\n'.",
         metavar='InteractiveShell.separate_in')
     ),
     (('-separate_out','-so'), dict(
         type=str, dest='InteractiveShell.separate_out', default=NoConfigDefault,
         help="Separator before output prompts.  Default 0 (nothing).",
         metavar='InteractiveShell.separate_out')
     ),
     (('-separate_out2','-so2'), dict(
         type=str, dest='InteractiveShell.separate_out2', default=NoConfigDefault,
         help="Separator after output prompts.  Default 0 (nonight).",
         metavar='InteractiveShell.separate_out2')
     ),
     (('-nosep',), dict(
         action='store_true', dest='Global.nosep', default=NoConfigDefault,
         help="Eliminate all spacing between prompts.")
     ),
     (('-term_title',), dict(
         action='store_true', dest='InteractiveShell.term_title', default=NoConfigDefault,
         help="Enable auto setting the terminal title.")
     ),
     (('-noterm_title',), dict(
         action='store_false', dest='InteractiveShell.term_title', default=NoConfigDefault,
         help="Disable auto setting the terminal title.")
     ),
     (('-xmode',), dict(
         type=str, dest='InteractiveShell.xmode', default=NoConfigDefault,
         help="Exception mode ('Plain','Context','Verbose')",
         metavar='InteractiveShell.xmode')
     ),
     (('-ext',), dict(
         type=str, dest='Global.extra_extension', default=NoConfigDefault,
         help="The dotted module name of an IPython extension to load.",
         metavar='Global.extra_extension')
     ),
     (('-c',), dict(
         type=str, dest='Global.code_to_run', default=NoConfigDefault,
         help="Execute the given command string.",
         metavar='Global.code_to_run')
     ),
     (('-i',), dict(
         action='store_true', dest='Global.force_interact', default=NoConfigDefault,
         help="If running code from the command line, become interactive afterwards.")
     ),
     (('-wthread',), dict(
         action='store_true', dest='Global.wthread', default=NoConfigDefault,
         help="Enable wxPython event loop integration.")
     ),
     (('-q4thread','-qthread'), dict(
         action='store_true', dest='Global.q4thread', default=NoConfigDefault,
         help="Enable Qt4 event loop integration. Qt3 is no longer supported.")
     ),
     (('-gthread',), dict(
         action='store_true', dest='Global.gthread', default=NoConfigDefault,
         help="Enable GTK event loop integration.")
     ),
     # # These are only here to get the proper deprecation warnings
     (('-pylab',), dict(
         action='store_true', dest='Global.pylab', default=NoConfigDefault,
-        help="Disabled.  Pylab has been disabled until matplotlib supports this version of IPython.")
+        help="Disabled.  Pylab has been disabled until matplotlib "
+        "supports this version of IPython.")
     )
 )
 
 
-class IPythonAppCLConfigLoader(IPythonArgParseConfigLoader):
+class IPythonAppCLConfigLoader(BaseAppArgParseConfigLoader):
 
     arguments = cl_args
 
 
 _default_config_file_name = 'ipython_config.py'
 
+
 class IPythonApp(Application):
     name = 'ipython'
+    description = 'IPython: an enhanced interactive Python shell.'
     config_file_name = _default_config_file_name
 
     def create_default_config(self):
         super(IPythonApp, self).create_default_config()
         self.default_config.Global.display_banner = True
         
         # If the -c flag is given or a file is given to run at the cmd line
         # like "ipython foo.py", normally we exit without starting the main
         # loop.  The force_interact config variable allows a user to override
         # this and interact.  It is also set by the -i cmd line flag, just
         # like Python.
         self.default_config.Global.force_interact = False
 
         # By default always interact by starting the IPython mainloop.
         self.default_config.Global.interact = True
 
-        # Let the parent class set the default, but each time log_level
-        # changes from config, we need to update self.log_level as that is
-        # what updates the actual log level in self.log.
-        self.default_config.Global.log_level = self.log_level
-
         # No GUI integration by default
         self.default_config.Global.wthread = False
         self.default_config.Global.q4thread = False
         self.default_config.Global.gthread = False
 
     def create_command_line_config(self):
         """Create and return a command line config loader."""
         return IPythonAppCLConfigLoader(
-            description=ipython_desc,
-            version=release.version)
+            description=self.description, 
+            version=release.version
+        )
 
     def post_load_command_line_config(self):
         """Do actions after loading cl config."""
         clc = self.command_line_config
 
         # Display the deprecation warnings about threaded shells
         if hasattr(clc.Global, 'pylab'):
             pylab_warning()
             del clc.Global['pylab']
 
     def load_file_config(self):
         if hasattr(self.command_line_config.Global, 'quick'):
             if self.command_line_config.Global.quick:
                 self.file_config = Config()
                 return
         super(IPythonApp, self).load_file_config()
 
     def post_load_file_config(self):
         if hasattr(self.command_line_config.Global, 'extra_extension'):
             if not hasattr(self.file_config.Global, 'extensions'):
                 self.file_config.Global.extensions = []
             self.file_config.Global.extensions.append(
                 self.command_line_config.Global.extra_extension)
             del self.command_line_config.Global.extra_extension
 
     def pre_construct(self):
         config = self.master_config
 
         if hasattr(config.Global, 'classic'):
             if config.Global.classic:
                 config.InteractiveShell.cache_size = 0
                 config.InteractiveShell.pprint = 0
                 config.InteractiveShell.prompt_in1 = '>>> '
                 config.InteractiveShell.prompt_in2 = '... '
                 config.InteractiveShell.prompt_out = ''
                 config.InteractiveShell.separate_in = \
                     config.InteractiveShell.separate_out = \
                     config.InteractiveShell.separate_out2 = ''
                 config.InteractiveShell.colors = 'NoColor'
                 config.InteractiveShell.xmode = 'Plain'
 
         if hasattr(config.Global, 'nosep'):
             if config.Global.nosep:
                 config.InteractiveShell.separate_in = \
                 config.InteractiveShell.separate_out = \
                 config.InteractiveShell.separate_out2 = ''
 
         # if there is code of files to run from the cmd line, don't interact
         # unless the -i flag (Global.force_interact) is true.
         code_to_run = config.Global.get('code_to_run','')
         file_to_run = False
         if len(self.extra_args)>=1:
             if self.extra_args[0]:
                 file_to_run = True
         if file_to_run or code_to_run:
             if not config.Global.force_interact:
                 config.Global.interact = False
 
     def construct(self):
         # I am a little hesitant to put these into InteractiveShell itself.
         # But that might be the place for them
         sys.path.insert(0, '')
 
         # Create an InteractiveShell instance
         self.shell = InteractiveShell(
             parent=None,
             config=self.master_config
         )
 
     def post_construct(self):
         """Do actions after construct, but before starting the app."""
         config = self.master_config
         
         # shell.display_banner should always be False for the terminal 
         # based app, because we call shell.show_banner() by hand below
         # so the banner shows *before* all extension loading stuff.
         self.shell.display_banner = False
 
         if config.Global.display_banner and \
             config.Global.interact:
             self.shell.show_banner()
 
         # Make sure there is a space below the banner.
         if self.log_level <= logging.INFO: print
 
         # Now a variety of things that happen after the banner is printed.
         self._enable_gui()
         self._load_extensions()
         self._run_exec_lines()
         self._run_exec_files()
         self._run_cmd_line_code()
 
     def _enable_gui(self):
         """Enable GUI event loop integration."""
         config = self.master_config
         try:
             # Enable GUI integration
             if config.Global.wthread:
                 self.log.info("Enabling wx GUI event loop integration")
                 inputhook.enable_wx(app=True)
             elif config.Global.q4thread:
                 self.log.info("Enabling Qt4 GUI event loop integration")
                 inputhook.enable_qt4(app=True)
             elif config.Global.gthread:
                 self.log.info("Enabling GTK GUI event loop integration")
                 inputhook.enable_gtk(app=True)
         except:
             self.log.warn("Error in enabling GUI event loop integration:")
             self.shell.showtraceback()
 
     def _load_extensions(self):
         """Load all IPython extensions in Global.extensions.
 
         This uses the :meth:`InteractiveShell.load_extensions` to load all
         the extensions listed in ``self.master_config.Global.extensions``.
         """
         try:
             if hasattr(self.master_config.Global, 'extensions'):
                 self.log.debug("Loading IPython extensions...")
                 extensions = self.master_config.Global.extensions
                 for ext in extensions:
                     try:
                         self.log.info("Loading IPython extension: %s" % ext)                        
                         self.shell.load_extension(ext)
                     except:
                         self.log.warn("Error in loading extension: %s" % ext)
                         self.shell.showtraceback()
         except:
             self.log.warn("Unknown error in loading extensions:")
             self.shell.showtraceback()
 
     def _run_exec_lines(self):
         """Run lines of code in Global.exec_lines in the user's namespace."""
         try:
             if hasattr(self.master_config.Global, 'exec_lines'):
                 self.log.debug("Running code from Global.exec_lines...")
                 exec_lines = self.master_config.Global.exec_lines
                 for line in exec_lines:
                     try:
                         self.log.info("Running code in user namespace: %s" % line)
                         self.shell.runlines(line)
                     except:
                         self.log.warn("Error in executing line in user namespace: %s" % line)
                         self.shell.showtraceback()
         except:
             self.log.warn("Unknown error in handling Global.exec_lines:")
             self.shell.showtraceback()
 
     def _exec_file(self, fname):
         full_filename = filefind(fname, ['.', self.ipythondir])
         if os.path.isfile(full_filename):
             if full_filename.endswith('.py'):
                 self.log.info("Running file in user namespace: %s" % full_filename)
                 self.shell.safe_execfile(full_filename, self.shell.user_ns)
             elif full_filename.endswith('.ipy'):
                 self.log.info("Running file in user namespace: %s" % full_filename)
                 self.shell.safe_execfile_ipy(full_filename)
             else:
                 self.log.warn("File does not have a .py or .ipy extension: <%s>" % full_filename)
 
     def _run_exec_files(self):
         try:
             if hasattr(self.master_config.Global, 'exec_files'):
                 self.log.debug("Running files in Global.exec_files...")
                 exec_files = self.master_config.Global.exec_files
                 for fname in exec_files:
                     self._exec_file(fname)
         except:
             self.log.warn("Unknown error in handling Global.exec_files:")
             self.shell.showtraceback()
 
     def _run_cmd_line_code(self):
         if hasattr(self.master_config.Global, 'code_to_run'):
             line = self.master_config.Global.code_to_run
             try:
                 self.log.info("Running code given at command line (-c): %s" % line)
                 self.shell.runlines(line)
             except:
                 self.log.warn("Error in executing line in user namespace: %s" % line)
                 self.shell.showtraceback()
             return
         # Like Python itself, ignore the second if the first of these is present
         try:
             fname = self.extra_args[0]
         except:
             pass
         else:
             try:
                 self._exec_file(fname)
             except:
                 self.log.warn("Error in executing file in user namespace: %s" % fname)
                 self.shell.showtraceback()
 
     def start_app(self):
         if self.master_config.Global.interact:
             self.log.debug("Starting IPython's mainloop...")
             self.shell.mainloop()
 
 
 def load_default_config(ipythondir=None):
     """Load the default config file from the default ipythondir.
 
     This is useful for embedded shells.
     """
     if ipythondir is None:
         ipythondir = get_ipython_dir()
     cl = PyFileConfigLoader(_default_config_file_name, ipythondir)
     config = cl.load_config()
     return config
 
 
 def launch_new_instance():
-    """Create a run a full blown IPython instance"""
+    """Create and run a full blown IPython instance"""
     app = IPythonApp()
     app.start()
 

IPython/kernel/ipcontrollerapp.py

@@ -1,310 +1,258 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 The IPython controller application
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2009  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 copy
 import logging
 import os
 import sys
 
 from twisted.application import service
 from twisted.internet import reactor, defer
 from twisted.python import log
 
 from IPython.config.loader import Config, NoConfigDefault
 
-from IPython.core.application import Application, IPythonArgParseConfigLoader
+from IPython.core.application import (
+    ApplicationWithDir, 
+    BaseAppArgParseConfigLoader
+)
+
 from IPython.core import release
 
 from IPython.utils.traitlets import Int, Str, Bool, Instance
 from IPython.utils.importstring import import_item
 
 from IPython.kernel import controllerservice
 from IPython.kernel.configobjfactory import (
     ConfiguredObjectFactory,
     AdaptedConfiguredObjectFactory
 )
 
 from IPython.kernel.fcutil import FCServiceFactory
 
 #-----------------------------------------------------------------------------
 # Default interfaces
 #-----------------------------------------------------------------------------
 
 
 # The default client interfaces for FCClientServiceFactory.Interfaces
 default_client_interfaces = Config()
 default_client_interfaces.Task.interface_chain = [
     'IPython.kernel.task.ITaskController',
     'IPython.kernel.taskfc.IFCTaskController'
 ]
 
 default_client_interfaces.Task.furl_file = 'ipcontroller-tc.furl'
 default_client_interfaces.MultiEngine.interface_chain = [
     'IPython.kernel.multiengine.IMultiEngine',
     'IPython.kernel.multienginefc.IFCSynchronousMultiEngine'
 ]
 
 default_client_interfaces.MultiEngine.furl_file = 'ipcontroller-mec.furl'
 
 # Make this a dict we can pass to Config.__init__ for the default
 default_client_interfaces = dict(copy.deepcopy(default_client_interfaces.items()))
 
 
 
 # The default engine interfaces for FCEngineServiceFactory.Interfaces
 default_engine_interfaces = Config()
 default_engine_interfaces.Default.interface_chain = [
     'IPython.kernel.enginefc.IFCControllerBase'
 ]
 
 default_engine_interfaces.Default.furl_file = 'ipcontroller-engine.furl'
 
 # Make this a dict we can pass to Config.__init__ for the default
 default_engine_interfaces = dict(copy.deepcopy(default_engine_interfaces.items()))
 
 
 #-----------------------------------------------------------------------------
 # Service factories
 #-----------------------------------------------------------------------------
 
 
 class FCClientServiceFactory(FCServiceFactory):
     """A Foolscap implementation of the client services."""
 
     cert_file = Str('ipcontroller-client.pem', config=True)
     Interfaces = Instance(klass=Config, kw=default_client_interfaces,
                           allow_none=False, config=True)
 
 
 class FCEngineServiceFactory(FCServiceFactory):
     """A Foolscap implementation of the engine services."""
 
     cert_file = Str('ipcontroller-engine.pem', config=True)
     Interfaces = Instance(klass=dict, kw=default_engine_interfaces,
                           allow_none=False, config=True)
 
 
 #-----------------------------------------------------------------------------
 # The main application
 #-----------------------------------------------------------------------------
 
 
 cl_args = (
     # Client config
     (('--client-ip',), dict(
         type=str, dest='FCClientServiceFactory.ip', default=NoConfigDefault,
         help='The IP address or hostname the controller will listen on for client connections.',
         metavar='FCClientServiceFactory.ip')
     ),
     (('--client-port',), dict(
         type=int, dest='FCClientServiceFactory.port', default=NoConfigDefault,
         help='The port the controller will listen on for client connections.',
         metavar='FCClientServiceFactory.port')
     ),
     (('--client-location',), dict(
         type=str, dest='FCClientServiceFactory.location', default=NoConfigDefault,
         help='The hostname or ip that clients should connect to.',
         metavar='FCClientServiceFactory.location')
     ),
     (('-x',), dict(
         action='store_false', dest='FCClientServiceFactory.secure', default=NoConfigDefault,
         help='Turn off all client security.')
     ),
     # Engine config
     (('--engine-ip',), dict(
         type=str, dest='FCEngineServiceFactory.ip', default=NoConfigDefault,
         help='The IP address or hostname the controller will listen on for engine connections.',
         metavar='FCEngineServiceFactory.ip')
     ),
     (('--engine-port',), dict(
         type=int, dest='FCEngineServiceFactory.port', default=NoConfigDefault,
         help='The port the controller will listen on for engine connections.',
         metavar='FCEngineServiceFactory.port')
     ),
     (('--engine-location',), dict(
         type=str, dest='FCEngineServiceFactory.location', default=NoConfigDefault,
         help='The hostname or ip that engines should connect to.',
         metavar='FCEngineServiceFactory.location')
     ),
     (('-y',), dict(
         action='store_false', dest='FCEngineServiceFactory.secure', default=NoConfigDefault,
         help='Turn off all engine security.')
     ),
     # Global config
     (('--log-to-file',), dict(
         action='store_true', dest='Global.log_to_file', default=NoConfigDefault,
         help='Log to a file in the log directory (default is stdout)')
     ),
     (('-r','--reuse-furls'), dict(
         action='store_true', dest='Global.reuse_furls', default=NoConfigDefault,
         help='Try to reuse all FURL files.')
-    ),
-    (('-cluster_dir', '--cluster-dir',), dict(
-        type=str, dest='Global.cluster_dir', default=NoConfigDefault,
-        help='Absolute or relative path to the cluster directory.',
-        metavar='Global.cluster_dir')
-    ),
+    )
 )
 
 
-class IPControllerAppCLConfigLoader(IPythonArgParseConfigLoader):
+class IPControllerAppCLConfigLoader(BaseAppArgParseConfigLoader):
 
     arguments = cl_args
 
 
 _default_config_file_name = 'ipcontroller_config.py'
 
-class IPControllerApp(Application):
+
+class IPControllerApp(ApplicationWithDir):
 
     name = 'ipcontroller'
+    description = 'Start the IPython controller for parallel computing.'
     config_file_name = _default_config_file_name
     default_log_level = logging.DEBUG
 
     def create_default_config(self):
         super(IPControllerApp, self).create_default_config()
         self.default_config.Global.reuse_furls = False
         self.default_config.Global.import_statements = []
-        self.default_config.Global.profile = 'default'
         self.default_config.Global.log_dir_name = 'log'
         self.default_config.Global.security_dir_name = 'security'
         self.default_config.Global.log_to_file = False
-        # Resolve the default cluster_dir using the default profile
-        self.default_config.Global.cluster_dir = ''
-
-    def create_command_line_config(self):
-        """Create and return a command line config loader."""
-
-        return IPControllerAppCLConfigLoader(
-            description="Start an IPython controller",
-            version=release.version)
-
-    def find_config_file_name(self):
-        """Find the config file name for this application."""
-        self.find_cluster_dir()
-        self.create_cluster_dir()
-
-    def find_cluster_dir(self):
-        """This resolves into full paths, the various cluster directories.
-
-        This method must set ``self.cluster_dir`` to the full paths of 
-        the directory.
-        """
-        # Ignore self.command_line_config.Global.config_file
-        # Instead, first look for an explicit cluster_dir
-        try:
-            self.cluster_dir = self.command_line_config.Global.cluster_dir
-        except AttributeError:
-            self.cluster_dir = self.default_config.Global.cluster_dir
-        self.cluster_dir = os.path.expandvars(os.path.expanduser(self.cluster_dir))
-        if not self.cluster_dir:
-            # Then look for a profile
-            try:
-                self.profile = self.command_line_config.Global.profile
-            except AttributeError:
-                self.profile = self.default_config.Global.profile
-            cluster_dir_name = 'cluster_' + self.profile
-            try_this = os.path.join(os.getcwd(), cluster_dir_name)
-            if os.path.isdir(try_this):
-                self.cluster_dir = try_this
-            else:
-                self.cluster_dir = os.path.join(self.ipythondir, cluster_dir_name)
-        # These have to be set because they could be different from the one
-        # that we just computed.  Because command line has the highest
-        # priority, this will always end up in the master_config.
-        self.default_config.Global.cluster_dir = self.cluster_dir
-        self.command_line_config.Global.cluster_dir = self.cluster_dir
-
-    def create_cluster_dir(self):
-        """Make sure that the cluster, security and log dirs exist."""
-        if not os.path.isdir(self.cluster_dir):
-            os.makedirs(self.cluster_dir, mode=0777)
-
-    def find_config_file_paths(self):
-        """Set the search paths for resolving the config file."""
-        self.config_file_paths = (self.cluster_dir,)
 
     def pre_construct(self):
         # Now set the security_dir and log_dir and create them.  We use
         # the names an construct the absolute paths.
-        security_dir = os.path.join(self.master_config.Global.cluster_dir,
+        security_dir = os.path.join(self.master_config.Global.app_dir,
                                     self.master_config.Global.security_dir_name)
-        log_dir = os.path.join(self.master_config.Global.cluster_dir, 
+        log_dir = os.path.join(self.master_config.Global.app_dir, 
                                self.master_config.Global.log_dir_name)
         if not os.path.isdir(security_dir):
             os.mkdir(security_dir, 0700)
         else:
             os.chmod(security_dir, 0700)
         if not os.path.isdir(log_dir):
             os.mkdir(log_dir, 0777)
 
         self.security_dir = self.master_config.Global.security_dir = security_dir
         self.log_dir = self.master_config.Global.log_dir = log_dir
 
         # Now setup reuse_furls
-        if hasattr(self.master_config.Global.reuse_furls):
+        if hasattr(self.master_config.Global, 'reuse_furls'):
             self.master_config.FCClientServiceFactory.reuse_furls = \
                 self.master_config.Global.reuse_furls
             self.master_config.FCEngineServiceFactory.reuse_furls = \
                 self.master_config.Global.reuse_furls
 
     def construct(self):
         # I am a little hesitant to put these into InteractiveShell itself.
         # But that might be the place for them
         sys.path.insert(0, '')
 
         self.start_logging()
         self.import_statements()
 
         # Create the service hierarchy
         self.main_service = service.MultiService()
         # The controller service
         controller_service = controllerservice.ControllerService()
         controller_service.setServiceParent(self.main_service)
         # The client tub and all its refereceables
         csfactory = FCClientServiceFactory(self.master_config, controller_service)
         client_service = csfactory.create()
         client_service.setServiceParent(self.main_service)
         # The engine tub
         esfactory = FCEngineServiceFactory(self.master_config, controller_service)
         engine_service = esfactory.create()
         engine_service.setServiceParent(self.main_service)
 
     def start_logging(self):
         if self.master_config.Global.log_to_file:
             log_filename = self.name + '-' + str(os.getpid()) + '.log'
             logfile = os.path.join(self.log_dir, log_filename)
             open_log_file = open(logfile, 'w')
         else:
             open_log_file = sys.stdout
         log.startLogging(open_log_file)
 
     def import_statements(self):
         statements = self.master_config.Global.import_statements
         for s in statements:
             try:
                 exec s in globals(), locals()
             except:
                 log.msg("Error running import statement: %s" % s)
 
     def start_app(self):
         # Start the controller service and set things running
         self.main_service.startService()
         reactor.run()
 
-if __name__ == '__main__':
+
+def launch_new_instance():
+    """Create and run the IPython controller"""
     app = IPControllerApp()
     app.start()

IPython/kernel/scripts/ipcontroller

@@ -1,20 +1,18 b''
 #!/usr/bin/env python
 # encoding: utf-8
 
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  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
-#-------------------------------------------------------------------------------
+#-----------------------------------------------------------------------------
+
 
-if __name__ == '__main__':
-	from IPython.kernel.scripts import ipcontroller
-	ipcontroller.main()
+from IPython.kernel.ipcontrollerapp import launch_new_instance
 
+launch_new_instance()

setup.py

@@ -1,210 +1,210 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
 
 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/ipcluster.1.gz',
                   ['docs/man/ipcluster.1'],
                   'cd docs/man && gzip -9c ipcluster.1 > ipcluster.1.gz'),
 
                  ('docs/man/ipcontroller.1.gz',
                   ['docs/man/ipcontroller.1'],
                   'cd docs/man && gzip -9c ipcontroller.1 > ipcontroller.1.gz'),
 
                  ('docs/man/ipengine.1.gz',
                   ['docs/man/ipengine.1'],
                   'cd docs/man && gzip -9c ipengine.1 > ipengine.1.gz'),
 
                  ('docs/man/ipython.1.gz',
                   ['docs/man/ipython.1'],
                   'cd docs/man && gzip -9c ipython.1 > ipython.1.gz'),
 
                  ('docs/man/ipython-wx.1.gz',
                   ['docs/man/ipython-wx.1'],
                   'cd docs/man && gzip -9c ipython-wx.1 > ipython-wx.1.gz'),
 
                  ('docs/man/ipythonx.1.gz',
                   ['docs/man/ipythonx.1'],
                   'cd docs/man && gzip -9c ipythonx.1 > ipythonx.1.gz'),
 
                  ('docs/man/irunner.1.gz',
                   ['docs/man/irunner.1'],
                   'cd docs/man && gzip -9c irunner.1 > irunner.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/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.ipapp:launch_new_instance',
             'pycolor = IPython.utils.PyColorize:main',
-            'ipcontroller = IPython.kernel.scripts.ipcontroller:main',
+            'ipcontroller = IPython.kernel.ipcontrollerapp:launch_new_instance',
             '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:
     # 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)