IPython/core/application.py

#!/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 os
import sys
import traceback

from copy import deepcopy
from IPython.utils.ipstruct import Struct
from IPython.utils.genutils import get_ipython_dir, filefind
from IPython.config.loader import (
    IPythonArgParseConfigLoader,
    PyFileConfigLoader
)

#-----------------------------------------------------------------------------
# Classes and functions
#-----------------------------------------------------------------------------


class ApplicationError(Exception):
    pass


class Application(object):
    """Load a config, construct an app and run it.
    """

    config_file_name = 'ipython_config.py'
    name = 'ipython'
    debug = False

    def __init__(self):
        pass

    def start(self):
        """Start the application."""
        self.attempt(self.create_default_config)
        self.attempt(self.pre_load_command_line_config)
        self.attempt(self.load_command_line_config, action='abort')
        self.attempt(self.post_load_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.attempt(self.post_load_file_config)
        self.attempt(self.merge_configs)
        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."""
        self.default_config = Struct()
        self.default_config.IPYTHONDIR = get_ipython_dir()

    def create_command_line_config(self):
        """Create and return a command line config loader."""
        return IPythonArgParseConfigLoader(description=self.name)

    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.

        This method also sets ``self.debug``.
        """

        loader = self.create_command_line_config()
        self.command_line_config = loader.load_config()
        try:
            self.debug = self.command_line_config.DEBUG
        except AttributeError:
            pass # use class default
        self.log("Default config loaded:", self.default_config)
        self.log("Command line config loaded:", self.command_line_config)

    def post_load_command_line_config(self):
        """Do actions just after loading the command line config."""
        pass

    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.IPYTHONDIR
        except AttributeError:
            self.ipythondir = self.default_config.IPYTHONDIR
        sys.path.append(os.path.abspath(self.ipythondir))
        if not os.path.isdir(self.ipythondir):
            os.makedirs(self.ipythondir, mode = 0777)
        self.log("IPYTHONDIR set to: %s" % self.ipythondir)

    def find_config_file_name(self):
        """Find the config file name for this application.

        If a profile has been set at the command line, this will resolve
        it.  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.
        """

        try:
            self.config_file_name = self.command_line_config.CONFIG_FILE
        except AttributeError:
            pass

        try:
            self.profile_name = self.command_line_config.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."""
        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.
        """
        loader = PyFileConfigLoader(self.config_file_name, 
                                    self.config_file_paths)
        try:
            self.file_config = loader.load_config()
            self.file_config.CONFIG_FILE = loader.full_filename
        except IOError:
            self.log("Config file not found, skipping: %s" % \
                     self.config_file_name)
            self.file_config = Struct()
        else:
            self.log("Config file loaded: %s" % loader.full_filename,
                     self.file_config)

    def post_load_file_config(self):
        """Do actions after the config file is loaded."""
        pass

    def merge_configs(self):
        """Merge the default, command line and file config objects."""
        config = Struct()
        config.update(self.default_config)
        config.update(self.file_config)
        config.update(self.command_line_config)
        self.master_config = config
        self.log("Master config created:", 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("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("Starting application...")

    #-------------------------------------------------------------------------
    # Utility methods
    #-------------------------------------------------------------------------

    def abort(self):
        """Abort the starting of the application."""
        print "Aborting application: ", self.name
        sys.exit(1)

    def exit(self):
        print "Exiting application: ", self.name
        sys.exit(1)

    def attempt(self, func, action='abort'):
        try:
            func()
        except:
            if action == 'abort':
                self.print_traceback()
                self.abort()
            elif action == 'exit':
                self.exit()

    def print_traceback(self):
        print "Error in appliction startup: ", self.name
        print
        traceback.print_exc()

    def log(self, *args):
        if self.debug:
            for arg in args:
                print "[%s] %s" % (self.name, arg)