Work on startup related things.

* Extension loading works.
* Execution of code from user config file works.
* Reworked logging in application.py and ipapp.py to use logging.
* Updated config files.
* Changed how display_banner is handled and implemented show_banner.
* Implemented safe_execfile_ipy to run .ipy files using runlines.

IPython/utils/syspathcontext.py

@@ -0,0 +1,67 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+Context managers for adding things to sys.path temporarily.
+
+Authors:
+
+* Brian Granger
+"""
+
+#-----------------------------------------------------------------------------
+#  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 sys
+
+class appended_to_syspath(object):
+    """A context for appending a directory to sys.path for a second."""
+
+    def __init__(self, dir):
+        self.dir = dir
+
+    def __enter__(self):
+        if self.dir not in sys.path:
+            sys.path.append(self.dir)
+            self.added = True
+        else:
+            self.added = False
+
+    def __exit__(self, type, value, traceback):
+        if self.added:
+            try:
+                sys.path.remove(self.dir)
+            except ValueError:
+                pass
+        # Returning False causes any exceptions to be re-raised.
+        return False
+
+class prepended_to_syspath(object):
+    """A context for prepending a directory to sys.path for a second."""
+
+    def __init__(self, dir):
+        self.dir = dir
+
+    def __enter__(self):
+        if self.dir not in sys.path:
+            sys.path.insert(0,self.dir)
+            self.added = True
+        else:
+            self.added = False
+
+    def __exit__(self, type, value, traceback):
+        if self.added:
+            try:
+                sys.path.remove(self.dir)
+            except ValueError:
+                pass
+        # Returning False causes any exceptions to be re-raised.
+        return False

IPython/config/profile/ipython_config_math.py

@@ -1,9 +1,8 b''
 from ipython_config import *
 
-EXECUTE.extend([
+Global.exec_lines.extend([
     'import cmath',
     'from math import *',
     'print "*** math functions available globally, cmath as a module"'
-
 ])
 

IPython/config/profile/ipython_config_numeric.py

@@ -1,6 +1,6 b''
 from ipython_config import *
 
-EXECUTE.extend([
+Global.exec_lines.extend([
     'import numpy',
     'import scipy',
     'import numpy as np',

IPython/config/profile/ipython_config_pylab.py

@@ -1,7 +1,8 b''
 from ipython_config_numeric import *
 
-EXECUTE.extend([
-
-
+Global.exec_lines.extend([
+    'import matplotlib',
+    'from matplotlib import pyplot as plt',
+    'from matplotlib.pyplot import *'
 ])
 

IPython/config/profile/ipython_config_pysh.py

@@ -1,15 +1,13 b''
 from ipython_config import *
 
-EXECUTE.insert(0, 'from IPython.extensions.InterpreterExec import *')
+InteractiveShell.prompt_in2 = '\C_LightGreen\u@\h\C_LightBlue[\C_LightCyan\Y1\C_LightBlue]\C_Green|\#> '
+InteractiveShell.prompt_in2 = '\C_Green|\C_LightGreen\D\C_Green> '
+InteractiveShell.prompt_out = '<\#> '
 
-PROMPT_IN1 = '\C_LightGreen\u@\h\C_LightBlue[\C_LightCyan\Y1\C_LightBlue]\C_Green|\#> '
-PROMPT_IN2 = '\C_Green|\C_LightGreen\D\C_Green> '
-PROMPT_OUT = '<\#> '
+InteractiveShell.prompts_pad_left = True
 
-PROMPTS_PAD_LEFT = True
+InteractiveShell.separate_in = ''
+InteractiveShell.separate_out = ''
+InteractiveShell.separate_out2 = ''
 
-SEPARATE_IN = 0
-SEPARATE_OUT = 0
-SEPARATE_OUT2 = 0
-
-MULTI_LINE_SPECIALS = True
  No newline at end of file
+PrefilterManager.multi_line_specials = True
  No newline at end of file

IPython/config/profile/ipython_config_sympy.py

@@ -1,9 +1,9 b''
 from ipython_config import *
 
-EXECUTE.extend([
-    'from __future__ import division'
-    'from sympy import *'
-    'x, y, z = symbols('xyz')'
-    'k, m, n = symbols('kmn', integer=True)'
-    'f, g, h = map(Function, 'fgh')'
+Global.exec_lines.extend([
+    "from __future__ import division"
+    "from sympy import *"
+    "x, y, z = symbols('xyz')"
+    "k, m, n = symbols('kmn', integer=True)"
+    "f, g, h = map(Function, 'fgh')"
 ])

IPython/core/alias.py

@@ -112,11 +112,9 b' class AliasManager(Component):'
 
     @auto_attr
     def shell(self):
-        shell = Component.get_instances(
+        return Component.get_instances(
             root=self.root,
-            klass='IPython.core.iplib.InteractiveShell'
-        )[0]
-        return shell
+            klass='IPython.core.iplib.InteractiveShell')[0]
 
     def __contains__(self, name):
         if name in self.alias_table:

IPython/core/application.py

@@ -23,6 +23,7 b' Notes'
 # Imports
 #-----------------------------------------------------------------------------
 
+import logging
 import os
 import sys
 import traceback
@@ -53,8 +54,8 b' class IPythonArgParseConfigLoader(ArgParseConfigLoader):'
             help='The string name of the ipython profile to be used.',
             default=NoConfigDefault,
             metavar='Global.profile')
-        self.parser.add_argument('-debug',dest="Global.debug",action='store_true',
-            help='Debug the application startup process.',
+        self.parser.add_argument('-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',dest='Global.config_file',type=str,
             help='Set the config file name to override default.',
@@ -72,10 +73,26 b' class Application(object):'
 
     config_file_name = 'ipython_config.py'
     name = 'ipython'
-    debug = False
 
     def __init__(self):
-        pass
+        self.init_logger()
+
+    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(logging.WARN)
+        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."""
@@ -103,6 +120,8 b' class Application(object):'
         """Create defaults that can't be set elsewhere."""
         self.default_config = Config()
         self.default_config.Global.ipythondir = get_ipython_dir()
+        self.log.debug('Default config loaded:')
+        self.log.debug(repr(self.default_config))
 
     def create_command_line_config(self):
         """Create and return a command line config loader."""
@@ -120,12 +139,14 b' class Application(object):'
 
         loader = self.create_command_line_config()
         self.command_line_config = loader.load_config()
+
         try:
-            self.debug = self.command_line_config.Global.debug
+            self.log_level = self.command_line_config.Global.log_level
         except AttributeError:
-            pass # use class default
-        self.log("Default config loaded:", self.default_config)
-        self.log("Command line config loaded:", self.command_line_config)
+            pass # Use existing value which is set in Application.init_logger.
+
+        self.log.debug("Command line config loaded:")
+        self.log.debug(repr(self.command_line_config))
 
     def post_load_command_line_config(self):
         """Do actions just after loading the command line config."""
@@ -148,7 +169,7 b' class Application(object):'
         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)
+        self.log.debug("IPYTHONDIR set to: %s" % self.ipythondir)
 
     def find_config_file_name(self):
         """Find the config file name for this application.
@@ -187,18 +208,28 b' class Application(object):'
         ``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:
-            self.log("Config file not found, skipping: %s" % \
-                     self.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()
         else:
-            self.log("Config file loaded: %s" % loader.full_filename,
-                     self.file_config)
+            self.log.debug("Config file loaded: <%s>" % loader.full_filename)
+            self.log.debug(repr(self.file_config))
+        # We need to keeep self.log_level updated.
+        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."""
@@ -211,7 +242,8 b' class Application(object):'
         config._merge(self.file_config)
         config._merge(self.command_line_config)
         self.master_config = config
-        self.log("Master config created:", self.master_config)
+        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."""
@@ -219,7 +251,7 b' class Application(object):'
 
     def construct(self):
         """Construct the main components that make up this app."""
-        self.log("Constructing components for application...")
+        self.log.debug("Constructing components for application")
 
     def post_construct(self):
         """Do actions after construct, but before starting the app."""
@@ -227,7 +259,7 b' class Application(object):'
 
     def start_app(self):
         """Actually start the app."""
-        self.log("Starting application...")
+        self.log.debug("Starting application")
 
     #-------------------------------------------------------------------------
     # Utility methods
@@ -235,11 +267,11 b' class Application(object):'
 
     def abort(self):
         """Abort the starting of the application."""
-        print "Aborting application: ", self.name
+        self.log.critical("Aborting application: %s" % self.name, exc_info=True)
         sys.exit(1)
 
     def exit(self):
-        print "Exiting application: ", self.name
+        self.log.critical("Aborting application: %s" % self.name)
         sys.exit(1)
 
     def attempt(self, func, action='abort'):
@@ -249,17 +281,7 b' class Application(object):'
             self.exit()
         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)        
  No newline at end of file
+      
  No newline at end of file

IPython/core/builtin_trap.py

@@ -46,11 +46,9 b' class BuiltinTrap(Component):'
 
     @auto_attr
     def shell(self):
-        shell = Component.get_instances(
+        return Component.get_instances(
             root=self.root,
-            klass='IPython.core.iplib.InteractiveShell'
-        )[0]
-        return shell
+            klass='IPython.core.iplib.InteractiveShell')[0]
 
     def __enter__(self):
         if self._nested_level == 0:

IPython/core/display_trap.py

@@ -48,11 +48,9 b' class DisplayTrap(Component):'
 
     @auto_attr
     def shell(self):
-        shell = Component.get_instances(
+        return Component.get_instances(
             root=self.root,
-            klass='IPython.core.iplib.InteractiveShell'
-        )[0]
-        return shell
+            klass='IPython.core.iplib.InteractiveShell')[0]
 
     def __enter__(self):
         if self._nested_level == 0:

IPython/core/embed.py

@@ -64,10 +64,13 b' class InteractiveShellEmbed(InteractiveShell):'
     exit_msg = Str('')
     embedded = CBool(True)
     embedded_active = CBool(True)
+    # Like the base class display_banner is not configurable, but here it
+    # is True by default.
+    display_banner = CBool(True)
 
     def __init__(self, parent=None, config=None, ipythondir=None, usage=None,
                  user_ns=None, user_global_ns=None,
-                 banner1=None, banner2=None,
+                 banner1=None, banner2=None, display_banner=None,
                  custom_exceptions=((),None), exit_msg=''):
 
         self.save_sys_ipcompleter()
@@ -75,7 +78,7 b' class InteractiveShellEmbed(InteractiveShell):'
         super(InteractiveShellEmbed,self).__init__(
             parent=parent, config=config, ipythondir=ipythondir, usage=usage, 
             user_ns=user_ns, user_global_ns=user_global_ns,
-            banner1=banner1, banner2=banner2,
+            banner1=banner1, banner2=banner2, display_banner=display_banner,
             custom_exceptions=custom_exceptions)
 
         self.exit_msg = exit_msg
@@ -148,23 +151,24 b' class InteractiveShellEmbed(InteractiveShell):'
         if self.has_readline:
             self.set_completer()
 
-        if self.banner and header:
-            format = '%s\n%s\n'
-        else:
-            format = '%s%s\n'
-        banner =  format % (self.banner,header)
+        # self.banner is auto computed
+        if header:
+            self.old_banner2 = self.banner2
+            self.banner2 = self.banner2 + '\n' + header + '\n'
 
         # Call the embedding code with a stack depth of 1 so it can skip over
         # our call and get the original caller's namespaces.
-        self.mainloop(banner, local_ns, global_ns,
-                            stack_depth=stack_depth)
+        self.mainloop(local_ns, global_ns, stack_depth=stack_depth)
+
+        self.banner2 = self.old_banner2
 
         if self.exit_msg is not None:
             print self.exit_msg
 
         self.restore_sys_ipcompleter()
 
-    def mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
+    def mainloop(self, local_ns=None, global_ns=None, stack_depth=0,
+                 display_banner=None):
         """Embeds IPython into a running python program.
 
         Input:
@@ -221,7 +225,7 b' class InteractiveShellEmbed(InteractiveShell):'
         self.set_completer_frame()
 
         with nested(self.builtin_trap, self.display_trap):
-            self.interact(header)
+            self.interact(display_banner=display_banner)
         
             # now, purge out the user namespace from anything we might have added
             # from the caller's local namespace
@@ -242,7 +246,7 b' _embedded_shell = None'
 
 
 def embed(header='', config=None, usage=None, banner1=None, banner2=None,
-          exit_msg=''):
+          display_banner=True, exit_msg=''):
     """Call this to embed IPython at the current point in your program.
 
     The first invocation of this will create an :class:`InteractiveShellEmbed`
@@ -264,9 +268,13 b" def embed(header='', config=None, usage=None, banner1=None, banner2=None,"
     """
     if config is None:
         config = load_default_config()
+        config.InteractiveShellEmbed = config.InteractiveShell
     global _embedded_shell
     if _embedded_shell is None:
-        _embedded_shell = InteractiveShellEmbed(config=config,
-        usage=usage, banner1=banner1, banner2=banner2, exit_msg=exit_msg)
+        _embedded_shell = InteractiveShellEmbed(
+            config=config, usage=usage, 
+            banner1=banner1, banner2=banner2, 
+            display_banner=display_banner, exit_msg=exit_msg
+        )
     _embedded_shell(header=header, stack_depth=2)
 

IPython/core/ipapp.py

@@ -23,6 +23,7 b' Notes'
 # Imports
 #-----------------------------------------------------------------------------
 
+import logging
 import os
 import sys
 import warnings
@@ -33,11 +34,12 b' from IPython.core.iplib import InteractiveShell'
 from IPython.config.loader import (
     NoConfigDefault, 
     Config,
+    ConfigError,
     PyFileConfigLoader
 )
 
 from IPython.utils.ipstruct import Struct
-from IPython.utils.genutils import get_ipython_dir
+from IPython.utils.genutils import filefind, get_ipython_dir
 
 #-----------------------------------------------------------------------------
 # Utilities and helpers
@@ -95,11 +97,11 b' cl_args = ('
         help='Turn off auto editing of files with syntax errors.')
     ),
     (('-banner',), dict(
-        action='store_true', dest='InteractiveShell.display_banner', default=NoConfigDefault,
+        action='store_true', dest='Global.display_banner', default=NoConfigDefault,
         help='Display a banner upon starting IPython.')
     ),
     (('-nobanner',), dict(
-        action='store_false', dest='InteractiveShell.display_banner', default=NoConfigDefault,
+        action='store_false', dest='Global.display_banner', default=NoConfigDefault,
         help="Don't display a banner upon starting IPython.")
     ),
     (('-c',), dict(
@@ -244,6 +246,11 b' cl_args = ('
         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')
+    ),
     # These are only here to get the proper deprecation warnings
     (('-pylab','-wthread','-qthread','-q4thread','-gthread'), dict(
         action='store_true', dest='Global.threaded_shell', default=NoConfigDefault,
@@ -263,6 +270,14 b' class IPythonApp(Application):'
     name = 'ipython'
     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
+        # 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
+
     def create_command_line_config(self):
         """Create and return a command line config loader."""
         return IPythonAppCLConfigLoader(
@@ -286,7 +301,12 b' class IPythonApp(Application):'
         super(IPythonApp, self).load_file_config()
 
     def post_load_file_config(self):
-        """Logic goes here."""
+        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
@@ -318,17 +338,90 b' class IPythonApp(Application):'
         # I am a little hesitant to put these into InteractiveShell itself.
         # But that might be the place for them
         sys.path.insert(0, '')
-        # add personal ipythondir to sys.path so that users can put things in
-        # there for customization
-        sys.path.append(os.path.abspath(self.ipythondir))
-        
+
         # 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."""
+        # 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 self.master_config.Global.display_banner:
+            self.shell.show_banner()
+
+        # Make sure there is a space below the banner.
+        if self.log_level <= logging.INFO: print
+
+        self._load_extensions()
+        self._run_exec_lines()
+        self._run_exec_files()
+
+    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 _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:
+                    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)
+        except:
+            self.log.warn("Unknown error in handling Global.exec_files:")
+            self.shell.showtraceback()
+
     def start_app(self):
+        self.log.debug("Starting IPython's mainloop...")
         self.shell.mainloop()
 
 

IPython/core/iplib.py

@@ -55,8 +55,9 b' from IPython.utils.ipstruct import Struct'
 from IPython.utils import PyColorize
 from IPython.utils.genutils import *
 from IPython.utils.genutils import get_ipython_dir
-from IPython.utils.strdispatch import StrDispatch
 from IPython.utils.platutils import toggle_set_term_title, set_term_title
+from IPython.utils.strdispatch import StrDispatch
+from IPython.utils.syspathcontext import prepended_to_syspath
 
 # from IPython.utils import growl
 # growl.start("IPython")
@@ -185,7 +186,6 b' class InteractiveShell(Component, Magic):'
     autoedit_syntax = CBool(False, config=True)
     autoindent = CBool(True, config=True)
     automagic = CBool(True, config=True)
-    display_banner = CBool(True, config=True)
     banner = Str('')
     banner1 = Str(default_banner, config=True)
     banner2 = Str('', config=True)
@@ -197,6 +197,12 b' class InteractiveShell(Component, Magic):'
     confirm_exit = CBool(True, config=True)
     debug = CBool(False, config=True)
     deep_reload = CBool(False, config=True)
+    # This display_banner only controls whether or not self.show_banner()
+    # is called when mainloop/interact are called.  The default is False
+    # because for the terminal based application, the banner behavior
+    # is controlled by Global.display_banner, which IPythonApp looks at
+    # to determine if *it* should call show_banner() by hand or not.
+    display_banner = CBool(False) # This isn't configurable!
     embedded = CBool(False)
     embedded_active = CBool(False)
     editor = Str(get_default_editor(), config=True)
@@ -262,7 +268,7 b' class InteractiveShell(Component, Magic):'
 
     def __init__(self, parent=None, config=None, ipythondir=None, usage=None,
                  user_ns=None, user_global_ns=None,
-                 banner1=None, banner2=None,
+                 banner1=None, banner2=None, display_banner=None,
                  custom_exceptions=((),None)):
 
         # This is where traitlets with a config_key argument are updated
@@ -274,7 +280,7 b' class InteractiveShell(Component, Magic):'
         self.init_instance_attrs()
         self.init_term_title()
         self.init_usage(usage)
-        self.init_banner(banner1, banner2)
+        self.init_banner(banner1, banner2, display_banner)
 
         # Create namespaces (user_ns, user_global_ns, etc.)
         self.init_create_namespaces(user_ns, user_global_ns)
@@ -331,6 +337,12 b' class InteractiveShell(Component, Magic):'
     def _ipythondir_changed(self, name, new):
         if not os.path.isdir(new):
             os.makedirs(new, mode = 0777)
+        if not os.path.isdir(self.ipython_extension_dir):
+            os.makedirs(self.ipython_extension_dir, mode = 0777)
+
+    @property
+    def ipython_extension_dir(self):
+        return os.path.join(self.ipythondir, 'extensions')
 
     @property
     def usable_screen_length(self):
@@ -429,22 +441,6 b' class InteractiveShell(Component, Magic):'
         else:
             self.usage = usage
 
-    def init_banner(self, banner1, banner2):
-        if self.c:  # regular python doesn't print the banner with -c
-            self.display_banner = False
-        if banner1 is not None:
-            self.banner1 = banner1
-        if banner2 is not None:
-            self.banner2 = banner2
-        self.compute_banner()
-
-    def compute_banner(self):
-        self.banner = self.banner1 + '\n'
-        if self.profile:
-            self.banner += '\nIPython profile: %s\n' % self.profile
-        if self.banner2:
-            self.banner += '\n' + self.banner2 + '\n'
-
     def init_encoding(self):
         # Get system encoding at startup time.  Certain terminals (like Emacs
         # under Win32 have it set to None, and we need to have a known valid
@@ -486,7 +482,7 b' class InteractiveShell(Component, Magic):'
     def init_logstart(self):
         if self.logplay:
             self.magic_logstart(self.logplay + ' append')
-        elif  self.logfile:
+        elif self.logfile:
             self.magic_logstart(self.logfile)
         elif self.logstart:
             self.magic_logstart()
@@ -532,6 +528,31 b' class InteractiveShell(Component, Magic):'
             warn("doctest module does not exist.")
 
     #-------------------------------------------------------------------------
+    # Things related to the banner
+    #-------------------------------------------------------------------------
+
+    def init_banner(self, banner1, banner2, display_banner):
+        if banner1 is not None:
+            self.banner1 = banner1
+        if banner2 is not None:
+            self.banner2 = banner2
+        if display_banner is not None:
+            self.display_banner = display_banner
+        self.compute_banner()
+
+    def show_banner(self, banner=None):
+        if banner is None:
+            banner = self.banner
+        self.write(banner)
+
+    def compute_banner(self):
+        self.banner = self.banner1 + '\n'
+        if self.profile:
+            self.banner += '\nIPython profile: %s\n' % self.profile
+        if self.banner2:
+            self.banner += '\n' + self.banner2 + '\n'
+
+    #-------------------------------------------------------------------------
     # Things related to injections into the sys module
     #-------------------------------------------------------------------------
 
@@ -1673,7 +1694,7 b' class InteractiveShell(Component, Magic):'
         with nested(self.builtin_trap,):
             return eval(expr, self.user_global_ns, self.user_ns)
 
-    def mainloop(self, banner=None):
+    def mainloop(self, display_banner=None):
         """Start the mainloop.
 
         If an optional banner argument is given, it will override the
@@ -1684,10 +1705,6 b' class InteractiveShell(Component, Magic):'
             if self.c:  # Emulate Python's -c option
                 self.exec_init_cmd()
 
-            if self.display_banner:
-                if banner is None:
-                    banner = self.banner
-
             # if you run stuff with -c <cmd>, raw hist is not updated
             # ensure that it's in sync
             if len(self.input_hist) != len (self.input_hist_raw):
@@ -1695,7 +1712,7 b' class InteractiveShell(Component, Magic):'
 
             while 1:
                 try:
-                    self.interact()
+                    self.interact(display_banner=display_banner)
                     #self.interact_with_readline()                
                     # XXX for testing of a readline-decoupled repl loop, call
                     # interact_with_readline above
@@ -1774,17 +1791,17 b' class InteractiveShell(Component, Magic):'
             line = raw_input_original().decode(self.stdin_encoding)
             self.interact_handle_input(line)
 
-    def interact(self, banner=None):
+    def interact(self, display_banner=None):
         """Closely emulate the interactive Python console."""
 
         # batch run -> do not interact        
         if self.exit_now:
             return
 
-        if self.display_banner:
-            if banner is None:
-                banner = self.banner
-            self.write(banner)
+        if display_banner is None:
+            display_banner = self.display_banner
+        if display_banner:
+            self.show_banner()
 
         more = 0
         
@@ -1856,128 +1873,45 b' class InteractiveShell(Component, Magic):'
         # We are off again...
         __builtin__.__dict__['__IPYTHON__active'] -= 1
 
-    def safe_execfile(self,fname,*where,**kw):
+    def safe_execfile(self, fname, *where, **kw):
         """A safe version of the builtin execfile().
 
-        This version will never throw an exception, and knows how to handle
-        ipython logs as well.
+        This version will never throw an exception, but instead print
+        helpful error messages to the screen.  This only works on pure
+        Python files with the .py extension.
 
-        :Parameters:
-          fname : string
-            Name of the file to be executed.
-            
-          where : tuple
+        Parameters
+        ----------
+        fname : string
+            The name of the file to be executed.
+        where : tuple
             One or two namespaces, passed to execfile() as (globals,locals).
             If only one is given, it is passed as both.
+        exit_ignore : bool (False)
+            If True, then don't print errors for non-zero exit statuses.
+        """
+        kw.setdefault('exit_ignore', False)
 
-        :Keywords:
-          islog : boolean (False)
-
-          quiet : boolean (True)
+        fname = os.path.abspath(os.path.expanduser(fname))
 
-          exit_ignore : boolean (False)
-          """
+        # Make sure we have a .py file
+        if not fname.endswith('.py'):
+            warn('File must end with .py to be run using execfile: <%s>' % fname)
 
-        def syspath_cleanup():
-            """Internal cleanup routine for sys.path."""
-            if add_dname:
-                try:
-                    sys.path.remove(dname)
-                except ValueError:
-                    # For some reason the user has already removed it, ignore.
-                    pass
-        
-        fname = os.path.expanduser(fname)
+        # Make sure we can open the file
+        try:
+            with open(fname) as thefile:
+                pass
+        except:
+            warn('Could not open file <%s> for safe execution.' % fname)
+            return
 
         # Find things also in current directory.  This is needed to mimic the
         # behavior of running a script from the system command line, where
         # Python inserts the script's directory into sys.path
-        dname = os.path.dirname(os.path.abspath(fname))
-        add_dname = False
-        if dname not in sys.path:
-            sys.path.insert(0,dname)
-            add_dname = True
-
-        try:
-            xfile = open(fname)
-        except:
-            print >> Term.cerr, \
-                  'Could not open file <%s> for safe execution.' % fname
-            syspath_cleanup()
-            return None
+        dname = os.path.dirname(fname)
 
-        kw.setdefault('islog',0)
-        kw.setdefault('quiet',1)
-        kw.setdefault('exit_ignore',0)
-        
-        first = xfile.readline()
-        loghead = str(self.loghead_tpl).split('\n',1)[0].strip()
-        xfile.close()
-        # line by line execution
-        if first.startswith(loghead) or kw['islog']:
-            print 'Loading log file <%s> one line at a time...' % fname
-            if kw['quiet']:
-                stdout_save = sys.stdout
-                sys.stdout = StringIO.StringIO()
-            try:
-                globs,locs = where[0:2]
-            except:
-                try:
-                    globs = locs = where[0]
-                except:
-                    globs = locs = globals()
-            badblocks = []
-
-            # we also need to identify indented blocks of code when replaying
-            # logs and put them together before passing them to an exec
-            # statement. This takes a bit of regexp and look-ahead work in the
-            # file. It's easiest if we swallow the whole thing in memory
-            # first, and manually walk through the lines list moving the
-            # counter ourselves.
-            indent_re = re.compile('\s+\S')
-            xfile = open(fname)
-            filelines = xfile.readlines()
-            xfile.close()
-            nlines = len(filelines)
-            lnum = 0
-            while lnum < nlines:
-                line = filelines[lnum]
-                lnum += 1
-                # don't re-insert logger status info into cache
-                if line.startswith('#log#'):
-                    continue
-                else:
-                    # build a block of code (maybe a single line) for execution
-                    block = line
-                    try:
-                        next = filelines[lnum] # lnum has already incremented
-                    except:
-                        next = None
-                    while next and indent_re.match(next):
-                        block += next
-                        lnum += 1
-                        try:
-                            next = filelines[lnum]
-                        except:
-                            next = None
-                    # now execute the block of one or more lines
-                    try:
-                        exec block in globs,locs
-                    except SystemExit:
-                        pass
-                    except:
-                        badblocks.append(block.rstrip())
-            if kw['quiet']:  # restore stdout
-                sys.stdout.close()
-                sys.stdout = stdout_save
-            print 'Finished replaying log file <%s>' % fname
-            if badblocks:
-                print >> sys.stderr, ('\nThe following lines/blocks in file '
-                                      '<%s> reported errors:' % fname)
-                    
-                for badline in badblocks:
-                    print >> sys.stderr, badline
-        else:  # regular file execution
+        with prepended_to_syspath(dname):
             try:
                 if sys.platform == 'win32' and sys.version_info < (2,5,1):
                     # Work around a bug in Python for Windows.  The bug was
@@ -1997,7 +1931,7 b' class InteractiveShell(Component, Magic):'
             except SyntaxError:
                 self.showsyntaxerror()
                 warn('Failure executing file: <%s>' % fname)
-            except SystemExit,status:
+            except SystemExit, status:
                 # Code that correctly sets the exit status flag to success (0)
                 # shouldn't be bothered with a traceback.  Note that a plain
                 # sys.exit() does NOT set the message to 0 (it's empty) so that
@@ -2005,13 +1939,8 b' class InteractiveShell(Component, Magic):'
                 # SystemExit exception changed between Python 2.4 and 2.5, so
                 # the checks must be done in a version-dependent way.
                 show = False
-
-                if sys.version_info[:2] > (2,5):
-                    if status.message!=0 and not kw['exit_ignore']:
-                        show = True
-                else:
-                    if status.code and not kw['exit_ignore']:
-                        show = True
+                if status.message!=0 and not kw['exit_ignore']:
+                    show = True
                 if show:
                     self.showtraceback()
                     warn('Failure executing file: <%s>' % fname)
@@ -2019,46 +1948,82 b' class InteractiveShell(Component, Magic):'
                 self.showtraceback()
                 warn('Failure executing file: <%s>' % fname)
 
-        syspath_cleanup()
+    def safe_execfile_ipy(self, fname):
+        """Like safe_execfile, but for .ipy files with IPython syntax.
+
+        Parameters
+        ----------
+        fname : str
+            The name of the file to execute.  The filename must have a
+            .ipy extension.
+        """
+        fname = os.path.abspath(os.path.expanduser(fname))
+
+        # Make sure we have a .py file
+        if not fname.endswith('.ipy'):
+            warn('File must end with .py to be run using execfile: <%s>' % fname)
+
+        # Make sure we can open the file
+        try:
+            with open(fname) as thefile:
+                pass
+        except:
+            warn('Could not open file <%s> for safe execution.' % fname)
+            return
+
+        # Find things also in current directory.  This is needed to mimic the
+        # behavior of running a script from the system command line, where
+        # Python inserts the script's directory into sys.path
+        dname = os.path.dirname(fname)
+
+        with prepended_to_syspath(dname):
+            try:
+                with open(fname) as thefile:
+                    script = thefile.read()
+                    # self.runlines currently captures all exceptions
+                    # raise in user code.  It would be nice if there were
+                    # versions of runlines, execfile that did raise, so
+                    # we could catch the errors.
+                    self.runlines(script, clean=True)
+            except:
+                self.showtraceback()
+                warn('Unknown failure executing file: <%s>' % fname)
+                
+    def _is_secondary_block_start(self, s):
+        if not s.endswith(':'):
+            return False
+        if (s.startswith('elif') or 
+            s.startswith('else') or 
+            s.startswith('except') or
+            s.startswith('finally')):
+            return True
 
     def cleanup_ipy_script(self, script):
         """Make a script safe for self.runlines()
 
-        Notes
-        -----
-        This was copied over from the old ipapi and probably can be done
-        away with once we move to block based interpreter.
-        
-        - Removes empty lines Suffixes all indented blocks that end with
-        - unindented lines with empty lines
+        Currently, IPython is lines based, with blocks being detected by
+        empty lines.  This is a problem for block based scripts that may
+        not have empty lines after blocks.  This script adds those empty
+        lines to make scripts safe for running in the current line based
+        IPython.
         """
-        
         res = []
         lines = script.splitlines()
-
         level = 0
+
         for l in lines:
             lstripped = l.lstrip()
             stripped = l.strip()                
             if not stripped:
                 continue
-            newlevel = len(l) - len(lstripped)
-            def is_secondary_block_start(s):
-                if not s.endswith(':'):
-                    return False
-                if (s.startswith('elif') or 
-                    s.startswith('else') or 
-                    s.startswith('except') or
-                    s.startswith('finally')):
-                    return True
-                    
+            newlevel = len(l) - len(lstripped)                    
             if level > 0 and newlevel == 0 and \
-                   not is_secondary_block_start(stripped): 
+                   not self._is_secondary_block_start(stripped): 
                 # add empty line
                 res.append('')
-                
             res.append(l)
             level = newlevel
+
         return '\n'.join(res) + '\n'
 
     def runlines(self, lines, clean=False):
@@ -2091,7 +2056,8 b' class InteractiveShell(Component, Magic):'
                 if line or more:
                     # push to raw history, so hist line numbers stay in sync
                     self.input_hist_raw.append("# " + line + "\n")
-                    more = self.push_line(self.prefilter_manager.prefilter_lines(line,more))
+                    prefiltered = self.prefilter_manager.prefilter_lines(line,more)
+                    more = self.push_line(prefiltered)
                     # IPython's runsource returns None if there was an error
                     # compiling the code.  This allows us to stop processing right
                     # away, so the user gets the error message at the right place.
@@ -2304,7 +2270,7 b' class InteractiveShell(Component, Magic):'
         if line.strip():
             if continue_prompt:
                 self.input_hist_raw[-1] += '%s\n' % line
-                if self.has_readline: # and some config option is set?
+                if self.has_readline and self.readline_use:
                     try:
                         histlen = self.readline.get_current_history_length()
                         if histlen > 1:
@@ -2349,37 +2315,56 b' class InteractiveShell(Component, Magic):'
     #     if batchrun and not self.interactive:
     #         self.ask_exit()            
 
-    # def load(self, mod):
-    #     """ Load an extension.
-    #     
-    #     Some modules should (or must) be 'load()':ed, rather than just imported.
-    #     
-    #     Loading will do:
-    #     
-    #     - run init_ipython(ip)
-    #     - run ipython_firstrun(ip)
-    #     """
-    # 
-    #     if mod in self.extensions:
-    #         # just to make sure we don't init it twice
-    #         # note that if you 'load' a module that has already been
-    #         # imported, init_ipython gets run anyway
-    #         
-    #         return self.extensions[mod]
-    #     __import__(mod)
-    #     m = sys.modules[mod]
-    #     if hasattr(m,'init_ipython'):
-    #         m.init_ipython(self)
-    #         
-    #     if hasattr(m,'ipython_firstrun'):
-    #         already_loaded = self.db.get('firstrun_done', set())
-    #         if mod not in already_loaded:
-    #             m.ipython_firstrun(self)
-    #             already_loaded.add(mod)
-    #             self.db['firstrun_done'] = already_loaded
-    #         
-    #     self.extensions[mod] = m
-    #     return m
+    #-------------------------------------------------------------------------
+    # IPython extensions
+    #-------------------------------------------------------------------------
+
+    def load_extension(self, module_str):
+        """Load an IPython extension.
+
+        An IPython extension is an importable Python module that has
+        a function with the signature::
+
+            def load_in_ipython(ipython):
+                # Do things with ipython
+
+        This function is called after your extension is imported and the 
+        currently active :class:`InteractiveShell` instance is passed as
+        the only argument.  You can do anything you want with IPython at
+        that point, including defining new magic and aliases, adding new
+        components, etc.
+
+        You can put your extension modules anywhere you want, as long as
+        they can be imported by Python's standard import mechanism.  However,
+        to make it easy to write extensions, you can also put your extensions
+        in ``os.path.join(self.ipythondir, 'extensions')``.  This directory
+        is added to ``sys.path`` automatically.
+        """
+        from IPython.utils.syspathcontext import prepended_to_syspath
+
+        if module_str in sys.modules:
+            return
+
+        with prepended_to_syspath(self.ipython_extension_dir):
+            __import__(module_str)
+            mod = sys.modules[module_str]
+            self._call_load_in_ipython(mod)
+
+    def reload_extension(self, module_str):
+        """Reload an IPython extension by doing reload."""
+        from IPython.utils.syspathcontext import prepended_to_syspath
+
+        with prepended_to_syspath(self.ipython_extension_dir):
+            if module_str in sys.modules:
+                mod = sys.modules[module_str]
+                reload(mod)
+                self._call_load_in_ipython(mod)
+            else:
+                self.load_extension(self, module_str)
+
+    def _call_load_in_ipython(self, mod):
+        if hasattr(mod, 'load_in_ipython'):
+            mod.load_in_ipython(self)
 
     #-------------------------------------------------------------------------
     # Things related to the prefilter

IPython/core/magic.py

@@ -1573,7 +1573,7 b' Currently the magic system has the following functions:\\n"""'
             return
 
         if filename.lower().endswith('.ipy'):
-            self.runlines(open(filename).read(), clean=True)
+            self.safe_execfile_ipy(filename)
             return
         
         # Control the response to exit() calls made by the script being run
@@ -1743,25 +1743,6 b' Currently the magic system has the following functions:\\n"""'
                 
         return stats
 
-    def magic_runlog(self, parameter_s =''):
-        """Run files as logs.
-
-        Usage:\\
-          %runlog file1 file2 ...
-
-        Run the named files (treating them as log files) in sequence inside
-        the interpreter, and return to the prompt.  This is much slower than
-        %run because each line is executed in a try/except block, but it
-        allows running files with syntax errors in them.
-
-        Normally IPython will guess when a file is one of its own logfiles, so
-        you can typically use %run even for logs. This shorthand allows you to
-        force any file to be treated as a log file."""
-
-        for f in parameter_s.split():
-            self.shell.safe_execfile(f,self.shell.user_ns,
-                                     self.shell.user_ns,islog=1)
-
     @testdec.skip_doctest
     def magic_timeit(self, parameter_s =''):
         """Time execution of a Python statement or expression

IPython/core/page.py

@@ -127,12 +127,14 b' def page(strng,start=0,screen_lines=0,pager_cmd = None):'
 
     # auto-determine screen size
     if screen_lines <= 0:
-        if TERM=='xterm':
+        if TERM=='xterm' or TERM=='xterm-color':
             use_curses = USE_CURSES
         else:
             # curses causes problems on many terminals other than xterm.
             use_curses = False
         if use_curses:
+            import termios
+            import curses
             # There is a bug in curses, where *sometimes* it fails to properly
             # initialize, and then after the endwin() call is made, the
             # terminal is left in an unusable state.  Rather than trying to

IPython/core/prefilter.py

@@ -32,6 +32,7 b' from IPython.core.alias import AliasManager'
 from IPython.core.autocall import IPyAutocall
 from IPython.core.component import Component
 from IPython.core.splitinput import split_user_input
+from IPython.core.page import page
 
 from IPython.utils.traitlets import List, Int, Any, Str, CBool
 from IPython.utils.genutils import make_quoted_expr
@@ -183,11 +184,9 b' class PrefilterManager(Component):'
 
     @auto_attr
     def shell(self):
-        shell = Component.get_instances(
+        return Component.get_instances(
             root=self.root,
-            klass='IPython.core.iplib.InteractiveShell'
-        )[0]
-        return shell
+            klass='IPython.core.iplib.InteractiveShell')[0]
 
     def init_checkers(self):
         self._checkers = []
@@ -319,11 +318,9 b' class PrefilterChecker(Component):'
 
     @auto_attr
     def shell(self):
-        shell = Component.get_instances(
+        return Component.get_instances(
             root=self.root,
-            klass='IPython.core.iplib.InteractiveShell'
-        )[0]
-        return shell
+            klass='IPython.core.iplib.InteractiveShell')[0]
 
     @auto_attr
     def prefilter_manager(self):
@@ -523,11 +520,9 b' class PrefilterHandler(Component):'
 
     @auto_attr
     def shell(self):
-        shell = Component.get_instances(
+        return Component.get_instances(
             root=self.root,
-            klass='IPython.core.iplib.InteractiveShell'
-        )[0]
-        return shell
+            klass='IPython.core.iplib.InteractiveShell')[0]
 
     @auto_attr
     def prefilter_manager(self):