Major restructuring of magics, breaking them up into separate classes.

This is the first step to get the new magic architecture in place,
with a new base class for magic functions.

At this point IPython does *not* run, but the changes are extensive
enough to warrant intermediate non-working commits.

IPython/core/interactiveshell.py

@@ -380,6 +380,7 b' class InteractiveShell(SingletonConfigurable):'
     plugin_manager = Instance('IPython.core.plugin.PluginManager')
     payload_manager = Instance('IPython.core.payload.PayloadManager')
     history_manager = Instance('IPython.core.history.HistoryManager')
+    magics_manager = Instance('IPython.core.magic.MagicsManager')
 
     profile_dir = Instance('IPython.core.application.ProfileDir')
     @property

IPython/core/magic.py

@@ -4,8 +4,8 b''
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2001 Janko Hauser <[e-mail]> and
-#  Copyright (C) 2001-2007 Fernando Perez <[e-mail]>
-#  Copyright (C) 2008-2011  The IPython Development Team
+#  Copyright (C) 2001 Fernando Perez <[e-mail]>
+#  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.
@@ -18,14 +18,16 b''
 import __builtin__ as builtin_mod
 import __future__
 import bdb
+import gc
+import imp
 import inspect
 import io
 import json
 import os
-import sys
 import re
+import shutil
+import sys
 import time
-import gc
 from StringIO import StringIO
 from getopt import getopt,GetoptError
 from pprint import pformat
@@ -42,36 +44,48 b' except ImportError:'
     except ImportError:
         profile = pstats = None
 
+import IPython
+from IPython.config.application import Application
+from IPython.config.configurable import Configurable
 from IPython.core import debugger, oinspect
+from IPython.core import magic_arguments, page
+from IPython.core.error import StdinNotImplementedError
 from IPython.core.error import TryNext
 from IPython.core.error import UsageError
-from IPython.core.error import StdinNotImplementedError
+from IPython.core.fakemodule import FakeModule
 from IPython.core.macro import Macro
-from IPython.core import magic_arguments, page
 from IPython.core.prefilter import ESC_MAGIC
+from IPython.core.profiledir import ProfileDir
 from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils import openpy
 from IPython.utils import py3compat
 from IPython.utils.encoding import DEFAULT_ENCODING
 from IPython.utils.io import file_read, nlprint
+from IPython.utils.ipstruct import Struct
 from IPython.utils.module_paths import find_mod
 from IPython.utils.path import get_py_filename, unquote_filename
 from IPython.utils.process import arg_split, abbrev_cwd
 from IPython.utils.terminal import set_term_title
 from IPython.utils.text import format_screen
 from IPython.utils.timing import clock, clock2
+from IPython.utils.traitlets import Bool, Dict, Instance, Integer, List, Unicode
 from IPython.utils.warn import warn, error
-from IPython.utils.ipstruct import Struct
-from IPython.config.application import Application
 
 #-----------------------------------------------------------------------------
-# Utility functions
+# Utility classes and functions
 #-----------------------------------------------------------------------------
 
+class Bunch: pass
+
+
+# Used for exception handling in magic_edit
+class MacroToEdit(ValueError): pass
+
+
 def on_off(tag):
     """Return an ON/OFF string for a 1/0 input. Simple utility function."""
     return ['OFF','ON'][tag]
 
-class Bunch: pass
 
 def compress_dhist(dh):
     head, tail = dh[:-10], dh[-10:]
@@ -86,72 +100,28 b' def compress_dhist(dh):'
 
     return newhead + tail
 
+
 def needs_local_scope(func):
     """Decorator to mark magic functions which need to local scope to run."""
     func.needs_local_scope = True
     return func
 
-    
-# Used for exception handling in magic_edit
-class MacroToEdit(ValueError): pass
-
 #***************************************************************************
-# Main class implementing Magic functionality
-
-# XXX - for some odd reason, if Magic is made a new-style class, we get errors
-# on construction of the main InteractiveShell object.  Something odd is going
-# on with super() calls, Configurable and the MRO... For now leave it as-is, but
-# eventually this needs to be clarified.
-# BG: This is because InteractiveShell inherits from this, but is itself a
-# Configurable. This messes up the MRO in some way. The fix is that we need to
-# make Magic a configurable that InteractiveShell does not subclass.
-
-class Magic(object):
-    """Magic functions for InteractiveShell.
-
-    Shell functions which can be reached as %function_name. All magic
-    functions should accept a string, which they can parse for their own
-    needs. This can make some functions easier to type, eg `%cd ../`
-    vs. `%cd("../")`
-
-    ALL definitions MUST begin with the prefix magic_. The user won't need it
-    at the command line, but it is is needed in the definition. """
-
-    # class globals
-    auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
-                   'Automagic is ON, % prefix NOT needed for magic functions.']
-
-
-    configurables = None
-
-    default_runner = None
-    #......................................................................
-    # some utility functions
-
-    def __init__(self, shell):
 
-        self.options_table = {}
-        if profile is None:
-            self.magic_prun = self.profile_missing_notice
-        self.shell = shell
-        if self.configurables is None:
-            self.configurables = []
+class MagicManager(Configurable):
+    """Object that handles all magic-related functionality for IPython.
+    """
+    # An instance of the IPython shell we are attached to
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
 
-        # namespace for holding state we may need
-        self._magic_state = Bunch()
+    auto_status = Enum([
+        'Automagic is OFF, % prefix IS needed for magic functions.',
+        'Automagic is ON, % prefix NOT needed for magic functions.'])
 
-    def profile_missing_notice(self, *args, **kwargs):
-        error("""\
-The profile module could not be found. It has been removed from the standard
-python packages because of its non-free license. To use profiling, install the
-python-profiler package from non-free.""")
+    def __init__(self, shell=None, config=None, **traits):
 
-    def default_option(self,fn,optstr):
-        """Make an entry in the options_table for fn, with value optstr"""
+        super(MagicManager, self).__init__(shell=shell, config=config, **traits)
 
-        if fn not in self.lsmagic():
-            error("%s is not a magic function" % fn)
-        self.options_table[fn] = optstr
 
     def lsmagic(self):
         """Return a list of currently available magic functions.
@@ -179,6 +149,30 b' python-profiler package from non-free.""")'
         out.sort()
         return out
 
+
+class MagicFunctions(object):
+    """Base class for implementing magic functions.
+
+    Shell functions which can be reached as %function_name. All magic
+    functions should accept a string, which they can parse for their own
+    needs. This can make some functions easier to type, eg `%cd ../`
+    vs. `%cd("../")`
+    """
+
+    options_table = Dict(config=True,
+        help = """Dict holding all command-line options for each magic.
+        """)
+
+    class __metaclass__(type):
+        def __new__(cls, name, bases, dct):
+            cls.registered = False
+            return type.__new__(cls, name, bases, dct)
+
+    def __init__(self, shell):
+        if not(self.__class__.registered):
+            raise ValueError('unregistered Magics')
+        self.shell = shell
+
     def arg_err(self,func):
         """Print docstring if incorrect arguments were passed"""
         print 'Error in arguments:'
@@ -280,10 +274,20 b' python-profiler package from non-free.""")'
 
         return opts,args
 
-    #......................................................................
-    # And now the actual magic functions
+    def default_option(self,fn,optstr):
+        """Make an entry in the options_table for fn, with value optstr"""
+
+        if fn not in self.lsmagic():
+            error("%s is not a magic function" % fn)
+        self.options_table[fn] = optstr
+
+
+class BasicMagics(MagicFunctions):
+    """Magics that provide central IPython functionality.
+
+    These are various magics that don't fit into specific categories but that
+    are all part of the base 'IPython experience'."""
 
-    # Functions for IPython shell work (vars,funcs, config, etc)
     def magic_lsmagic(self, parameter_s = ''):
         """List currently available magic functions."""
         mesc = ESC_MAGIC
@@ -383,99 +387,6 b' Currently the magic system has the following functions:\\n"""'
                                      Magic.auto_status[self.shell.automagic] ) )
         page.page(outmsg)
 
-    def magic_automagic(self, parameter_s = ''):
-        """Make magic functions callable without having to type the initial %.
-
-        Without argumentsl toggles on/off (when off, you must call it as
-        %automagic, of course).  With arguments it sets the value, and you can
-        use any of (case insensitive):
-
-         - on,1,True: to activate
-
-         - off,0,False: to deactivate.
-
-        Note that magic functions have lowest priority, so if there's a
-        variable whose name collides with that of a magic fn, automagic won't
-        work for that function (you get the variable instead). However, if you
-        delete the variable (del var), the previously shadowed magic function
-        becomes visible to automagic again."""
-
-        arg = parameter_s.lower()
-        if parameter_s in ('on','1','true'):
-            self.shell.automagic = True
-        elif parameter_s in ('off','0','false'):
-            self.shell.automagic = False
-        else:
-            self.shell.automagic = not self.shell.automagic
-        print '\n' + Magic.auto_status[self.shell.automagic]
-
-    @skip_doctest
-    def magic_autocall(self, parameter_s = ''):
-        """Make functions callable without having to type parentheses.
-
-        Usage:
-
-           %autocall [mode]
-
-        The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the
-        value is toggled on and off (remembering the previous state).
-
-        In more detail, these values mean:
-
-        0 -> fully disabled
-
-        1 -> active, but do not apply if there are no arguments on the line.
-
-        In this mode, you get::
-
-          In [1]: callable
-          Out[1]: <built-in function callable>
-
-          In [2]: callable 'hello'
-          ------> callable('hello')
-          Out[2]: False
-
-        2 -> Active always.  Even if no arguments are present, the callable
-        object is called::
-
-          In [2]: float
-          ------> float()
-          Out[2]: 0.0
-
-        Note that even with autocall off, you can still use '/' at the start of
-        a line to treat the first argument on the command line as a function
-        and add parentheses to it::
-
-          In [8]: /str 43
-          ------> str(43)
-          Out[8]: '43'
-
-        # all-random (note for auto-testing)
-        """
-
-        if parameter_s:
-            arg = int(parameter_s)
-        else:
-            arg = 'toggle'
-
-        if not arg in (0,1,2,'toggle'):
-            error('Valid modes: (0->Off, 1->Smart, 2->Full')
-            return
-
-        if arg in (0,1,2):
-            self.shell.autocall = arg
-        else: # toggle
-            if self.shell.autocall:
-                self._magic_state.autocall_save = self.shell.autocall
-                self.shell.autocall = 0
-            else:
-                try:
-                    self.shell.autocall = self._magic_state.autocall_save
-                except AttributeError:
-                    self.shell.autocall = self._magic_state.autocall_save = 1
-
-        print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
-
 
     def magic_page(self, parameter_s=''):
         """Pretty print the object and display it through a pager.
@@ -510,2214 +421,2572 b' Currently the magic system has the following functions:\\n"""'
         else:
             error("profile is an application-level value, but you don't appear to be in an IPython application")
 
-    def magic_pinfo(self, parameter_s='', namespaces=None):
-        """Provide detailed information about an object.
-
-        '%pinfo object' is just a synonym for object? or ?object."""
-
-        #print 'pinfo par: <%s>' % parameter_s  # dbg
-
-
-        # detail_level: 0 -> obj? , 1 -> obj??
-        detail_level = 0
-        # We need to detect if we got called as 'pinfo pinfo foo', which can
-        # happen if the user types 'pinfo foo?' at the cmd line.
-        pinfo,qmark1,oname,qmark2 = \
-               re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
-        if pinfo or qmark1 or qmark2:
-            detail_level = 1
-        if "*" in oname:
-            self.magic_psearch(oname)
-        else:
-            self.shell._inspect('pinfo', oname, detail_level=detail_level,
-                                namespaces=namespaces)
-
-    def magic_pinfo2(self, parameter_s='', namespaces=None):
-        """Provide extra detailed information about an object.
+    def magic_pprint(self, parameter_s=''):
+        """Toggle pretty printing on/off."""
+        ptformatter = self.shell.display_formatter.formatters['text/plain']
+        ptformatter.pprint = bool(1 - ptformatter.pprint)
+        print 'Pretty printing has been turned', \
+              ['OFF','ON'][ptformatter.pprint]
 
-        '%pinfo2 object' is just a synonym for object?? or ??object."""
-        self.shell._inspect('pinfo', parameter_s, detail_level=1,
-                            namespaces=namespaces)
+    def magic_colors(self,parameter_s = ''):
+        """Switch color scheme for prompts, info system and exception handlers.
 
-    @skip_doctest
-    def magic_pdef(self, parameter_s='', namespaces=None):
-        """Print the definition header for any callable object.
+        Currently implemented schemes: NoColor, Linux, LightBG.
 
-        If the object is a class, print the constructor information.
+        Color scheme names are not case-sensitive.
 
         Examples
         --------
-        ::
+        To get a plain black and white terminal::
 
-          In [3]: %pdef urllib.urlopen
-          urllib.urlopen(url, data=None, proxies=None)
+          %colors nocolor
         """
-        self._inspect('pdef',parameter_s, namespaces)
 
-    def magic_pdoc(self, parameter_s='', namespaces=None):
-        """Print the docstring for an object.
+        def color_switch_err(name):
+            warn('Error changing %s color schemes.\n%s' %
+                 (name,sys.exc_info()[1]))
 
-        If the given object is a class, it will print both the class and the
-        constructor docstrings."""
-        self._inspect('pdoc',parameter_s, namespaces)
 
-    def magic_psource(self, parameter_s='', namespaces=None):
-        """Print (or run through pager) the source code for an object."""
-        self._inspect('psource',parameter_s, namespaces)
+        new_scheme = parameter_s.strip()
+        if not new_scheme:
+            raise UsageError(
+                "%colors: you must specify a color scheme. See '%colors?'")
+            return
+        # local shortcut
+        shell = self.shell
 
-    def magic_pfile(self, parameter_s=''):
-        """Print (or run through pager) the file where an object is defined.
+        import IPython.utils.rlineimpl as readline
 
-        The file opens at the line where the object definition begins. IPython
-        will honor the environment variable PAGER if set, and otherwise will
-        do its best to print the file in a convenient form.
+        if not shell.colors_force and \
+                not readline.have_readline and sys.platform == "win32":
+            msg = """\
+Proper color support under MS Windows requires the pyreadline library.
+You can find it at:
+http://ipython.org/pyreadline.html
+Gary's readline needs the ctypes module, from:
+http://starship.python.net/crew/theller/ctypes
+(Note that ctypes is already part of Python versions 2.5 and newer).
 
-        If the given argument is not an object currently defined, IPython will
-        try to interpret it as a filename (automatically adding a .py extension
-        if needed). You can thus use %pfile as a syntax highlighting code
-        viewer."""
-
-        # first interpret argument as an object name
-        out = self._inspect('pfile',parameter_s)
-        # if not, try the input as a filename
-        if out == 'not found':
-            try:
-                filename = get_py_filename(parameter_s)
-            except IOError,msg:
-                print msg
-                return
-            page.page(self.shell.inspector.format(open(filename).read()))
-
-    def magic_psearch(self, parameter_s=''):
-        """Search for object in namespaces by wildcard.
+Defaulting color scheme to 'NoColor'"""
+            new_scheme = 'NoColor'
+            warn(msg)
 
-        %psearch [options] PATTERN [OBJECT TYPE]
+        # readline option is 0
+        if not shell.colors_force and not shell.has_readline:
+            new_scheme = 'NoColor'
 
-        Note: ? can be used as a synonym for %psearch, at the beginning or at
-        the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the
-        rest of the command line must be unchanged (options come first), so
-        for example the following forms are equivalent
+        # Set prompt colors
+        try:
+            shell.prompt_manager.color_scheme = new_scheme
+        except:
+            color_switch_err('prompt')
+        else:
+            shell.colors = \
+                   shell.prompt_manager.color_scheme_table.active_scheme_name
+        # Set exception colors
+        try:
+            shell.InteractiveTB.set_colors(scheme = new_scheme)
+            shell.SyntaxTB.set_colors(scheme = new_scheme)
+        except:
+            color_switch_err('exception')
 
-        %psearch -i a* function
-        -i a* function?
-        ?-i a* function
+        # Set info (for 'object?') colors
+        if shell.color_info:
+            try:
+                shell.inspector.set_active_scheme(new_scheme)
+            except:
+                color_switch_err('object inspector')
+        else:
+            shell.inspector.set_active_scheme('NoColor')
 
-        Arguments:
+    def magic_xmode(self,parameter_s = ''):
+        """Switch modes for the exception handlers.
 
-          PATTERN
+        Valid modes: Plain, Context and Verbose.
 
-          where PATTERN is a string containing * as a wildcard similar to its
-          use in a shell.  The pattern is matched in all namespaces on the
-          search path. By default objects starting with a single _ are not
-          matched, many IPython generated objects have a single
-          underscore. The default is case insensitive matching. Matching is
-          also done on the attributes of objects and not only on the objects
-          in a module.
+        If called without arguments, acts as a toggle."""
 
-          [OBJECT TYPE]
+        def xmode_switch_err(name):
+            warn('Error changing %s exception modes.\n%s' %
+                 (name,sys.exc_info()[1]))
 
-          Is the name of a python type from the types module. The name is
-          given in lowercase without the ending type, ex. StringType is
-          written string. By adding a type here only objects matching the
-          given type are matched. Using all here makes the pattern match all
-          types (this is the default).
+        shell = self.shell
+        new_mode = parameter_s.strip().capitalize()
+        try:
+            shell.InteractiveTB.set_mode(mode=new_mode)
+            print 'Exception reporting mode:',shell.InteractiveTB.mode
+        except:
+            xmode_switch_err('user')
 
-        Options:
+    def magic_quickref(self,arg):
+        """ Show a quick reference sheet """
+        import IPython.core.usage
+        qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
+        page.page(qr)
 
-          -a: makes the pattern match even objects whose names start with a
-          single underscore.  These names are normally omitted from the
-          search.
+    def magic_doctest_mode(self,parameter_s=''):
+        """Toggle doctest mode on and off.
 
-          -i/-c: make the pattern case insensitive/sensitive.  If neither of
-          these options are given, the default is read from your configuration
-          file, with the option ``InteractiveShell.wildcards_case_sensitive``.
-          If this option is not specified in your configuration file, IPython's
-          internal default is to do a case sensitive search.
+        This mode is intended to make IPython behave as much as possible like a
+        plain Python shell, from the perspective of how its prompts, exceptions
+        and output look.  This makes it easy to copy and paste parts of a
+        session into doctests.  It does so by:
 
-          -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you
-          specify can be searched in any of the following namespaces:
-          'builtin', 'user', 'user_global','internal', 'alias', where
-          'builtin' and 'user' are the search defaults.  Note that you should
-          not use quotes when specifying namespaces.
+        - Changing the prompts to the classic ``>>>`` ones.
+        - Changing the exception reporting mode to 'Plain'.
+        - Disabling pretty-printing of output.
 
-          'Builtin' contains the python module builtin, 'user' contains all
-          user data, 'alias' only contain the shell aliases and no python
-          objects, 'internal' contains objects used by IPython.  The
-          'user_global' namespace is only used by embedded IPython instances,
-          and it contains module-level globals.  You can add namespaces to the
-          search with -s or exclude them with -e (these options can be given
-          more than once).
+        Note that IPython also supports the pasting of code snippets that have
+        leading '>>>' and '...' prompts in them.  This means that you can paste
+        doctests from files or docstrings (even if they have leading
+        whitespace), and the code will execute correctly.  You can then use
+        '%history -t' to see the translated history; this will give you the
+        input after removal of all the leading prompts and whitespace, which
+        can be pasted back into an editor.
 
-        Examples
-        --------
-        ::
+        With these features, you can switch into this mode easily whenever you
+        need to do testing and changes to doctests, without having to leave
+        your existing IPython session.
+        """
 
-          %psearch a*            -> objects beginning with an a
-          %psearch -e builtin a* -> objects NOT in the builtin space starting in a
-          %psearch a* function   -> all functions beginning with an a
-          %psearch re.e*         -> objects beginning with an e in module re
-          %psearch r*.e*         -> objects that start with e in modules starting in r
-          %psearch r*.* string   -> all strings in modules beginning with r
+        from IPython.utils.ipstruct import Struct
 
-        Case sensitive search::
+        # Shorthands
+        shell = self.shell
+        pm = shell.prompt_manager
+        meta = shell.meta
+        disp_formatter = self.shell.display_formatter
+        ptformatter = disp_formatter.formatters['text/plain']
+        # dstore is a data store kept in the instance metadata bag to track any
+        # changes we make, so we can undo them later.
+        dstore = meta.setdefault('doctest_mode',Struct())
+        save_dstore = dstore.setdefault
 
-          %psearch -c a*         list all object beginning with lower case a
+        # save a few values we'll need to recover later
+        mode = save_dstore('mode',False)
+        save_dstore('rc_pprint',ptformatter.pprint)
+        save_dstore('xmode',shell.InteractiveTB.mode)
+        save_dstore('rc_separate_out',shell.separate_out)
+        save_dstore('rc_separate_out2',shell.separate_out2)
+        save_dstore('rc_prompts_pad_left',pm.justify)
+        save_dstore('rc_separate_in',shell.separate_in)
+        save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
+        save_dstore('prompt_templates',(pm.in_template, pm.in2_template, pm.out_template))
 
-        Show objects beginning with a single _::
+        if mode == False:
+            # turn on
+            pm.in_template = '>>> '
+            pm.in2_template = '... '
+            pm.out_template = ''
 
-          %psearch -a _*         list objects beginning with a single underscore"""
-        try:
-            parameter_s.encode('ascii')
-        except UnicodeEncodeError:
-            print 'Python identifiers can only contain ascii characters.'
-            return
+            # Prompt separators like plain python
+            shell.separate_in = ''
+            shell.separate_out = ''
+            shell.separate_out2 = ''
 
-        # default namespaces to be searched
-        def_search = ['user_local', 'user_global', 'builtin']
+            pm.justify = False
 
-        # Process options/args
-        opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
-        opt = opts.get
-        shell = self.shell
-        psearch = shell.inspector.psearch
+            ptformatter.pprint = False
+            disp_formatter.plain_text_only = True
 
-        # select case options
-        if opts.has_key('i'):
-            ignore_case = True
-        elif opts.has_key('c'):
-            ignore_case = False
+            shell.magic('xmode Plain')
         else:
-            ignore_case = not shell.wildcards_case_sensitive
+            # turn off
+            pm.in_template, pm.in2_template, pm.out_template = dstore.prompt_templates
 
-        # Build list of namespaces to search from user options
-        def_search.extend(opt('s',[]))
-        ns_exclude = ns_exclude=opt('e',[])
-        ns_search = [nm for nm in def_search if nm not in ns_exclude]
+            shell.separate_in = dstore.rc_separate_in
 
-        # Call the actual search
-        try:
-            psearch(args,shell.ns_table,ns_search,
-                    show_all=opt('a'),ignore_case=ignore_case)
-        except:
-            shell.showtraceback()
+            shell.separate_out = dstore.rc_separate_out
+            shell.separate_out2 = dstore.rc_separate_out2
 
-    @skip_doctest
-    def magic_who_ls(self, parameter_s=''):
-        """Return a sorted list of all interactive variables.
+            pm.justify = dstore.rc_prompts_pad_left
 
-        If arguments are given, only variables of types matching these
-        arguments are returned.
+            ptformatter.pprint = dstore.rc_pprint
+            disp_formatter.plain_text_only = dstore.rc_plain_text_only
 
-        Examples
-        --------
+            shell.magic('xmode ' + dstore.xmode)
 
-        Define two variables and list them with who_ls::
+        # Store new mode and inform
+        dstore.mode = bool(1-int(mode))
+        mode_label = ['OFF','ON'][dstore.mode]
+        print 'Doctest mode is:', mode_label
 
-          In [1]: alpha = 123
+    def magic_gui(self, parameter_s=''):
+        """Enable or disable IPython GUI event loop integration.
 
-          In [2]: beta = 'test'
+        %gui [GUINAME]
 
-          In [3]: %who_ls
-          Out[3]: ['alpha', 'beta']
+        This magic replaces IPython's threaded shells that were activated
+        using the (pylab/wthread/etc.) command line flags.  GUI toolkits
+        can now be enabled at runtime and keyboard
+        interrupts should work without any problems.  The following toolkits
+        are supported:  wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX)::
 
-          In [4]: %who_ls int
-          Out[4]: ['alpha']
+            %gui wx      # enable wxPython event loop integration
+            %gui qt4|qt  # enable PyQt4 event loop integration
+            %gui gtk     # enable PyGTK event loop integration
+            %gui gtk3    # enable Gtk3 event loop integration
+            %gui tk      # enable Tk event loop integration
+            %gui OSX     # enable Cocoa event loop integration
+                         # (requires %matplotlib 1.1)
+            %gui         # disable all event loop integration
 
-          In [5]: %who_ls str
-          Out[5]: ['beta']
+        WARNING:  after any of these has been called you can simply create
+        an application object, but DO NOT start the event loop yourself, as
+        we have already handled that.
         """
-
-        user_ns = self.shell.user_ns
-        user_ns_hidden = self.shell.user_ns_hidden
-        out = [ i for i in user_ns
-                if not i.startswith('_') \
-                and not i in user_ns_hidden ]
-
-        typelist = parameter_s.split()
-        if typelist:
-            typeset = set(typelist)
-            out = [i for i in out if type(user_ns[i]).__name__ in typeset]
-
-        out.sort()
-        return out
+        opts, arg = self.parse_options(parameter_s, '')
+        if arg=='': arg = None
+        try:
+            return self.enable_gui(arg)
+        except Exception as e:
+            # print simple error message, rather than traceback if we can't
+            # hook up the GUI
+            error(str(e))
 
     @skip_doctest
-    def magic_who(self, parameter_s=''):
-        """Print all interactive variables, with some minimal formatting.
+    def magic_precision(self, s=''):
+        """Set floating point precision for pretty printing.
 
-        If any arguments are given, only variables whose type matches one of
-        these are printed.  For example::
+        Can set either integer precision or a format string.
 
-          %who function str
+        If numpy has been imported and precision is an int,
+        numpy display precision will also be set, via ``numpy.set_printoptions``.
 
-        will only list functions and strings, excluding all other types of
-        variables.  To find the proper type names, simply use type(var) at a
-        command line to see how python prints type names.  For example:
+        If no argument is given, defaults will be restored.
 
+        Examples
+        --------
         ::
 
-          In [1]: type('hello')\\
-          Out[1]: <type 'str'>
+            In [1]: from math import pi
 
-        indicates that the type name for strings is 'str'.
+            In [2]: %precision 3
+            Out[2]: u'%.3f'
 
-        ``%who`` always excludes executed names loaded through your configuration
-        file and things which are internal to IPython.
+            In [3]: pi
+            Out[3]: 3.142
 
-        This is deliberate, as typically you may load many modules and the
-        purpose of %who is to show you only what you've manually defined.
+            In [4]: %precision %i
+            Out[4]: u'%i'
 
-        Examples
-        --------
+            In [5]: pi
+            Out[5]: 3
 
-        Define two variables and list them with who::
+            In [6]: %precision %e
+            Out[6]: u'%e'
 
-          In [1]: alpha = 123
+            In [7]: pi**10
+            Out[7]: 9.364805e+04
 
-          In [2]: beta = 'test'
+            In [8]: %precision
+            Out[8]: u'%r'
 
-          In [3]: %who
-          alpha   beta
+            In [9]: pi**10
+            Out[9]: 93648.047476082982
+        """
+        ptformatter = self.shell.display_formatter.formatters['text/plain']
+        ptformatter.float_precision = s
+        return ptformatter.float_format
 
-          In [4]: %who int
-          alpha
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        '-e', '--export', action='store_true', default=False,
+        help='Export IPython history as a notebook. The filename argument '
+             'is used to specify the notebook name and format. For example '
+             'a filename of notebook.ipynb will result in a notebook name '
+             'of "notebook" and a format of "xml". Likewise using a ".json" '
+             'or ".py" file extension will write the notebook in the json '
+             'or py formats.'
+    )
+    @magic_arguments.argument(
+        '-f', '--format',
+        help='Convert an existing IPython notebook to a new format. This option '
+             'specifies the new format and can have the values: xml, json, py. '
+             'The target filename is chosen automatically based on the new '
+             'format. The filename argument gives the name of the source file.'
+    )
+    @magic_arguments.argument(
+        'filename', type=unicode,
+        help='Notebook name or filename'
+    )
+    def magic_notebook(self, s):
+        """Export and convert IPython notebooks.
 
-          In [5]: %who str
-          beta
+        This function can export the current IPython history to a notebook file
+        or can convert an existing notebook file into a different format. For
+        example, to export the history to "foo.ipynb" do "%notebook -e foo.ipynb".
+        To export the history to "foo.py" do "%notebook -e foo.py". To convert
+        "foo.ipynb" to "foo.json" do "%notebook -f json foo.ipynb". Possible
+        formats include (json/ipynb, py).
         """
+        args = magic_arguments.parse_argstring(self.magic_notebook, s)
 
-        varlist = self.magic_who_ls(parameter_s)
-        if not varlist:
-            if parameter_s:
-                print 'No variables match your requested type.'
+        from IPython.nbformat import current
+        args.filename = unquote_filename(args.filename)
+        if args.export:
+            fname, name, format = current.parse_filename(args.filename)
+            cells = []
+            hist = list(self.shell.history_manager.get_range())
+            for session, prompt_number, input in hist[:-1]:
+                cells.append(current.new_code_cell(prompt_number=prompt_number,
+                                                   input=input))
+            worksheet = current.new_worksheet(cells=cells)
+            nb = current.new_notebook(name=name,worksheets=[worksheet])
+            with io.open(fname, 'w', encoding='utf-8') as f:
+                current.write(nb, f, format);
+        elif args.format is not None:
+            old_fname, old_name, old_format = current.parse_filename(args.filename)
+            new_format = args.format
+            if new_format == u'xml':
+                raise ValueError('Notebooks cannot be written as xml.')
+            elif new_format == u'ipynb' or new_format == u'json':
+                new_fname = old_name + u'.ipynb'
+                new_format = u'json'
+            elif new_format == u'py':
+                new_fname = old_name + u'.py'
             else:
-                print 'Interactive namespace is empty.'
-            return
+                raise ValueError('Invalid notebook format: %s' % new_format)
+            with io.open(old_fname, 'r', encoding='utf-8') as f:
+                nb = current.read(f, old_format)
+            with io.open(new_fname, 'w', encoding='utf-8') as f:
+                current.write(nb, f, new_format)
 
-        # if we have variables, move on...
-        count = 0
-        for i in varlist:
-            print i+'\t',
-            count += 1
-            if count > 8:
-                count = 0
-                print
-        print
 
-    @skip_doctest
-    def magic_whos(self, parameter_s=''):
-        """Like %who, but gives some extra information about each variable.
+class CodeMagics(MagicFunctions):
+    """Magics related to code management (loading, saving, editing, ...)."""
 
-        The same type filtering of %who can be applied here.
+    def magic_save(self,parameter_s = ''):
+        """Save a set of lines or a macro to a given filename.
 
-        For all variables, the type is printed. Additionally it prints:
+        Usage:\\
+          %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
 
-          - For {},[],(): their length.
+        Options:
 
-          - For numpy arrays, a summary with shape, number of
-          elements, typecode and size in memory.
+          -r: use 'raw' input.  By default, the 'processed' history is used,
+          so that magics are loaded in their transformed version to valid
+          Python.  If this option is given, the raw input as typed as the
+          command line is used instead.
 
-          - Everything else: a string representation, snipping their middle if
-          too long.
+        This function uses the same syntax as %history for input ranges,
+        then saves the lines to the filename you specify.
 
-        Examples
-        --------
+        It adds a '.py' extension to the file if you don't do so yourself, and
+        it asks for confirmation before overwriting existing files."""
 
-        Define two variables and list them with whos::
+        opts,args = self.parse_options(parameter_s,'r',mode='list')
+        fname, codefrom = unquote_filename(args[0]), " ".join(args[1:])
+        if not fname.endswith('.py'):
+            fname += '.py'
+        if os.path.isfile(fname):
+            ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
+            if ans.lower() not in ['y','yes']:
+                print 'Operation cancelled.'
+                return
+        try:
+            cmds = self.shell.find_user_code(codefrom, 'r' in opts)
+        except (TypeError, ValueError) as e:
+            print e.args[0]
+            return
+        with io.open(fname,'w', encoding="utf-8") as f:
+            f.write(u"# coding: utf-8\n")
+            f.write(py3compat.cast_unicode(cmds))
+        print 'The following commands were written to file `%s`:' % fname
+        print cmds
 
-          In [1]: alpha = 123
+    def magic_pastebin(self, parameter_s = ''):
+        """Upload code to Github's Gist paste bin, returning the URL.
 
-          In [2]: beta = 'test'
+        Usage:\\
+          %pastebin [-d "Custom description"] 1-7
 
-          In [3]: %whos
-          Variable   Type        Data/Info
-          --------------------------------
-          alpha      int         123
-          beta       str         test
+        The argument can be an input history range, a filename, or the name of a
+        string or macro.
+
+        Options:
+
+          -d: Pass a custom description for the gist. The default will say
+              "Pasted from IPython".
         """
+        opts, args = self.parse_options(parameter_s, 'd:')
 
-        varnames = self.magic_who_ls(parameter_s)
-        if not varnames:
-            if parameter_s:
-                print 'No variables match your requested type.'
-            else:
-                print 'Interactive namespace is empty.'
+        try:
+            code = self.shell.find_user_code(args)
+        except (ValueError, TypeError) as e:
+            print e.args[0]
             return
 
-        # if we have variables, move on...
+        post_data = json.dumps({
+          "description": opts.get('d', "Pasted from IPython"),
+          "public": True,
+          "files": {
+            "file1.py": {
+              "content": code
+            }
+          }
+        }).encode('utf-8')
 
-        # for these types, show len() instead of data:
-        seq_types = ['dict', 'list', 'tuple']
+        response = urlopen("https://api.github.com/gists", post_data)
+        response_data = json.loads(response.read().decode('utf-8'))
+        return response_data['html_url']
 
-        # for numpy arrays, display summary info
-        ndarray_type = None
-        if 'numpy' in sys.modules:
-            try:
-                from numpy import ndarray
-            except ImportError:
-                pass
-            else:
-                ndarray_type = ndarray.__name__
+    def magic_loadpy(self, arg_s):
+        """Alias of `%load`
 
-        # Find all variable names and types so we can figure out column sizes
-        def get_vars(i):
-            return self.shell.user_ns[i]
+        `%loadpy` has gained some flexibility and droped the requirement of a `.py`
+        extension. So it has been renamed simply into %load. You can look at
+        `%load`'s docstring for more info.
+        """
+        self.magic_load(arg_s)
 
-        # some types are well known and can be shorter
-        abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
-        def type_name(v):
-            tn = type(v).__name__
-            return abbrevs.get(tn,tn)
+    def magic_load(self, arg_s):
+        """Load code into the current frontend.
 
-        varlist = map(get_vars,varnames)
+        Usage:\\
+          %load [options] source
 
-        typelist = []
-        for vv in varlist:
-            tt = type_name(vv)
+          where source can be a filename, URL, input history range or macro
 
-            if tt=='instance':
-                typelist.append( abbrevs.get(str(vv.__class__),
-                                             str(vv.__class__)))
-            else:
-                typelist.append(tt)
+        Options:
+        --------
+          -y : Don't ask confirmation for loading source above 200 000 characters.
 
-        # column labels and # of spaces as separator
-        varlabel = 'Variable'
-        typelabel = 'Type'
-        datalabel = 'Data/Info'
-        colsep = 3
-        # variable format strings
-        vformat    = "{0:<{varwidth}}{1:<{typewidth}}"
-        aformat    = "%s: %s elems, type `%s`, %s bytes"
-        # find the size of the columns to format the output nicely
-        varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
-        typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
-        # table header
-        print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
-              ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
-        # and the table itself
-        kb = 1024
-        Mb = 1048576  # kb**2
-        for vname,var,vtype in zip(varnames,varlist,typelist):
-            print vformat.format(vname, vtype, varwidth=varwidth, typewidth=typewidth),
-            if vtype in seq_types:
-                print "n="+str(len(var))
-            elif vtype == ndarray_type:
-                vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
-                if vtype==ndarray_type:
-                    # numpy
-                    vsize  = var.size
-                    vbytes = vsize*var.itemsize
-                    vdtype = var.dtype
+        This magic command can either take a local filename, a URL, an history
+        range (see %history) or a macro as argument, it will prompt for
+        confirmation before loading source with more than 200 000 characters, unless
+        -y flag is passed or if the frontend does not support raw_input::
 
-                if vbytes < 100000:
-                    print aformat % (vshape,vsize,vdtype,vbytes)
-                else:
-                    print aformat % (vshape,vsize,vdtype,vbytes),
-                    if vbytes < Mb:
-                        print '(%s kb)' % (vbytes/kb,)
-                    else:
-                        print '(%s Mb)' % (vbytes/Mb,)
-            else:
+        %load myscript.py
+        %load 7-27
+        %load myMacro
+        %load http://www.example.com/myscript.py
+        """
+        opts,args = self.parse_options(arg_s,'y')
+
+        contents = self.shell.find_user_code(args)
+        l = len(contents)
+
+        # 200 000 is ~ 2500 full 80 caracter lines
+        # so in average, more than 5000 lines
+        if l > 200000 and 'y' not in opts:
                 try:
-                    vstr = str(var)
-                except UnicodeEncodeError:
-                    vstr = unicode(var).encode(DEFAULT_ENCODING,
-                                               'backslashreplace')
-                except:
-                    vstr = "<object with id %d (str() failed)>" % id(var)
-                vstr = vstr.replace('\n','\\n')
-                if len(vstr) < 50:
-                    print vstr
-                else:
-                    print vstr[:25] + "<...>" + vstr[-25:]
+                ans = self.shell.ask_yes_no(("The text you're trying to load seems pretty big"\
+                " (%d characters). Continue (y/[N]) ?" % l), default='n' )
+            except StdinNotImplementedError:
+                #asume yes if raw input not implemented
+                ans = True
 
-    def magic_reset(self, parameter_s=''):
-        """Resets the namespace by removing all names defined by the user, if
-        called without arguments, or by removing some types of objects, such
-        as everything currently in IPython's In[] and Out[] containers (see
-        the parameters for details).
+            if ans is False :
+                print 'Operation cancelled.'
+                return
 
-        Parameters
-        ----------
-        -f : force reset without asking for confirmation.
+        self.set_next_input(contents)
 
-        -s : 'Soft' reset: Only clears your namespace, leaving history intact.
-            References to objects may be kept. By default (without this option),
-            we do a 'hard' reset, giving you a new session and removing all
-            references to objects from the current session.
+    def _find_edit_target(self, args, opts, last_call):
+        """Utility method used by magic_edit to find what to edit."""
 
-        in : reset input history
+        def make_filename(arg):
+            "Make a filename from the given args"
+            arg = unquote_filename(arg)
+            try:
+                filename = get_py_filename(arg)
+            except IOError:
+                # If it ends with .py but doesn't already exist, assume we want
+                # a new file.
+                if arg.endswith('.py'):
+                    filename = arg
+                else:
+                    filename = None
+            return filename
        
-        out : reset output history
+        # Set a few locals from the options for convenience:
+        opts_prev = 'p' in opts
+        opts_raw = 'r' in opts
        
-        dhist : reset directory history
+        # custom exceptions
+        class DataIsObject(Exception): pass
         
-        array : reset only variables that are NumPy arrays
+        # Default line number value
+        lineno = opts.get('n',None)
 
-        See Also
-        --------
-        magic_reset_selective : invoked as ``%reset_selective``
+        if opts_prev:
+            args = '_%s' % last_call[0]
+            if not self.shell.user_ns.has_key(args):
+                args = last_call[1]
 
-        Examples
-        --------
-        ::
+        # use last_call to remember the state of the previous call, but don't
+        # let it be clobbered by successive '-p' calls.
+        try:
+            last_call[0] = self.shell.displayhook.prompt_count
+            if not opts_prev:
+                last_call[1] = args
+        except:
+            pass
 
-          In [6]: a = 1
+        # by default this is done with temp files, except when the given
+        # arg is a filename
+        use_temp = True
 
-          In [7]: a
-          Out[7]: 1
+        data = ''
 
-          In [8]: 'a' in _ip.user_ns
-          Out[8]: True
+        # First, see if the arguments should be a filename.
+        filename = make_filename(args)
+        if filename:
+            use_temp = False
+        elif args:
+            # Mode where user specifies ranges of lines, like in %macro.
+            data = self.shell.extract_input_lines(args, opts_raw)
+            if not data:
+                try:
+                    # Load the parameter given as a variable. If not a string,
+                    # process it as an object instead (below)
 
-          In [9]: %reset -f
+                    #print '*** args',args,'type',type(args)  # dbg
+                    data = eval(args, self.shell.user_ns)
+                    if not isinstance(data, basestring):
+                        raise DataIsObject
 
-          In [1]: 'a' in _ip.user_ns
-          Out[1]: False
+                except (NameError,SyntaxError):
+                    # given argument is not a variable, try as a filename
+                    filename = make_filename(args)
+                    if filename is None:
+                        warn("Argument given (%s) can't be found as a variable "
+                             "or as a filename." % args)
+                        return
+                    use_temp = False
 
-          In [2]: %reset -f in
-          Flushing input history
+                except DataIsObject:
+                    # macros have a special edit function
+                    if isinstance(data, Macro):
+                        raise MacroToEdit(data)
 
-          In [3]: %reset -f dhist in
-          Flushing directory history
-          Flushing input history
+                    # For objects, try to edit the file where they are defined
+                    try:
+                        filename = inspect.getabsfile(data)
+                        if 'fakemodule' in filename.lower() and inspect.isclass(data):
+                            # class created by %edit? Try to find source
+                            # by looking for method definitions instead, the
+                            # __module__ in those classes is FakeModule.
+                            attrs = [getattr(data, aname) for aname in dir(data)]
+                            for attr in attrs:
+                                if not inspect.ismethod(attr):
+                                    continue
+                                filename = inspect.getabsfile(attr)
+                                if filename and 'fakemodule' not in filename.lower():
+                                    # change the attribute to be the edit target instead
+                                    data = attr
+                                    break
 
-        Notes
-        -----
-        Calling this magic from clients that do not implement standard input,
-        such as the ipython notebook interface, will reset the namespace
-        without confirmation.
-        """
-        opts, args = self.parse_options(parameter_s,'sf', mode='list')
-        if 'f' in opts:
-            ans = True
-        else:
+                        datafile = 1
+                    except TypeError:
+                        filename = make_filename(args)
+                        datafile = 1
+                        warn('Could not find file where `%s` is defined.\n'
+                             'Opening a file named `%s`' % (args,filename))
+                    # Now, make sure we can actually read the source (if it was in
+                    # a temp file it's gone by now).
+                    if datafile:
             try:
-                ans = self.shell.ask_yes_no(
-                "Once deleted, variables cannot be recovered. Proceed (y/[n])? ", default='n')
-            except StdinNotImplementedError:
-                ans = True
-        if not ans:
-            print 'Nothing done.'
+                            if lineno is None:
+                                lineno = inspect.getsourcelines(data)[1]
+                        except IOError:
+                            filename = make_filename(args)
+                            if filename is None:
+                                warn('The file `%s` where `%s` was defined cannot '
+                                     'be read.' % (filename,data))
             return
+                    use_temp = False
 
-        if 's' in opts:                     # Soft reset
-            user_ns = self.shell.user_ns
-            for i in self.magic_who_ls():
-                del(user_ns[i])
-        elif len(args) == 0:                # Hard reset
-            self.shell.reset(new_session = False)
-        
-        # reset in/out/dhist/array: previously extensinions/clearcmd.py
-        ip = self.shell
-        user_ns = self.shell.user_ns  # local lookup, heavily used
+        if use_temp:
+            filename = self.shell.mktempfile(data)
+            print 'IPython will make a temporary file named:',filename
 
-        for target in args:
-            target = target.lower() # make matches case insensitive
-            if target == 'out':
-                print "Flushing output cache (%d entries)" % len(user_ns['_oh'])
-                self.shell.displayhook.flush()
+        return filename, lineno, use_temp
 
-            elif target == 'in':
-                print "Flushing input history"
-                pc = self.shell.displayhook.prompt_count + 1
-                for n in range(1, pc):
-                    key = '_i'+repr(n)
-                    user_ns.pop(key,None)
-                user_ns.update(dict(_i=u'',_ii=u'',_iii=u''))
-                hm = ip.history_manager
-                # don't delete these, as %save and %macro depending on the length
-                # of these lists to be preserved
-                hm.input_hist_parsed[:] = [''] * pc
-                hm.input_hist_raw[:] = [''] * pc
-                # hm has internal machinery for _i,_ii,_iii, clear it out
-                hm._i = hm._ii = hm._iii = hm._i00 =  u''
+    def _edit_macro(self,mname,macro):
+        """open an editor with the macro data in a file"""
+        filename = self.shell.mktempfile(macro.value)
+        self.shell.hooks.editor(filename)
 
-            elif target == 'array':
-                # Support cleaning up numpy arrays
-                try:
-                    from numpy import ndarray
-                    # This must be done with items and not iteritems because we're
-                    # going to modify the dict in-place.
-                    for x,val in user_ns.items():
-                        if isinstance(val,ndarray):
-                            del user_ns[x]
-                except ImportError:
-                    print "reset array only works if Numpy is available."
+        # and make a new macro object, to replace the old one
+        mfile = open(filename)
+        mvalue = mfile.read()
+        mfile.close()
+        self.shell.user_ns[mname] = Macro(mvalue)
 
-            elif target == 'dhist':
-                print "Flushing directory history"
-                del user_ns['_dh'][:]
+    def magic_ed(self,parameter_s=''):
+        """Alias to %edit."""
+        return self.magic_edit(parameter_s)
 
-            else:
-                print "Don't know how to reset ",
-                print target + ", please run `%reset?` for details"
+    @skip_doctest
+    def magic_edit(self,parameter_s='',last_call=['','']):
+        """Bring up an editor and execute the resulting code.
 
-        gc.collect()
+        Usage:
+          %edit [options] [args]
 
-    def magic_reset_selective(self, parameter_s=''):
-        """Resets the namespace by removing names defined by the user.
+        %edit runs IPython's editor hook. The default version of this hook is
+        set to call the editor specified by your $EDITOR environment variable.
+        If this isn't found, it will default to vi under Linux/Unix and to
+        notepad under Windows. See the end of this docstring for how to change
+        the editor hook.
 
-        Input/Output history are left around in case you need them.
+        You can also set the value of this editor via the
+        ``TerminalInteractiveShell.editor`` option in your configuration file.
+        This is useful if you wish to use a different editor from your typical
+        default with IPython (and for Windows users who typically don't set
+        environment variables).
 
-        %reset_selective [-f] regex
+        This command allows you to conveniently edit multi-line code right in
+        your IPython session.
 
-        No action is taken if regex is not included
+        If called without arguments, %edit opens up an empty editor with a
+        temporary file and will execute the contents of this file when you
+        close it (don't forget to save it!).
 
-        Options
-          -f : force reset without asking for confirmation.
 
-        See Also
-        --------
-        magic_reset : invoked as ``%reset``
+        Options:
 
-        Examples
-        --------
+        -n <number>: open the editor at a specified line number.  By default,
+        the IPython editor hook uses the unix syntax 'editor +N filename', but
+        you can configure this by providing your own modified hook if your
+        favorite editor supports line-number specifications with a different
+        syntax.
 
-        We first fully reset the namespace so your output looks identical to
-        this example for pedagogical reasons; in practice you do not need a
-        full reset::
+        -p: this will call the editor with the same data as the previous time
+        it was used, regardless of how long ago (in your current session) it
+        was.
 
-          In [1]: %reset -f
+        -r: use 'raw' input.  This option only applies to input taken from the
+        user's history.  By default, the 'processed' history is used, so that
+        magics are loaded in their transformed version to valid Python.  If
+        this option is given, the raw input as typed as the command line is
+        used instead.  When you exit the editor, it will be executed by
+        IPython's own processor.
 
-        Now, with a clean namespace we can make a few variables and use
-        ``%reset_selective`` to only delete names that match our regexp::
+        -x: do not execute the edited code immediately upon exit. This is
+        mainly useful if you are editing programs which need to be called with
+        command line arguments, which you can then do using %run.
 
-          In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
 
-          In [3]: who_ls
-          Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
+        Arguments:
 
-          In [4]: %reset_selective -f b[2-3]m
+        If arguments are given, the following possibilities exist:
 
-          In [5]: who_ls
-          Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
+        - If the argument is a filename, IPython will load that into the
+          editor. It will execute its contents with execfile() when you exit,
+          loading any code in the file into your interactive namespace.
 
-          In [6]: %reset_selective -f d
+        - The arguments are ranges of input history,  e.g. "7 ~1/4-6".
+          The syntax is the same as in the %history magic.
 
-          In [7]: who_ls
-          Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
+        - If the argument is a string variable, its contents are loaded
+          into the editor. You can thus edit any string which contains
+          python code (including the result of previous edits).
 
-          In [8]: %reset_selective -f c
+        - If the argument is the name of an object (other than a string),
+          IPython will try to locate the file where it was defined and open the
+          editor at the point where it is defined. You can use `%edit function`
+          to load an editor exactly at the point where 'function' is defined,
+          edit it and have the file be executed automatically.
 
-          In [9]: who_ls
-          Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
+        - If the object is a macro (see %macro for details), this opens up your
+          specified editor with a temporary file containing the macro's data.
+          Upon exit, the macro is reloaded with the contents of the file.
 
-          In [10]: %reset_selective -f b
+        Note: opening at an exact line is only supported under Unix, and some
+        editors (like kedit and gedit up to Gnome 2.8) do not understand the
+        '+NUMBER' parameter necessary for this feature. Good editors like
+        (X)Emacs, vi, jed, pico and joe all do.
 
-          In [11]: who_ls
-          Out[11]: ['a']
+        After executing your code, %edit will return as output the code you
+        typed in the editor (except when it was an existing file). This way
+        you can reload the code in further invocations of %edit as a variable,
+        via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
+        the output.
 
-        Notes
-        -----
-        Calling this magic from clients that do not implement standard input,
-        such as the ipython notebook interface, will reset the namespace
-        without confirmation.
-        """
+        Note that %edit is also available through the alias %ed.
 
-        opts, regex = self.parse_options(parameter_s,'f')
+        This is an example of creating a simple function inside the editor and
+        then modifying it. First, start up the editor::
 
-        if opts.has_key('f'):
-            ans = True
-        else:
-            try:
-                ans = self.shell.ask_yes_no(
-                "Once deleted, variables cannot be recovered. Proceed (y/[n])? ",
-                default='n')
-            except StdinNotImplementedError:
-                ans = True
-        if not ans:
-            print 'Nothing done.'
-            return
-        user_ns = self.shell.user_ns
-        if not regex:
-            print 'No regex pattern specified. Nothing done.'
-            return
-        else:
-            try:
-                m = re.compile(regex)
-            except TypeError:
-                raise TypeError('regex must be a string or compiled pattern')
-            for i in self.magic_who_ls():
-                if m.search(i):
-                    del(user_ns[i])
+          In [1]: ed
+          Editing... done. Executing edited code...
+          Out[1]: 'def foo():\\n    print "foo() was defined in an editing
+          session"\\n'
 
-    def magic_xdel(self, parameter_s=''):
-        """Delete a variable, trying to clear it from anywhere that
-        IPython's machinery has references to it. By default, this uses
-        the identity of the named object in the user namespace to remove
-        references held under other names. The object is also removed
-        from the output history.
+        We can then call the function foo()::
 
-        Options
-          -n : Delete the specified name from all namespaces, without
-          checking their identity.
-        """
-        opts, varname = self.parse_options(parameter_s,'n')
-        try:
-            self.shell.del_var(varname, ('n' in opts))
-        except (NameError, ValueError) as e:
-            print type(e).__name__ +": "+ str(e)
+          In [2]: foo()
+          foo() was defined in an editing session
 
-    def magic_logstart(self,parameter_s=''):
-        """Start logging anywhere in a session.
+        Now we edit foo.  IPython automatically loads the editor with the
+        (temporary) file where foo() was previously defined::
 
-        %logstart [-o|-r|-t] [log_name [log_mode]]
+          In [3]: ed foo
+          Editing... done. Executing edited code...
 
-        If no name is given, it defaults to a file named 'ipython_log.py' in your
-        current directory, in 'rotate' mode (see below).
+        And if we call foo() again we get the modified version::
 
-        '%logstart name' saves to file 'name' in 'backup' mode.  It saves your
-        history up to that point and then continues logging.
+          In [4]: foo()
+          foo() has now been changed!
 
-        %logstart takes a second optional parameter: logging mode. This can be one
-        of (note that the modes are given unquoted):\\
-          append: well, that says it.\\
-          backup: rename (if exists) to name~ and start name.\\
-          global: single logfile in your home dir, appended to.\\
-          over  : overwrite existing log.\\
-          rotate: create rotating logs name.1~, name.2~, etc.
+        Here is an example of how to edit a code snippet successive
+        times. First we call the editor::
 
-        Options:
+          In [5]: ed
+          Editing... done. Executing edited code...
+          hello
+          Out[5]: "print 'hello'\\n"
 
-          -o: log also IPython's output.  In this mode, all commands which
-          generate an Out[NN] prompt are recorded to the logfile, right after
-          their corresponding input line.  The output lines are always
-          prepended with a '#[Out]# ' marker, so that the log remains valid
-          Python code.
+        Now we call it again with the previous output (stored in _)::
 
-          Since this marker is always the same, filtering only the output from
-          a log is very easy, using for example a simple awk call::
+          In [6]: ed _
+          Editing... done. Executing edited code...
+          hello world
+          Out[6]: "print 'hello world'\\n"
 
-            awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
+        Now we call it with the output #8 (stored in _8, also as Out[8])::
 
-          -r: log 'raw' input.  Normally, IPython's logs contain the processed
-          input, so that user lines are logged in their final form, converted
-          into valid Python.  For example, %Exit is logged as
-          _ip.magic("Exit").  If the -r flag is given, all input is logged
-          exactly as typed, with no transformations applied.
+          In [7]: ed _8
+          Editing... done. Executing edited code...
+          hello again
+          Out[7]: "print 'hello again'\\n"
 
-          -t: put timestamps before each input line logged (these are put in
-          comments)."""
 
-        opts,par = self.parse_options(parameter_s,'ort')
-        log_output = 'o' in opts
-        log_raw_input = 'r' in opts
-        timestamp = 't' in opts
+        Changing the default editor hook:
 
-        logger = self.shell.logger
+        If you wish to write your own editor hook, you can put it in a
+        configuration file which you load at startup time.  The default hook
+        is defined in the IPython.core.hooks module, and you can use that as a
+        starting example for further modifications.  That file also has
+        general instructions on how to set a new hook for use once you've
+        defined it."""
+        opts,args = self.parse_options(parameter_s,'prxn:')
 
-        # if no args are given, the defaults set in the logger constructor by
-        # ipython remain valid
-        if par:
             try:
-                logfname,logmode = par.split()
-            except:
-                logfname = par
-                logmode = 'backup'
-        else:
-            logfname = logger.logfname
-            logmode = logger.logmode
-        # put logfname into rc struct as if it had been called on the command
-        # line, so it ends up saved in the log header Save it in case we need
-        # to restore it...
-        old_logfile = self.shell.logfile
-        if logfname:
-            logfname = os.path.expanduser(logfname)
-        self.shell.logfile = logfname
+            filename, lineno, is_temp = self._find_edit_target(args, opts, last_call)
+        except MacroToEdit as e:
+            self._edit_macro(args, e.args[0])
+            return
 
-        loghead = '# IPython log file\n\n'
+        # do actual editing here
+        print 'Editing...',
+        sys.stdout.flush()
         try:
-            started  = logger.logstart(logfname,loghead,logmode,
-                                       log_output,timestamp,log_raw_input)
-        except:
-            self.shell.logfile = old_logfile
-            warn("Couldn't start log: %s" % sys.exc_info()[1])
-        else:
-            # log input history up to this point, optionally interleaving
-            # output if requested
+            # Quote filenames that may have spaces in them
+            if ' ' in filename:
+                filename = "'%s'" % filename
+            self.shell.hooks.editor(filename,lineno)
+        except TryNext:
+            warn('Could not open editor')
+            return
 
-            if timestamp:
-                # disable timestamping for the previous history, since we've
-                # lost those already (no time machine here).
-                logger.timestamp = False
+        # XXX TODO: should this be generalized for all string vars?
+        # For now, this is special-cased to blocks created by cpaste
+        if args.strip() == 'pasted_block':
+            self.shell.user_ns['pasted_block'] = file_read(filename)
 
-            if log_raw_input:
-                input_hist = self.shell.history_manager.input_hist_raw
+        if 'x' in opts:  # -x prevents actual execution
+            print
             else:
-                input_hist = self.shell.history_manager.input_hist_parsed
-
-            if log_output:
-                log_write = logger.log_write
-                output_hist = self.shell.history_manager.output_hist
-                for n in range(1,len(input_hist)-1):
-                    log_write(input_hist[n].rstrip() + '\n')
-                    if n in output_hist:
-                        log_write(repr(output_hist[n]),'output')
+            print 'done. Executing edited code...'
+            if 'r' in opts:    # Untranslated IPython code
+                self.shell.run_cell(file_read(filename),
+                                                    store_history=False)
             else:
-                logger.log_write('\n'.join(input_hist[1:]))
-                logger.log_write('\n')
-            if timestamp:
-                # re-enable timestamping
-                logger.timestamp = True
-
-            print ('Activating auto-logging. '
-                   'Current session state plus future input saved.')
-            logger.logstate()
+                self.shell.safe_execfile(filename, self.shell.user_ns,
+                                         self.shell.user_ns)
 
-    def magic_logstop(self,parameter_s=''):
-        """Fully stop logging and close log file.
+        if is_temp:
+            try:
+                return open(filename).read()
+            except IOError,msg:
+                if msg.filename == filename:
+                    warn('File not found. Did you forget to save?')
+                    return
+                else:
+                    self.shell.showtraceback()
 
-        In order to start logging again, a new %logstart call needs to be made,
-        possibly (though not necessarily) with a new filename, mode and other
-        options."""
-        self.logger.logstop()
 
-    def magic_logoff(self,parameter_s=''):
-        """Temporarily stop logging.
+class ConfigMagics(MagicFunctions):
 
-        You must have previously started logging."""
-        self.shell.logger.switch_log(0)
+    def __init__(self, shell):
+        super(ProfileMagics, self).__init__(shell)
+        self.configurables = []
 
-    def magic_logon(self,parameter_s=''):
-        """Restart logging.
+    def magic_config(self, s):
+        """configure IPython
 
-        This function is for restarting logging which you've temporarily
-        stopped with %logoff. For starting logging for the first time, you
-        must use the %logstart function, which allows you to specify an
-        optional log filename."""
+            %config Class[.trait=value]
 
-        self.shell.logger.switch_log(1)
+        This magic exposes most of the IPython config system. Any
+        Configurable class should be able to be configured with the simple
+        line::
 
-    def magic_logstate(self,parameter_s=''):
-        """Print the status of the logging system."""
+            %config Class.trait=value
 
-        self.shell.logger.logstate()
+        Where `value` will be resolved in the user's namespace, if it is an
+        expression or variable name.
 
-    def magic_pdb(self, parameter_s=''):
-        """Control the automatic calling of the pdb interactive debugger.
+        Examples
+        --------
 
-        Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
-        argument it works as a toggle.
+        To see what classes are available for config, pass no arguments::
 
-        When an exception is triggered, IPython can optionally call the
-        interactive pdb debugger after the traceback printout. %pdb toggles
-        this feature on and off.
+            In [1]: %config
+            Available objects for config:
+                TerminalInteractiveShell
+                HistoryManager
+                PrefilterManager
+                AliasManager
+                IPCompleter
+                PromptManager
+                DisplayFormatter
 
-        The initial state of this feature is set in your configuration
-        file (the option is ``InteractiveShell.pdb``).
+        To view what is configurable on a given class, just pass the class
+        name::
 
-        If you want to just activate the debugger AFTER an exception has fired,
-        without having to type '%pdb on' and rerunning your code, you can use
-        the %debug magic."""
+            In [2]: %config IPCompleter
+            IPCompleter options
+            -----------------
+            IPCompleter.omit__names=<Enum>
+                Current: 2
+                Choices: (0, 1, 2)
+                Instruct the completer to omit private method names
+                Specifically, when completing on ``object.<tab>``.
+                When 2 [default]: all names that start with '_' will be excluded.
+                When 1: all 'magic' names (``__foo__``) will be excluded.
+                When 0: nothing will be excluded.
+            IPCompleter.merge_completions=<CBool>
+                Current: True
+                Whether to merge completion results into a single list
+                If False, only the completion results from the first non-empty completer
+                will be returned.
+            IPCompleter.limit_to__all__=<CBool>
+                Current: False
+                Instruct the completer to use __all__ for the completion
+                Specifically, when completing on ``object.<tab>``.
+                When True: only those names in obj.__all__ will be included.
+                When False [default]: the __all__ attribute is ignored
+            IPCompleter.greedy=<CBool>
+                Current: False
+                Activate greedy completion
+                This will enable completion on elements of lists, results of function calls,
+                etc., but can be unsafe because the code is actually evaluated on TAB.
 
-        par = parameter_s.strip().lower()
+        but the real use is in setting values::
 
-        if par:
-            try:
-                new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
-            except KeyError:
-                print ('Incorrect argument. Use on/1, off/0, '
-                       'or nothing for a toggle.')
-                return
-        else:
-            # toggle
-            new_pdb = not self.shell.call_pdb
+            In [3]: %config IPCompleter.greedy = True
 
-        # set on the shell
-        self.shell.call_pdb = new_pdb
-        print 'Automatic pdb calling has been turned',on_off(new_pdb)
+        and these values are read from the user_ns if they are variables::
 
-    def magic_debug(self, parameter_s=''):
-        """Activate the interactive debugger in post-mortem mode.
+            In [4]: feeling_greedy=False
 
-        If an exception has just occurred, this lets you inspect its stack
-        frames interactively.  Note that this will always work only on the last
-        traceback that occurred, so you must call this quickly after an
-        exception that you wish to inspect has fired, because if another one
-        occurs, it clobbers the previous one.
+            In [5]: %config IPCompleter.greedy = feeling_greedy
 
-        If you want IPython to automatically do this on every exception, see
-        the %pdb magic for more details.
         """
-        self.shell.debugger(force=True)
+        from IPython.config.loader import Config
+        # some IPython objects are Configurable, but do not yet have
+        # any configurable traits.  Exclude them from the effects of
+        # this magic, as their presence is just noise:
+        configurables = [ c for c in self.shell.configurables
+                          if c.__class__.class_traits(config=True) ]
+        classnames = [ c.__class__.__name__ for c in configurables ]
 
-    @skip_doctest
-    def magic_prun(self, parameter_s ='',user_mode=1,
-                   opts=None,arg_lst=None,prog_ns=None):
+        line = s.strip()
+        if not line:
+            # print available configurable names
+            print "Available objects for config:"
+            for name in classnames:
+                print "    ", name
+            return
+        elif line in classnames:
+            # `%config TerminalInteractiveShell` will print trait info for
+            # TerminalInteractiveShell
+            c = configurables[classnames.index(line)]
+            cls = c.__class__
+            help = cls.class_get_help(c)
+            # strip leading '--' from cl-args:
+            help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
+            print help
+            return
+        elif '=' not in line:
+            raise UsageError("Invalid config statement: %r, should be Class.trait = value" % line)
 
-        """Run a statement through the python code profiler.
 
-        Usage:
-          %prun [options] statement
+        # otherwise, assume we are setting configurables.
+        # leave quotes on args when splitting, because we want
+        # unquoted args to eval in user_ns
+        cfg = Config()
+        exec "cfg."+line in locals(), self.shell.user_ns
 
-        The given statement (which doesn't require quote marks) is run via the
-        python profiler in a manner similar to the profile.run() function.
-        Namespaces are internally managed to work correctly; profile.run
-        cannot be used in IPython because it makes certain assumptions about
-        namespaces which do not hold under IPython.
+        for configurable in configurables:
+            try:
+                configurable.update_config(cfg)
+            except Exception as e:
+                error(e)
 
-        Options:
 
-        -l <limit>: you can place restrictions on what or how much of the
-        profile gets printed. The limit value can be:
+class NamespaceMagics(MagicFunctions):
+    """Magics to manage various aspects of the user's namespace.
 
-          * A string: only information for function names containing this string
-          is printed.
+    These include listing variables, introspecting into them, etc.
+    """
 
-          * An integer: only these many lines are printed.
+    def magic_pinfo(self, parameter_s='', namespaces=None):
+        """Provide detailed information about an object.
 
-          * A float (between 0 and 1): this fraction of the report is printed
-          (for example, use a limit of 0.4 to see the topmost 40% only).
+        '%pinfo object' is just a synonym for object? or ?object."""
 
-        You can combine several limits with repeated use of the option. For
-        example, '-l __init__ -l 5' will print only the topmost 5 lines of
-        information about class constructors.
+        #print 'pinfo par: <%s>' % parameter_s  # dbg
 
-        -r: return the pstats.Stats object generated by the profiling. This
-        object has all the information about the profile in it, and you can
-        later use it for further analysis or in other functions.
 
-       -s <key>: sort profile by given key. You can provide more than one key
-        by using the option several times: '-s key1 -s key2 -s key3...'. The
-        default sorting key is 'time'.
+        # detail_level: 0 -> obj? , 1 -> obj??
+        detail_level = 0
+        # We need to detect if we got called as 'pinfo pinfo foo', which can
+        # happen if the user types 'pinfo foo?' at the cmd line.
+        pinfo,qmark1,oname,qmark2 = \
+               re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
+        if pinfo or qmark1 or qmark2:
+            detail_level = 1
+        if "*" in oname:
+            self.magic_psearch(oname)
+        else:
+            self.shell._inspect('pinfo', oname, detail_level=detail_level,
+                                namespaces=namespaces)
 
-        The following is copied verbatim from the profile documentation
-        referenced below:
+    def magic_pinfo2(self, parameter_s='', namespaces=None):
+        """Provide extra detailed information about an object.
 
-        When more than one key is provided, additional keys are used as
-        secondary criteria when the there is equality in all keys selected
-        before them.
+        '%pinfo2 object' is just a synonym for object?? or ??object."""
+        self.shell._inspect('pinfo', parameter_s, detail_level=1,
+                            namespaces=namespaces)
 
-        Abbreviations can be used for any key names, as long as the
-        abbreviation is unambiguous.  The following are the keys currently
-        defined:
+    @skip_doctest
+    def magic_pdef(self, parameter_s='', namespaces=None):
+        """Print the definition header for any callable object.
 
-                Valid Arg       Meaning
-                  "calls"      call count
-                  "cumulative" cumulative time
-                  "file"       file name
-                  "module"     file name
-                  "pcalls"     primitive call count
-                  "line"       line number
-                  "name"       function name
-                  "nfl"        name/file/line
-                  "stdname"    standard name
-                  "time"       internal time
+        If the object is a class, print the constructor information.
 
-        Note that all sorts on statistics are in descending order (placing
-        most time consuming items first), where as name, file, and line number
-        searches are in ascending order (i.e., alphabetical). The subtle
-        distinction between "nfl" and "stdname" is that the standard name is a
-        sort of the name as printed, which means that the embedded line
-        numbers get compared in an odd way.  For example, lines 3, 20, and 40
-        would (if the file names were the same) appear in the string order
-        "20" "3" and "40".  In contrast, "nfl" does a numeric compare of the
-        line numbers.  In fact, sort_stats("nfl") is the same as
-        sort_stats("name", "file", "line").
+        Examples
+        --------
+        ::
 
-        -T <filename>: save profile results as shown on screen to a text
-        file. The profile is still shown on screen.
+          In [3]: %pdef urllib.urlopen
+          urllib.urlopen(url, data=None, proxies=None)
+        """
+        self._inspect('pdef',parameter_s, namespaces)
 
-        -D <filename>: save (via dump_stats) profile statistics to given
-        filename. This data is in a format understood by the pstats module, and
-        is generated by a call to the dump_stats() method of profile
-        objects. The profile is still shown on screen.
+    def magic_pdoc(self, parameter_s='', namespaces=None):
+        """Print the docstring for an object.
 
-        -q: suppress output to the pager.  Best used with -T and/or -D above.
+        If the given object is a class, it will print both the class and the
+        constructor docstrings."""
+        self._inspect('pdoc',parameter_s, namespaces)
 
-        If you want to run complete programs under the profiler's control, use
-        '%run -p [prof_opts] filename.py [args to program]' where prof_opts
-        contains profiler specific options as described here.
+    def magic_psource(self, parameter_s='', namespaces=None):
+        """Print (or run through pager) the source code for an object."""
+        self._inspect('psource',parameter_s, namespaces)
 
-        You can read the complete documentation for the profile module with::
+    def magic_pfile(self, parameter_s=''):
+        """Print (or run through pager) the file where an object is defined.
 
-          In [1]: import profile; profile.help()
-        """
+        The file opens at the line where the object definition begins. IPython
+        will honor the environment variable PAGER if set, and otherwise will
+        do its best to print the file in a convenient form.
 
-        opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
+        If the given argument is not an object currently defined, IPython will
+        try to interpret it as a filename (automatically adding a .py extension
+        if needed). You can thus use %pfile as a syntax highlighting code
+        viewer."""
 
-        if user_mode:  # regular user call
-            opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:q',
-                                              list_all=1, posix=False)
-            namespace = self.shell.user_ns
-        else:  # called to run a program by %run -p
-            try:
-                filename = get_py_filename(arg_lst[0])
-            except IOError as e:
+        # first interpret argument as an object name
+        out = self._inspect('pfile',parameter_s)
+        # if not, try the input as a filename
+        if out == 'not found':
                 try:
-                    msg = str(e)
-                except UnicodeError:
-                    msg = e.message
-                error(msg)
+                filename = get_py_filename(parameter_s)
+            except IOError,msg:
+                print msg
                 return
+            page.page(self.shell.inspector.format(open(filename).read()))
 
-            arg_str = 'execfile(filename,prog_ns)'
-            namespace = {
-                'execfile': self.shell.safe_execfile,
-                'prog_ns': prog_ns,
-                'filename': filename
-                }
+    def magic_psearch(self, parameter_s=''):
+        """Search for object in namespaces by wildcard.
 
-        opts.merge(opts_def)
+        %psearch [options] PATTERN [OBJECT TYPE]
 
-        prof = profile.Profile()
-        try:
-            prof = prof.runctx(arg_str,namespace,namespace)
-            sys_exit = ''
-        except SystemExit:
-            sys_exit = """*** SystemExit exception caught in code being profiled."""
+        Note: ? can be used as a synonym for %psearch, at the beginning or at
+        the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the
+        rest of the command line must be unchanged (options come first), so
+        for example the following forms are equivalent
 
-        stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
+        %psearch -i a* function
+        -i a* function?
+        ?-i a* function
 
-        lims = opts.l
-        if lims:
-            lims = []  # rebuild lims with ints/floats/strings
-            for lim in opts.l:
-                try:
-                    lims.append(int(lim))
-                except ValueError:
-                    try:
-                        lims.append(float(lim))
-                    except ValueError:
-                        lims.append(lim)
+        Arguments:
 
-        # Trap output.
-        stdout_trap = StringIO()
+          PATTERN
 
-        if hasattr(stats,'stream'):
-            # In newer versions of python, the stats object has a 'stream'
-            # attribute to write into.
-            stats.stream = stdout_trap
-            stats.print_stats(*lims)
-        else:
-            # For older versions, we manually redirect stdout during printing
-            sys_stdout = sys.stdout
-            try:
-                sys.stdout = stdout_trap
-                stats.print_stats(*lims)
-            finally:
-                sys.stdout = sys_stdout
+          where PATTERN is a string containing * as a wildcard similar to its
+          use in a shell.  The pattern is matched in all namespaces on the
+          search path. By default objects starting with a single _ are not
+          matched, many IPython generated objects have a single
+          underscore. The default is case insensitive matching. Matching is
+          also done on the attributes of objects and not only on the objects
+          in a module.
 
-        output = stdout_trap.getvalue()
-        output = output.rstrip()
+          [OBJECT TYPE]
 
-        if 'q' not in opts:
-            page.page(output)
-        print sys_exit,
+          Is the name of a python type from the types module. The name is
+          given in lowercase without the ending type, ex. StringType is
+          written string. By adding a type here only objects matching the
+          given type are matched. Using all here makes the pattern match all
+          types (this is the default).
 
-        dump_file = opts.D[0]
-        text_file = opts.T[0]
-        if dump_file:
-            dump_file = unquote_filename(dump_file)
-            prof.dump_stats(dump_file)
-            print '\n*** Profile stats marshalled to file',\
-                  `dump_file`+'.',sys_exit
-        if text_file:
-            text_file = unquote_filename(text_file)
-            pfile = open(text_file,'w')
-            pfile.write(output)
-            pfile.close()
-            print '\n*** Profile printout saved to text file',\
-                  `text_file`+'.',sys_exit
+        Options:
 
-        if opts.has_key('r'):
-            return stats
-        else:
-            return None
+          -a: makes the pattern match even objects whose names start with a
+          single underscore.  These names are normally omitted from the
+          search.
 
-    @skip_doctest
-    def magic_run(self, parameter_s ='', runner=None,
-                  file_finder=get_py_filename):
-        """Run the named file inside IPython as a program.
+          -i/-c: make the pattern case insensitive/sensitive.  If neither of
+          these options are given, the default is read from your configuration
+          file, with the option ``InteractiveShell.wildcards_case_sensitive``.
+          If this option is not specified in your configuration file, IPython's
+          internal default is to do a case sensitive search.
 
-        Usage:\\
-          %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
+          -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you
+          specify can be searched in any of the following namespaces:
+          'builtin', 'user', 'user_global','internal', 'alias', where
+          'builtin' and 'user' are the search defaults.  Note that you should
+          not use quotes when specifying namespaces.
 
-        Parameters after the filename are passed as command-line arguments to
-        the program (put in sys.argv). Then, control returns to IPython's
-        prompt.
+          'Builtin' contains the python module builtin, 'user' contains all
+          user data, 'alias' only contain the shell aliases and no python
+          objects, 'internal' contains objects used by IPython.  The
+          'user_global' namespace is only used by embedded IPython instances,
+          and it contains module-level globals.  You can add namespaces to the
+          search with -s or exclude them with -e (these options can be given
+          more than once).
 
-        This is similar to running at a system prompt:\\
-          $ python file args\\
-        but with the advantage of giving you IPython's tracebacks, and of
-        loading all variables into your interactive namespace for further use
-        (unless -p is used, see below).
+        Examples
+        --------
+        ::
 
-        The file is executed in a namespace initially consisting only of
-        __name__=='__main__' and sys.argv constructed as indicated. It thus
-        sees its environment as if it were being run as a stand-alone program
-        (except for sharing global objects such as previously imported
-        modules). But after execution, the IPython interactive namespace gets
-        updated with all variables defined in the program (except for __name__
-        and sys.argv). This allows for very convenient loading of code for
-        interactive work, while giving each program a 'clean sheet' to run in.
+          %psearch a*            -> objects beginning with an a
+          %psearch -e builtin a* -> objects NOT in the builtin space starting in a
+          %psearch a* function   -> all functions beginning with an a
+          %psearch re.e*         -> objects beginning with an e in module re
+          %psearch r*.e*         -> objects that start with e in modules starting in r
+          %psearch r*.* string   -> all strings in modules beginning with r
 
-        Options:
+        Case sensitive search::
 
-        -n: __name__ is NOT set to '__main__', but to the running file's name
-        without extension (as python does under import).  This allows running
-        scripts and reloading the definitions in them without calling code
-        protected by an ' if __name__ == "__main__" ' clause.
+          %psearch -c a*         list all object beginning with lower case a
 
-        -i: run the file in IPython's namespace instead of an empty one. This
-        is useful if you are experimenting with code written in a text editor
-        which depends on variables defined interactively.
+        Show objects beginning with a single _::
 
-        -e: ignore sys.exit() calls or SystemExit exceptions in the script
-        being run.  This is particularly useful if IPython is being used to
-        run unittests, which always exit with a sys.exit() call.  In such
-        cases you are interested in the output of the test results, not in
-        seeing a traceback of the unittest module.
+          %psearch -a _*         list objects beginning with a single underscore"""
+        try:
+            parameter_s.encode('ascii')
+        except UnicodeEncodeError:
+            print 'Python identifiers can only contain ascii characters.'
+            return
 
-        -t: print timing information at the end of the run.  IPython will give
-        you an estimated CPU time consumption for your script, which under
-        Unix uses the resource module to avoid the wraparound problems of
-        time.clock().  Under Unix, an estimate of time spent on system tasks
-        is also given (for Windows platforms this is reported as 0.0).
+        # default namespaces to be searched
+        def_search = ['user_local', 'user_global', 'builtin']
 
-        If -t is given, an additional -N<N> option can be given, where <N>
-        must be an integer indicating how many times you want the script to
-        run.  The final timing report will include total and per run results.
+        # Process options/args
+        opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
+        opt = opts.get
+        shell = self.shell
+        psearch = shell.inspector.psearch
 
-        For example (testing the script uniq_stable.py)::
+        # select case options
+        if opts.has_key('i'):
+            ignore_case = True
+        elif opts.has_key('c'):
+            ignore_case = False
+        else:
+            ignore_case = not shell.wildcards_case_sensitive
 
-            In [1]: run -t uniq_stable
+        # Build list of namespaces to search from user options
+        def_search.extend(opt('s',[]))
+        ns_exclude = ns_exclude=opt('e',[])
+        ns_search = [nm for nm in def_search if nm not in ns_exclude]
 
-            IPython CPU timings (estimated):\\
-              User  :    0.19597 s.\\
-              System:        0.0 s.\\
+        # Call the actual search
+        try:
+            psearch(args,shell.ns_table,ns_search,
+                    show_all=opt('a'),ignore_case=ignore_case)
+        except:
+            shell.showtraceback()
 
-            In [2]: run -t -N5 uniq_stable
+    @skip_doctest
+    def magic_who_ls(self, parameter_s=''):
+        """Return a sorted list of all interactive variables.
 
-            IPython CPU timings (estimated):\\
-            Total runs performed: 5\\
-              Times :      Total       Per run\\
-              User  :   0.910862 s,  0.1821724 s.\\
-              System:        0.0 s,        0.0 s.
+        If arguments are given, only variables of types matching these
+        arguments are returned.
 
-        -d: run your program under the control of pdb, the Python debugger.
-        This allows you to execute your program step by step, watch variables,
-        etc.  Internally, what IPython does is similar to calling:
+        Examples
+        --------
 
-          pdb.run('execfile("YOURFILENAME")')
+        Define two variables and list them with who_ls::
 
-        with a breakpoint set on line 1 of your file.  You can change the line
-        number for this automatic breakpoint to be <N> by using the -bN option
-        (where N must be an integer).  For example::
+          In [1]: alpha = 123
 
-          %run -d -b40 myscript
+          In [2]: beta = 'test'
 
-        will set the first breakpoint at line 40 in myscript.py.  Note that
-        the first breakpoint must be set on a line which actually does
-        something (not a comment or docstring) for it to stop execution.
+          In [3]: %who_ls
+          Out[3]: ['alpha', 'beta']
 
-        When the pdb debugger starts, you will see a (Pdb) prompt.  You must
-        first enter 'c' (without quotes) to start execution up to the first
-        breakpoint.
+          In [4]: %who_ls int
+          Out[4]: ['alpha']
 
-        Entering 'help' gives information about the use of the debugger.  You
-        can easily see pdb's full documentation with "import pdb;pdb.help()"
-        at a prompt.
+          In [5]: %who_ls str
+          Out[5]: ['beta']
+        """
 
-        -p: run program under the control of the Python profiler module (which
-        prints a detailed report of execution times, function calls, etc).
+        user_ns = self.shell.user_ns
+        user_ns_hidden = self.shell.user_ns_hidden
+        out = [ i for i in user_ns
+                if not i.startswith('_') \
+                and not i in user_ns_hidden ]
 
-        You can pass other options after -p which affect the behavior of the
-        profiler itself. See the docs for %prun for details.
+        typelist = parameter_s.split()
+        if typelist:
+            typeset = set(typelist)
+            out = [i for i in out if type(user_ns[i]).__name__ in typeset]
 
-        In this mode, the program's variables do NOT propagate back to the
-        IPython interactive namespace (because they remain in the namespace
-        where the profiler executes them).
+        out.sort()
+        return out
 
-        Internally this triggers a call to %prun, see its documentation for
-        details on the options available specifically for profiling.
+    @skip_doctest
+    def magic_who(self, parameter_s=''):
+        """Print all interactive variables, with some minimal formatting.
 
-        There is one special usage for which the text above doesn't apply:
-        if the filename ends with .ipy, the file is run as ipython script,
-        just as if the commands were written on IPython prompt.
+        If any arguments are given, only variables whose type matches one of
+        these are printed.  For example::
 
-        -m: specify module name to load instead of script path. Similar to
-        the -m option for the python interpreter. Use this option last if you
-        want to combine with other %run options. Unlike the python interpreter
-        only source modules are allowed no .pyc or .pyo files.
-        For example::
+          %who function str
 
-            %run -m example
+        will only list functions and strings, excluding all other types of
+        variables.  To find the proper type names, simply use type(var) at a
+        command line to see how python prints type names.  For example:
 
-        will run the example module.
+        ::
 
-        """
+          In [1]: type('hello')\\
+          Out[1]: <type 'str'>
 
-        # get arguments and set sys.argv for program to be run.
-        opts, arg_lst = self.parse_options(parameter_s, 'nidtN:b:pD:l:rs:T:em:',
-                                           mode='list', list_all=1)
-        if "m" in opts:
-            modulename = opts["m"][0]
-            modpath = find_mod(modulename)
-            if modpath is None:
-                warn('%r is not a valid modulename on sys.path'%modulename)
-                return
-            arg_lst = [modpath] + arg_lst
-        try:
-            filename = file_finder(arg_lst[0])
-        except IndexError:
-            warn('you must provide at least a filename.')
-            print '\n%run:\n', oinspect.getdoc(self.magic_run)
-            return
-        except IOError as e:
-            try:
-                msg = str(e)
-            except UnicodeError:
-                msg = e.message
-            error(msg)
-            return
+        indicates that the type name for strings is 'str'.
 
-        if filename.lower().endswith('.ipy'):
-            self.shell.safe_execfile_ipy(filename)
-            return
+        ``%who`` always excludes executed names loaded through your configuration
+        file and things which are internal to IPython.
 
-        # Control the response to exit() calls made by the script being run
-        exit_ignore = 'e' in opts
+        This is deliberate, as typically you may load many modules and the
+        purpose of %who is to show you only what you've manually defined.
 
-        # Make sure that the running script gets a proper sys.argv as if it
-        # were run from a system shell.
-        save_argv = sys.argv # save it for later restoring
+        Examples
+        --------
 
-        # simulate shell expansion on arguments, at least tilde expansion
-        args = [ os.path.expanduser(a) for a in arg_lst[1:] ]
+        Define two variables and list them with who::
 
-        sys.argv = [filename] + args  # put in the proper filename
-        # protect sys.argv from potential unicode strings on Python 2:
-        if not py3compat.PY3:
-            sys.argv = [ py3compat.cast_bytes(a) for a in sys.argv ]
+          In [1]: alpha = 123
 
-        if 'i' in opts:
-            # Run in user's interactive namespace
-            prog_ns = self.shell.user_ns
-            __name__save = self.shell.user_ns['__name__']
-            prog_ns['__name__'] = '__main__'
-            main_mod = self.shell.new_main_mod(prog_ns)
-        else:
-            # Run in a fresh, empty namespace
-            if 'n' in opts:
-                name = os.path.splitext(os.path.basename(filename))[0]
-            else:
-                name = '__main__'
+          In [2]: beta = 'test'
 
-            main_mod = self.shell.new_main_mod()
-            prog_ns = main_mod.__dict__
-            prog_ns['__name__'] = name
+          In [3]: %who
+          alpha   beta
 
-        # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
-        # set the __file__ global in the script's namespace
-        prog_ns['__file__'] = filename
+          In [4]: %who int
+          alpha
 
-        # pickle fix.  See interactiveshell for an explanation.  But we need to make sure
-        # that, if we overwrite __main__, we replace it at the end
-        main_mod_name = prog_ns['__name__']
+          In [5]: %who str
+          beta
+        """
 
-        if main_mod_name == '__main__':
-            restore_main = sys.modules['__main__']
+        varlist = self.magic_who_ls(parameter_s)
+        if not varlist:
+            if parameter_s:
+                print 'No variables match your requested type.'
         else:
-            restore_main = False
+                print 'Interactive namespace is empty.'
+            return
 
-        # This needs to be undone at the end to prevent holding references to
-        # every single object ever created.
-        sys.modules[main_mod_name] = main_mod
+        # if we have variables, move on...
+        count = 0
+        for i in varlist:
+            print i+'\t',
+            count += 1
+            if count > 8:
+                count = 0
+                print
+        print
 
-        try:
-            stats = None
-            with self.shell.readline_no_record:
-                if 'p' in opts:
-                    stats = self.magic_prun('', 0, opts, arg_lst, prog_ns)
-                else:
-                    if 'd' in opts:
-                        deb = debugger.Pdb(self.shell.colors)
-                        # reset Breakpoint state, which is moronically kept
-                        # in a class
-                        bdb.Breakpoint.next = 1
-                        bdb.Breakpoint.bplist = {}
-                        bdb.Breakpoint.bpbynumber = [None]
-                        # Set an initial breakpoint to stop execution
-                        maxtries = 10
-                        bp = int(opts.get('b', [1])[0])
-                        checkline = deb.checkline(filename, bp)
-                        if not checkline:
-                            for bp in range(bp + 1, bp + maxtries + 1):
-                                if deb.checkline(filename, bp):
-                                    break
+    @skip_doctest
+    def magic_whos(self, parameter_s=''):
+        """Like %who, but gives some extra information about each variable.
+
+        The same type filtering of %who can be applied here.
+
+        For all variables, the type is printed. Additionally it prints:
+
+          - For {},[],(): their length.
+
+          - For numpy arrays, a summary with shape, number of
+          elements, typecode and size in memory.
+
+          - Everything else: a string representation, snipping their middle if
+          too long.
+
+        Examples
+        --------
+
+        Define two variables and list them with whos::
+
+          In [1]: alpha = 123
+
+          In [2]: beta = 'test'
+
+          In [3]: %whos
+          Variable   Type        Data/Info
+          --------------------------------
+          alpha      int         123
+          beta       str         test
+        """
+
+        varnames = self.magic_who_ls(parameter_s)
+        if not varnames:
+            if parameter_s:
+                print 'No variables match your requested type.'
                             else:
-                                msg = ("\nI failed to find a valid line to set "
-                                       "a breakpoint\n"
-                                       "after trying up to line: %s.\n"
-                                       "Please set a valid breakpoint manually "
-                                       "with the -b option." % bp)
-                                error(msg)
+                print 'Interactive namespace is empty.'
                                 return
-                        # if we find a good linenumber, set the breakpoint
-                        deb.do_break('%s:%s' % (filename, bp))
-                        # Start file run
-                        print "NOTE: Enter 'c' at the",
-                        print "%s prompt to start your script." % deb.prompt
-                        ns = {'execfile': py3compat.execfile, 'prog_ns': prog_ns}
-                        try:
-                            deb.run('execfile("%s", prog_ns)' % filename, ns)
 
-                        except:
-                            etype, value, tb = sys.exc_info()
-                            # Skip three frames in the traceback: the %run one,
-                            # one inside bdb.py, and the command-line typed by the
-                            # user (run by exec in pdb itself).
-                            self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
-                    else:
-                        if runner is None:
-                            runner = self.default_runner
-                        if runner is None:
-                            runner = self.shell.safe_execfile
-                        if 't' in opts:
-                            # timed execution
+        # if we have variables, move on...
+
+        # for these types, show len() instead of data:
+        seq_types = ['dict', 'list', 'tuple']
+
+        # for numpy arrays, display summary info
+        ndarray_type = None
+        if 'numpy' in sys.modules:
                             try:
-                                nruns = int(opts['N'][0])
-                                if nruns < 1:
-                                    error('Number of runs must be >=1')
-                                    return
-                            except (KeyError):
-                                nruns = 1
-                            twall0 = time.time()
-                            if nruns == 1:
-                                t0 = clock2()
-                                runner(filename, prog_ns, prog_ns,
-                                       exit_ignore=exit_ignore)
-                                t1 = clock2()
-                                t_usr = t1[0] - t0[0]
-                                t_sys = t1[1] - t0[1]
-                                print "\nIPython CPU timings (estimated):"
-                                print "  User   : %10.2f s." % t_usr
-                                print "  System : %10.2f s." % t_sys
+                from numpy import ndarray
+            except ImportError:
+                pass
                             else:
-                                runs = range(nruns)
-                                t0 = clock2()
-                                for nr in runs:
-                                    runner(filename, prog_ns, prog_ns,
-                                           exit_ignore=exit_ignore)
-                                t1 = clock2()
-                                t_usr = t1[0] - t0[0]
-                                t_sys = t1[1] - t0[1]
-                                print "\nIPython CPU timings (estimated):"
-                                print "Total runs performed:", nruns
-                                print "  Times  : %10.2f    %10.2f" % ('Total', 'Per run')
-                                print "  User   : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns)
-                                print "  System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns)
-                            twall1 = time.time()
-                            print "Wall time: %10.2f s." % (twall1 - twall0)
+                ndarray_type = ndarray.__name__
+
+        # Find all variable names and types so we can figure out column sizes
+        def get_vars(i):
+            return self.shell.user_ns[i]
+
+        # some types are well known and can be shorter
+        abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
+        def type_name(v):
+            tn = type(v).__name__
+            return abbrevs.get(tn,tn)
+
+        varlist = map(get_vars,varnames)
+
+        typelist = []
+        for vv in varlist:
+            tt = type_name(vv)
 
+            if tt=='instance':
+                typelist.append( abbrevs.get(str(vv.__class__),
+                                             str(vv.__class__)))
                         else:
-                            # regular execution
-                            runner(filename, prog_ns, prog_ns, exit_ignore=exit_ignore)
+                typelist.append(tt)
 
-                if 'i' in opts:
-                    self.shell.user_ns['__name__'] = __name__save
+        # column labels and # of spaces as separator
+        varlabel = 'Variable'
+        typelabel = 'Type'
+        datalabel = 'Data/Info'
+        colsep = 3
+        # variable format strings
+        vformat    = "{0:<{varwidth}}{1:<{typewidth}}"
+        aformat    = "%s: %s elems, type `%s`, %s bytes"
+        # find the size of the columns to format the output nicely
+        varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
+        typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
+        # table header
+        print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
+              ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
+        # and the table itself
+        kb = 1024
+        Mb = 1048576  # kb**2
+        for vname,var,vtype in zip(varnames,varlist,typelist):
+            print vformat.format(vname, vtype, varwidth=varwidth, typewidth=typewidth),
+            if vtype in seq_types:
+                print "n="+str(len(var))
+            elif vtype == ndarray_type:
+                vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
+                if vtype==ndarray_type:
+                    # numpy
+                    vsize  = var.size
+                    vbytes = vsize*var.itemsize
+                    vdtype = var.dtype
+
+                if vbytes < 100000:
+                    print aformat % (vshape,vsize,vdtype,vbytes)
                 else:
-                    # The shell MUST hold a reference to prog_ns so after %run
-                    # exits, the python deletion mechanism doesn't zero it out
-                    # (leaving dangling references).
-                    self.shell.cache_main_mod(prog_ns, filename)
-                    # update IPython interactive namespace
+                    print aformat % (vshape,vsize,vdtype,vbytes),
+                    if vbytes < Mb:
+                        print '(%s kb)' % (vbytes/kb,)
+                    else:
+                        print '(%s Mb)' % (vbytes/Mb,)
+            else:
+                try:
+                    vstr = str(var)
+                except UnicodeEncodeError:
+                    vstr = unicode(var).encode(DEFAULT_ENCODING,
+                                               'backslashreplace')
+                except:
+                    vstr = "<object with id %d (str() failed)>" % id(var)
+                vstr = vstr.replace('\n','\\n')
+                if len(vstr) < 50:
+                    print vstr
+                else:
+                    print vstr[:25] + "<...>" + vstr[-25:]
 
-                    # Some forms of read errors on the file may mean the
-                    # __name__ key was never set; using pop we don't have to
-                    # worry about a possible KeyError.
-                    prog_ns.pop('__name__', None)
+    def magic_reset(self, parameter_s=''):
+        """Resets the namespace by removing all names defined by the user, if
+        called without arguments, or by removing some types of objects, such
+        as everything currently in IPython's In[] and Out[] containers (see
+        the parameters for details).
 
-                    self.shell.user_ns.update(prog_ns)
-        finally:
-            # It's a bit of a mystery why, but __builtins__ can change from
-            # being a module to becoming a dict missing some key data after
-            # %run.  As best I can see, this is NOT something IPython is doing
-            # at all, and similar problems have been reported before:
-            # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
-            # Since this seems to be done by the interpreter itself, the best
-            # we can do is to at least restore __builtins__ for the user on
-            # exit.
-            self.shell.user_ns['__builtins__'] = builtin_mod
+        Parameters
+        ----------
+        -f : force reset without asking for confirmation.
 
-            # Ensure key global structures are restored
-            sys.argv = save_argv
-            if restore_main:
-                sys.modules['__main__'] = restore_main
-            else:
-                # Remove from sys.modules the reference to main_mod we'd
-                # added.  Otherwise it will trap references to objects
-                # contained therein.
-                del sys.modules[main_mod_name]
+        -s : 'Soft' reset: Only clears your namespace, leaving history intact.
+            References to objects may be kept. By default (without this option),
+            we do a 'hard' reset, giving you a new session and removing all
+            references to objects from the current session.
 
-        return stats
+        in : reset input history
 
-    @skip_doctest
-    def magic_timeit(self, parameter_s =''):
-        """Time execution of a Python statement or expression
+        out : reset output history
+
+        dhist : reset directory history
+
+        array : reset only variables that are NumPy arrays
+
+        See Also
+        --------
+        magic_reset_selective : invoked as ``%reset_selective``
+
+        Examples
+        --------
+        ::
+
+          In [6]: a = 1
+
+          In [7]: a
+          Out[7]: 1
+
+          In [8]: 'a' in _ip.user_ns
+          Out[8]: True
+
+          In [9]: %reset -f
+
+          In [1]: 'a' in _ip.user_ns
+          Out[1]: False
+
+          In [2]: %reset -f in
+          Flushing input history
+
+          In [3]: %reset -f dhist in
+          Flushing directory history
+          Flushing input history
+
+        Notes
+        -----
+        Calling this magic from clients that do not implement standard input,
+        such as the ipython notebook interface, will reset the namespace
+        without confirmation.
+        """
+        opts, args = self.parse_options(parameter_s,'sf', mode='list')
+        if 'f' in opts:
+            ans = True
+        else:
+            try:
+                ans = self.shell.ask_yes_no(
+                "Once deleted, variables cannot be recovered. Proceed (y/[n])? ", default='n')
+            except StdinNotImplementedError:
+                ans = True
+        if not ans:
+            print 'Nothing done.'
+            return
+
+        if 's' in opts:                     # Soft reset
+            user_ns = self.shell.user_ns
+            for i in self.magic_who_ls():
+                del(user_ns[i])
+        elif len(args) == 0:                # Hard reset
+            self.shell.reset(new_session = False)
+
+        # reset in/out/dhist/array: previously extensinions/clearcmd.py
+        ip = self.shell
+        user_ns = self.shell.user_ns  # local lookup, heavily used
+
+        for target in args:
+            target = target.lower() # make matches case insensitive
+            if target == 'out':
+                print "Flushing output cache (%d entries)" % len(user_ns['_oh'])
+                self.shell.displayhook.flush()
+
+            elif target == 'in':
+                print "Flushing input history"
+                pc = self.shell.displayhook.prompt_count + 1
+                for n in range(1, pc):
+                    key = '_i'+repr(n)
+                    user_ns.pop(key,None)
+                user_ns.update(dict(_i=u'',_ii=u'',_iii=u''))
+                hm = ip.history_manager
+                # don't delete these, as %save and %macro depending on the length
+                # of these lists to be preserved
+                hm.input_hist_parsed[:] = [''] * pc
+                hm.input_hist_raw[:] = [''] * pc
+                # hm has internal machinery for _i,_ii,_iii, clear it out
+                hm._i = hm._ii = hm._iii = hm._i00 =  u''
+
+            elif target == 'array':
+                # Support cleaning up numpy arrays
+                try:
+                    from numpy import ndarray
+                    # This must be done with items and not iteritems because we're
+                    # going to modify the dict in-place.
+                    for x,val in user_ns.items():
+                        if isinstance(val,ndarray):
+                            del user_ns[x]
+                except ImportError:
+                    print "reset array only works if Numpy is available."
+
+            elif target == 'dhist':
+                print "Flushing directory history"
+                del user_ns['_dh'][:]
+
+            else:
+                print "Don't know how to reset ",
+                print target + ", please run `%reset?` for details"
+
+        gc.collect()
+
+    def magic_reset_selective(self, parameter_s=''):
+        """Resets the namespace by removing names defined by the user.
+
+        Input/Output history are left around in case you need them.
+
+        %reset_selective [-f] regex
+
+        No action is taken if regex is not included
+
+        Options
+          -f : force reset without asking for confirmation.
+
+        See Also
+        --------
+        magic_reset : invoked as ``%reset``
+
+        Examples
+        --------
+
+        We first fully reset the namespace so your output looks identical to
+        this example for pedagogical reasons; in practice you do not need a
+        full reset::
+
+          In [1]: %reset -f
+
+        Now, with a clean namespace we can make a few variables and use
+        ``%reset_selective`` to only delete names that match our regexp::
+
+          In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
+
+          In [3]: who_ls
+          Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
+
+          In [4]: %reset_selective -f b[2-3]m
+
+          In [5]: who_ls
+          Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
+
+          In [6]: %reset_selective -f d
+
+          In [7]: who_ls
+          Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
+
+          In [8]: %reset_selective -f c
+
+          In [9]: who_ls
+          Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
+
+          In [10]: %reset_selective -f b
+
+          In [11]: who_ls
+          Out[11]: ['a']
+
+        Notes
+        -----
+        Calling this magic from clients that do not implement standard input,
+        such as the ipython notebook interface, will reset the namespace
+        without confirmation.
+        """
+
+        opts, regex = self.parse_options(parameter_s,'f')
+
+        if opts.has_key('f'):
+            ans = True
+        else:
+            try:
+                ans = self.shell.ask_yes_no(
+                "Once deleted, variables cannot be recovered. Proceed (y/[n])? ",
+                default='n')
+            except StdinNotImplementedError:
+                ans = True
+        if not ans:
+            print 'Nothing done.'
+            return
+        user_ns = self.shell.user_ns
+        if not regex:
+            print 'No regex pattern specified. Nothing done.'
+            return
+        else:
+            try:
+                m = re.compile(regex)
+            except TypeError:
+                raise TypeError('regex must be a string or compiled pattern')
+            for i in self.magic_who_ls():
+                if m.search(i):
+                    del(user_ns[i])
+
+    def magic_xdel(self, parameter_s=''):
+        """Delete a variable, trying to clear it from anywhere that
+        IPython's machinery has references to it. By default, this uses
+        the identity of the named object in the user namespace to remove
+        references held under other names. The object is also removed
+        from the output history.
+
+        Options
+          -n : Delete the specified name from all namespaces, without
+          checking their identity.
+        """
+        opts, varname = self.parse_options(parameter_s,'n')
+        try:
+            self.shell.del_var(varname, ('n' in opts))
+        except (NameError, ValueError) as e:
+            print type(e).__name__ +": "+ str(e)
+
+
+class ExecutionMagics(MagicFunctions):
+    """Magics related to code execution, debugging, profiling, etc.
+
+    """
+
+    def __init__(self, shell):
+        super(ProfileMagics, self).__init__(shell)
+        if profile is None:
+            self.magic_prun = self.profile_missing_notice
+        # Default execution function used to actually run user code.
+        self.default_runner = None
+
+    def profile_missing_notice(self, *args, **kwargs):
+        error("""\
+The profile module could not be found. It has been removed from the standard
+python packages because of its non-free license. To use profiling, install the
+python-profiler package from non-free.""")
+
+    @skip_doctest
+    def magic_prun(self, parameter_s ='',user_mode=1,
+                   opts=None,arg_lst=None,prog_ns=None):
+
+        """Run a statement through the python code profiler.
+
+        Usage:
+          %prun [options] statement
+
+        The given statement (which doesn't require quote marks) is run via the
+        python profiler in a manner similar to the profile.run() function.
+        Namespaces are internally managed to work correctly; profile.run
+        cannot be used in IPython because it makes certain assumptions about
+        namespaces which do not hold under IPython.
+
+        Options:
+
+        -l <limit>: you can place restrictions on what or how much of the
+        profile gets printed. The limit value can be:
+
+          * A string: only information for function names containing this string
+          is printed.
+
+          * An integer: only these many lines are printed.
+
+          * A float (between 0 and 1): this fraction of the report is printed
+          (for example, use a limit of 0.4 to see the topmost 40% only).
+
+        You can combine several limits with repeated use of the option. For
+        example, '-l __init__ -l 5' will print only the topmost 5 lines of
+        information about class constructors.
+
+        -r: return the pstats.Stats object generated by the profiling. This
+        object has all the information about the profile in it, and you can
+        later use it for further analysis or in other functions.
+
+       -s <key>: sort profile by given key. You can provide more than one key
+        by using the option several times: '-s key1 -s key2 -s key3...'. The
+        default sorting key is 'time'.
+
+        The following is copied verbatim from the profile documentation
+        referenced below:
+
+        When more than one key is provided, additional keys are used as
+        secondary criteria when the there is equality in all keys selected
+        before them.
+
+        Abbreviations can be used for any key names, as long as the
+        abbreviation is unambiguous.  The following are the keys currently
+        defined:
+
+                Valid Arg       Meaning
+                  "calls"      call count
+                  "cumulative" cumulative time
+                  "file"       file name
+                  "module"     file name
+                  "pcalls"     primitive call count
+                  "line"       line number
+                  "name"       function name
+                  "nfl"        name/file/line
+                  "stdname"    standard name
+                  "time"       internal time
+
+        Note that all sorts on statistics are in descending order (placing
+        most time consuming items first), where as name, file, and line number
+        searches are in ascending order (i.e., alphabetical). The subtle
+        distinction between "nfl" and "stdname" is that the standard name is a
+        sort of the name as printed, which means that the embedded line
+        numbers get compared in an odd way.  For example, lines 3, 20, and 40
+        would (if the file names were the same) appear in the string order
+        "20" "3" and "40".  In contrast, "nfl" does a numeric compare of the
+        line numbers.  In fact, sort_stats("nfl") is the same as
+        sort_stats("name", "file", "line").
+
+        -T <filename>: save profile results as shown on screen to a text
+        file. The profile is still shown on screen.
+
+        -D <filename>: save (via dump_stats) profile statistics to given
+        filename. This data is in a format understood by the pstats module, and
+        is generated by a call to the dump_stats() method of profile
+        objects. The profile is still shown on screen.
+
+        -q: suppress output to the pager.  Best used with -T and/or -D above.
+
+        If you want to run complete programs under the profiler's control, use
+        '%run -p [prof_opts] filename.py [args to program]' where prof_opts
+        contains profiler specific options as described here.
+
+        You can read the complete documentation for the profile module with::
+
+          In [1]: import profile; profile.help()
+        """
+
+        opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
+
+        if user_mode:  # regular user call
+            opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:q',
+                                              list_all=1, posix=False)
+            namespace = self.shell.user_ns
+        else:  # called to run a program by %run -p
+            try:
+                filename = get_py_filename(arg_lst[0])
+            except IOError as e:
+                try:
+                    msg = str(e)
+                except UnicodeError:
+                    msg = e.message
+                error(msg)
+                return
+
+            arg_str = 'execfile(filename,prog_ns)'
+            namespace = {
+                'execfile': self.shell.safe_execfile,
+                'prog_ns': prog_ns,
+                'filename': filename
+                }
+
+        opts.merge(opts_def)
+
+        prof = profile.Profile()
+        try:
+            prof = prof.runctx(arg_str,namespace,namespace)
+            sys_exit = ''
+        except SystemExit:
+            sys_exit = """*** SystemExit exception caught in code being profiled."""
+
+        stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
+
+        lims = opts.l
+        if lims:
+            lims = []  # rebuild lims with ints/floats/strings
+            for lim in opts.l:
+                try:
+                    lims.append(int(lim))
+                except ValueError:
+                    try:
+                        lims.append(float(lim))
+                    except ValueError:
+                        lims.append(lim)
+
+        # Trap output.
+        stdout_trap = StringIO()
+
+        if hasattr(stats,'stream'):
+            # In newer versions of python, the stats object has a 'stream'
+            # attribute to write into.
+            stats.stream = stdout_trap
+            stats.print_stats(*lims)
+        else:
+            # For older versions, we manually redirect stdout during printing
+            sys_stdout = sys.stdout
+            try:
+                sys.stdout = stdout_trap
+                stats.print_stats(*lims)
+            finally:
+                sys.stdout = sys_stdout
 
-        Usage:\\
-          %timeit [-n<N> -r<R> [-t|-c]] statement
+        output = stdout_trap.getvalue()
+        output = output.rstrip()
 
-        Time execution of a Python statement or expression using the timeit
-        module.
+        if 'q' not in opts:
+            page.page(output)
+        print sys_exit,
 
-        Options:
-        -n<N>: execute the given statement <N> times in a loop. If this value
-        is not given, a fitting value is chosen.
+        dump_file = opts.D[0]
+        text_file = opts.T[0]
+        if dump_file:
+            dump_file = unquote_filename(dump_file)
+            prof.dump_stats(dump_file)
+            print '\n*** Profile stats marshalled to file',\
+                  `dump_file`+'.',sys_exit
+        if text_file:
+            text_file = unquote_filename(text_file)
+            pfile = open(text_file,'w')
+            pfile.write(output)
+            pfile.close()
+            print '\n*** Profile printout saved to text file',\
+                  `text_file`+'.',sys_exit
 
-        -r<R>: repeat the loop iteration <R> times and take the best result.
-        Default: 3
+        if opts.has_key('r'):
+            return stats
+        else:
+            return None
 
-        -t: use time.time to measure the time, which is the default on Unix.
-        This function measures wall time.
+    def magic_pdb(self, parameter_s=''):
+        """Control the automatic calling of the pdb interactive debugger.
 
-        -c: use time.clock to measure the time, which is the default on
-        Windows and measures wall time. On Unix, resource.getrusage is used
-        instead and returns the CPU user time.
+        Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
+        argument it works as a toggle.
 
-        -p<P>: use a precision of <P> digits to display the timing result.
-        Default: 3
+        When an exception is triggered, IPython can optionally call the
+        interactive pdb debugger after the traceback printout. %pdb toggles
+        this feature on and off.
 
+        The initial state of this feature is set in your configuration
+        file (the option is ``InteractiveShell.pdb``).
 
-        Examples
-        --------
-        ::
+        If you want to just activate the debugger AFTER an exception has fired,
+        without having to type '%pdb on' and rerunning your code, you can use
+        the %debug magic."""
 
-          In [1]: %timeit pass
-          10000000 loops, best of 3: 53.3 ns per loop
+        par = parameter_s.strip().lower()
 
-          In [2]: u = None
+        if par:
+            try:
+                new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
+            except KeyError:
+                print ('Incorrect argument. Use on/1, off/0, '
+                       'or nothing for a toggle.')
+                return
+        else:
+            # toggle
+            new_pdb = not self.shell.call_pdb
 
-          In [3]: %timeit u is None
-          10000000 loops, best of 3: 184 ns per loop
+        # set on the shell
+        self.shell.call_pdb = new_pdb
+        print 'Automatic pdb calling has been turned',on_off(new_pdb)
 
-          In [4]: %timeit -r 4 u == None
-          1000000 loops, best of 4: 242 ns per loop
+    def magic_debug(self, parameter_s=''):
+        """Activate the interactive debugger in post-mortem mode.
 
-          In [5]: import time
+        If an exception has just occurred, this lets you inspect its stack
+        frames interactively.  Note that this will always work only on the last
+        traceback that occurred, so you must call this quickly after an
+        exception that you wish to inspect has fired, because if another one
+        occurs, it clobbers the previous one.
 
-          In [6]: %timeit -n1 time.sleep(2)
-          1 loops, best of 3: 2 s per loop
+        If you want IPython to automatically do this on every exception, see
+        the %pdb magic for more details.
+        """
+        self.shell.debugger(force=True)
 
+    def magic_tb(self, s):
+        """Print the last traceback with the currently active exception mode.
 
-        The times reported by %timeit will be slightly higher than those
-        reported by the timeit.py script when variables are accessed. This is
-        due to the fact that %timeit executes the statement in the namespace
-        of the shell, compared with timeit.py, which uses a single setup
-        statement to import function or create variables. Generally, the bias
-        does not matter as long as results from timeit.py are not mixed with
-        those from %timeit."""
+        See %xmode for changing exception reporting modes."""
+        self.shell.showtraceback()
 
-        import timeit
-        import math
+    @skip_doctest
+    def magic_run(self, parameter_s ='', runner=None,
+                  file_finder=get_py_filename):
+        """Run the named file inside IPython as a program.
 
-        # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
-        # certain terminals.  Until we figure out a robust way of
-        # auto-detecting if the terminal can deal with it, use plain 'us' for
-        # microseconds.  I am really NOT happy about disabling the proper
-        # 'micro' prefix, but crashing is worse... If anyone knows what the
-        # right solution for this is, I'm all ears...
-        #
-        # Note: using
-        #
-        # s = u'\xb5'
-        # s.encode(sys.getdefaultencoding())
-        #
-        # is not sufficient, as I've seen terminals where that fails but
-        # print s
-        #
-        # succeeds
-        #
-        # See bug: https://bugs.launchpad.net/ipython/+bug/348466
+        Usage:\\
+          %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
 
-        #units = [u"s", u"ms",u'\xb5',"ns"]
-        units = [u"s", u"ms",u'us',"ns"]
+        Parameters after the filename are passed as command-line arguments to
+        the program (put in sys.argv). Then, control returns to IPython's
+        prompt.
 
-        scaling = [1, 1e3, 1e6, 1e9]
+        This is similar to running at a system prompt:\\
+          $ python file args\\
+        but with the advantage of giving you IPython's tracebacks, and of
+        loading all variables into your interactive namespace for further use
+        (unless -p is used, see below).
 
-        opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
-                                        posix=False, strict=False)
-        if stmt == "":
-            return
-        timefunc = timeit.default_timer
-        number = int(getattr(opts, "n", 0))
-        repeat = int(getattr(opts, "r", timeit.default_repeat))
-        precision = int(getattr(opts, "p", 3))
-        if hasattr(opts, "t"):
-            timefunc = time.time
-        if hasattr(opts, "c"):
-            timefunc = clock
+        The file is executed in a namespace initially consisting only of
+        __name__=='__main__' and sys.argv constructed as indicated. It thus
+        sees its environment as if it were being run as a stand-alone program
+        (except for sharing global objects such as previously imported
+        modules). But after execution, the IPython interactive namespace gets
+        updated with all variables defined in the program (except for __name__
+        and sys.argv). This allows for very convenient loading of code for
+        interactive work, while giving each program a 'clean sheet' to run in.
 
-        timer = timeit.Timer(timer=timefunc)
-        # this code has tight coupling to the inner workings of timeit.Timer,
-        # but is there a better way to achieve that the code stmt has access
-        # to the shell namespace?
+        Options:
 
-        src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
-                                 'setup': "pass"}
-        # Track compilation time so it can be reported if too long
-        # Minimum time above which compilation time will be reported
-        tc_min = 0.1
+        -n: __name__ is NOT set to '__main__', but to the running file's name
+        without extension (as python does under import).  This allows running
+        scripts and reloading the definitions in them without calling code
+        protected by an ' if __name__ == "__main__" ' clause.
 
-        t0 = clock()
-        code = compile(src, "<magic-timeit>", "exec")
-        tc = clock()-t0
+        -i: run the file in IPython's namespace instead of an empty one. This
+        is useful if you are experimenting with code written in a text editor
+        which depends on variables defined interactively.
 
-        ns = {}
-        exec code in self.shell.user_ns, ns
-        timer.inner = ns["inner"]
+        -e: ignore sys.exit() calls or SystemExit exceptions in the script
+        being run.  This is particularly useful if IPython is being used to
+        run unittests, which always exit with a sys.exit() call.  In such
+        cases you are interested in the output of the test results, not in
+        seeing a traceback of the unittest module.
 
-        if number == 0:
-            # determine number so that 0.2 <= total time < 2.0
-            number = 1
-            for i in range(1, 10):
-                if timer.timeit(number) >= 0.2:
-                    break
-                number *= 10
+        -t: print timing information at the end of the run.  IPython will give
+        you an estimated CPU time consumption for your script, which under
+        Unix uses the resource module to avoid the wraparound problems of
+        time.clock().  Under Unix, an estimate of time spent on system tasks
+        is also given (for Windows platforms this is reported as 0.0).
 
-        best = min(timer.repeat(repeat, number)) / number
+        If -t is given, an additional -N<N> option can be given, where <N>
+        must be an integer indicating how many times you want the script to
+        run.  The final timing report will include total and per run results.
 
-        if best > 0.0 and best < 1000.0:
-            order = min(-int(math.floor(math.log10(best)) // 3), 3)
-        elif best >= 1000.0:
-            order = 0
-        else:
-            order = 3
-        print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
-                                                          precision,
-                                                          best * scaling[order],
-                                                          units[order])
-        if tc > tc_min:
-            print "Compiler time: %.2f s" % tc
+        For example (testing the script uniq_stable.py)::
 
-    @skip_doctest
-    @needs_local_scope
-    def magic_time(self,parameter_s, user_locals):
-        """Time execution of a Python statement or expression.
+            In [1]: run -t uniq_stable
 
-        The CPU and wall clock times are printed, and the value of the
-        expression (if any) is returned.  Note that under Win32, system time
-        is always reported as 0, since it can not be measured.
+            IPython CPU timings (estimated):\\
+              User  :    0.19597 s.\\
+              System:        0.0 s.\\
 
-        This function provides very basic timing functionality.  In Python
-        2.3, the timeit module offers more control and sophistication, so this
-        could be rewritten to use it (patches welcome).
+            In [2]: run -t -N5 uniq_stable
 
-        Examples
-        --------
-        ::
+            IPython CPU timings (estimated):\\
+            Total runs performed: 5\\
+              Times :      Total       Per run\\
+              User  :   0.910862 s,  0.1821724 s.\\
+              System:        0.0 s,        0.0 s.
 
-          In [1]: time 2**128
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00
-          Out[1]: 340282366920938463463374607431768211456L
+        -d: run your program under the control of pdb, the Python debugger.
+        This allows you to execute your program step by step, watch variables,
+        etc.  Internally, what IPython does is similar to calling:
 
-          In [2]: n = 1000000
+          pdb.run('execfile("YOURFILENAME")')
 
-          In [3]: time sum(range(n))
-          CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
-          Wall time: 1.37
-          Out[3]: 499999500000L
+        with a breakpoint set on line 1 of your file.  You can change the line
+        number for this automatic breakpoint to be <N> by using the -bN option
+        (where N must be an integer).  For example::
 
-          In [4]: time print 'hello world'
-          hello world
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00
+          %run -d -b40 myscript
 
-          Note that the time needed by Python to compile the given expression
-          will be reported if it is more than 0.1s.  In this example, the
-          actual exponentiation is done by Python at compilation time, so while
-          the expression can take a noticeable amount of time to compute, that
-          time is purely due to the compilation:
+        will set the first breakpoint at line 40 in myscript.py.  Note that
+        the first breakpoint must be set on a line which actually does
+        something (not a comment or docstring) for it to stop execution.
 
-          In [5]: time 3**9999;
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00 s
+        When the pdb debugger starts, you will see a (Pdb) prompt.  You must
+        first enter 'c' (without quotes) to start execution up to the first
+        breakpoint.
 
-          In [6]: time 3**999999;
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00 s
-          Compiler : 0.78 s
-          """
+        Entering 'help' gives information about the use of the debugger.  You
+        can easily see pdb's full documentation with "import pdb;pdb.help()"
+        at a prompt.
 
-        # fail immediately if the given expression can't be compiled
+        -p: run program under the control of the Python profiler module (which
+        prints a detailed report of execution times, function calls, etc).
 
-        expr = self.shell.prefilter(parameter_s,False)
+        You can pass other options after -p which affect the behavior of the
+        profiler itself. See the docs for %prun for details.
 
-        # Minimum time above which compilation time will be reported
-        tc_min = 0.1
+        In this mode, the program's variables do NOT propagate back to the
+        IPython interactive namespace (because they remain in the namespace
+        where the profiler executes them).
 
-        try:
-            mode = 'eval'
-            t0 = clock()
-            code = compile(expr,'<timed eval>',mode)
-            tc = clock()-t0
-        except SyntaxError:
-            mode = 'exec'
-            t0 = clock()
-            code = compile(expr,'<timed exec>',mode)
-            tc = clock()-t0
-        # skew measurement as little as possible
-        glob = self.shell.user_ns
-        wtime = time.time
-        # time execution
-        wall_st = wtime()
-        if mode=='eval':
-            st = clock2()
-            out = eval(code, glob, user_locals)
-            end = clock2()
-        else:
-            st = clock2()
-            exec code in glob, user_locals
-            end = clock2()
-            out = None
-        wall_end = wtime()
-        # Compute actual times and report
-        wall_time = wall_end-wall_st
-        cpu_user = end[0]-st[0]
-        cpu_sys = end[1]-st[1]
-        cpu_tot = cpu_user+cpu_sys
-        print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
-              (cpu_user,cpu_sys,cpu_tot)
-        print "Wall time: %.2f s" % wall_time
-        if tc > tc_min:
-            print "Compiler : %.2f s" % tc
-        return out
+        Internally this triggers a call to %prun, see its documentation for
+        details on the options available specifically for profiling.
 
-    @skip_doctest
-    def magic_macro(self,parameter_s = ''):
-        """Define a macro for future re-execution. It accepts ranges of history,
-        filenames or string objects.
+        There is one special usage for which the text above doesn't apply:
+        if the filename ends with .ipy, the file is run as ipython script,
+        just as if the commands were written on IPython prompt.
 
-        Usage:\\
-          %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
+        -m: specify module name to load instead of script path. Similar to
+        the -m option for the python interpreter. Use this option last if you
+        want to combine with other %run options. Unlike the python interpreter
+        only source modules are allowed no .pyc or .pyo files.
+        For example::
 
-        Options:
+            %run -m example
 
-          -r: use 'raw' input.  By default, the 'processed' history is used,
-          so that magics are loaded in their transformed version to valid
-          Python.  If this option is given, the raw input as typed as the
-          command line is used instead.
+        will run the example module.
 
-        This will define a global variable called `name` which is a string
-        made of joining the slices and lines you specify (n1,n2,... numbers
-        above) from your input history into a single string. This variable
-        acts like an automatic function which re-executes those lines as if
-        you had typed them. You just type 'name' at the prompt and the code
-        executes.
+        """
 
-        The syntax for indicating input ranges is described in %history.
+        # get arguments and set sys.argv for program to be run.
+        opts, arg_lst = self.parse_options(parameter_s, 'nidtN:b:pD:l:rs:T:em:',
+                                           mode='list', list_all=1)
+        if "m" in opts:
+            modulename = opts["m"][0]
+            modpath = find_mod(modulename)
+            if modpath is None:
+                warn('%r is not a valid modulename on sys.path'%modulename)
+                return
+            arg_lst = [modpath] + arg_lst
+        try:
+            filename = file_finder(arg_lst[0])
+        except IndexError:
+            warn('you must provide at least a filename.')
+            print '\n%run:\n', oinspect.getdoc(self.magic_run)
+            return
+        except IOError as e:
+            try:
+                msg = str(e)
+            except UnicodeError:
+                msg = e.message
+            error(msg)
+            return
 
-        Note: as a 'hidden' feature, you can also use traditional python slice
-        notation, where N:M means numbers N through M-1.
+        if filename.lower().endswith('.ipy'):
+            self.shell.safe_execfile_ipy(filename)
+            return
 
-        For example, if your history contains (%hist prints it)::
+        # Control the response to exit() calls made by the script being run
+        exit_ignore = 'e' in opts
 
-          44: x=1
-          45: y=3
-          46: z=x+y
-          47: print x
-          48: a=5
-          49: print 'x',x,'y',y
+        # Make sure that the running script gets a proper sys.argv as if it
+        # were run from a system shell.
+        save_argv = sys.argv # save it for later restoring
 
-        you can create a macro with lines 44 through 47 (included) and line 49
-        called my_macro with::
+        # simulate shell expansion on arguments, at least tilde expansion
+        args = [ os.path.expanduser(a) for a in arg_lst[1:] ]
 
-          In [55]: %macro my_macro 44-47 49
+        sys.argv = [filename] + args  # put in the proper filename
+        # protect sys.argv from potential unicode strings on Python 2:
+        if not py3compat.PY3:
+            sys.argv = [ py3compat.cast_bytes(a) for a in sys.argv ]
 
-        Now, typing `my_macro` (without quotes) will re-execute all this code
-        in one pass.
+        if 'i' in opts:
+            # Run in user's interactive namespace
+            prog_ns = self.shell.user_ns
+            __name__save = self.shell.user_ns['__name__']
+            prog_ns['__name__'] = '__main__'
+            main_mod = self.shell.new_main_mod(prog_ns)
+        else:
+            # Run in a fresh, empty namespace
+            if 'n' in opts:
+                name = os.path.splitext(os.path.basename(filename))[0]
+            else:
+                name = '__main__'
 
-        You don't need to give the line-numbers in order, and any given line
-        number can appear multiple times. You can assemble macros with any
-        lines from your input history in any order.
+            main_mod = self.shell.new_main_mod()
+            prog_ns = main_mod.__dict__
+            prog_ns['__name__'] = name
 
-        The macro is a simple object which holds its value in an attribute,
-        but IPython's display system checks for macros and executes them as
-        code instead of printing them when you type their name.
+        # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
+        # set the __file__ global in the script's namespace
+        prog_ns['__file__'] = filename
 
-        You can view a macro's contents by explicitly printing it with::
+        # pickle fix.  See interactiveshell for an explanation.  But we need to make sure
+        # that, if we overwrite __main__, we replace it at the end
+        main_mod_name = prog_ns['__name__']
 
-          print macro_name
+        if main_mod_name == '__main__':
+            restore_main = sys.modules['__main__']
+        else:
+            restore_main = False
 
-        """
-        opts,args = self.parse_options(parameter_s,'r',mode='list')
-        if not args:   # List existing macros
-            return sorted(k for k,v in self.shell.user_ns.iteritems() if\
-                                                        isinstance(v, Macro))
-        if len(args) == 1:
-            raise UsageError(
-                "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
-        name, codefrom = args[0], " ".join(args[1:])
+        # This needs to be undone at the end to prevent holding references to
+        # every single object ever created.
+        sys.modules[main_mod_name] = main_mod
 
-        #print 'rng',ranges  # dbg
         try:
-            lines = self.shell.find_user_code(codefrom, 'r' in opts)
-        except (ValueError, TypeError) as e:
-            print e.args[0]
+            stats = None
+            with self.shell.readline_no_record:
+                if 'p' in opts:
+                    stats = self.magic_prun('', 0, opts, arg_lst, prog_ns)
+                else:
+                    if 'd' in opts:
+                        deb = debugger.Pdb(self.shell.colors)
+                        # reset Breakpoint state, which is moronically kept
+                        # in a class
+                        bdb.Breakpoint.next = 1
+                        bdb.Breakpoint.bplist = {}
+                        bdb.Breakpoint.bpbynumber = [None]
+                        # Set an initial breakpoint to stop execution
+                        maxtries = 10
+                        bp = int(opts.get('b', [1])[0])
+                        checkline = deb.checkline(filename, bp)
+                        if not checkline:
+                            for bp in range(bp + 1, bp + maxtries + 1):
+                                if deb.checkline(filename, bp):
+                                    break
+                            else:
+                                msg = ("\nI failed to find a valid line to set "
+                                       "a breakpoint\n"
+                                       "after trying up to line: %s.\n"
+                                       "Please set a valid breakpoint manually "
+                                       "with the -b option." % bp)
+                                error(msg)
+                                return
+                        # if we find a good linenumber, set the breakpoint
+                        deb.do_break('%s:%s' % (filename, bp))
+                        # Start file run
+                        print "NOTE: Enter 'c' at the",
+                        print "%s prompt to start your script." % deb.prompt
+                        ns = {'execfile': py3compat.execfile, 'prog_ns': prog_ns}
+                        try:
+                            deb.run('execfile("%s", prog_ns)' % filename, ns)
+
+                        except:
+                            etype, value, tb = sys.exc_info()
+                            # Skip three frames in the traceback: the %run one,
+                            # one inside bdb.py, and the command-line typed by the
+                            # user (run by exec in pdb itself).
+                            self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
+                    else:
+                        if runner is None:
+                            runner = self.default_runner
+                        if runner is None:
+                            runner = self.shell.safe_execfile
+                        if 't' in opts:
+                            # timed execution
+                            try:
+                                nruns = int(opts['N'][0])
+                                if nruns < 1:
+                                    error('Number of runs must be >=1')
             return
-        macro = Macro(lines)
-        self.shell.define_macro(name, macro)
-        print 'Macro `%s` created. To execute, type its name (without quotes).' % name
-        print '=== Macro contents: ==='
-        print macro,
-
-    def magic_save(self,parameter_s = ''):
-        """Save a set of lines or a macro to a given filename.
+                            except (KeyError):
+                                nruns = 1
+                            twall0 = time.time()
+                            if nruns == 1:
+                                t0 = clock2()
+                                runner(filename, prog_ns, prog_ns,
+                                       exit_ignore=exit_ignore)
+                                t1 = clock2()
+                                t_usr = t1[0] - t0[0]
+                                t_sys = t1[1] - t0[1]
+                                print "\nIPython CPU timings (estimated):"
+                                print "  User   : %10.2f s." % t_usr
+                                print "  System : %10.2f s." % t_sys
+                            else:
+                                runs = range(nruns)
+                                t0 = clock2()
+                                for nr in runs:
+                                    runner(filename, prog_ns, prog_ns,
+                                           exit_ignore=exit_ignore)
+                                t1 = clock2()
+                                t_usr = t1[0] - t0[0]
+                                t_sys = t1[1] - t0[1]
+                                print "\nIPython CPU timings (estimated):"
+                                print "Total runs performed:", nruns
+                                print "  Times  : %10.2f    %10.2f" % ('Total', 'Per run')
+                                print "  User   : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns)
+                                print "  System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns)
+                            twall1 = time.time()
+                            print "Wall time: %10.2f s." % (twall1 - twall0)
 
-        Usage:\\
-          %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
+                        else:
+                            # regular execution
+                            runner(filename, prog_ns, prog_ns, exit_ignore=exit_ignore)
 
-        Options:
+                if 'i' in opts:
+                    self.shell.user_ns['__name__'] = __name__save
+                else:
+                    # The shell MUST hold a reference to prog_ns so after %run
+                    # exits, the python deletion mechanism doesn't zero it out
+                    # (leaving dangling references).
+                    self.shell.cache_main_mod(prog_ns, filename)
+                    # update IPython interactive namespace
 
-          -r: use 'raw' input.  By default, the 'processed' history is used,
-          so that magics are loaded in their transformed version to valid
-          Python.  If this option is given, the raw input as typed as the
-          command line is used instead.
+                    # Some forms of read errors on the file may mean the
+                    # __name__ key was never set; using pop we don't have to
+                    # worry about a possible KeyError.
+                    prog_ns.pop('__name__', None)
 
-        This function uses the same syntax as %history for input ranges,
-        then saves the lines to the filename you specify.
+                    self.shell.user_ns.update(prog_ns)
+        finally:
+            # It's a bit of a mystery why, but __builtins__ can change from
+            # being a module to becoming a dict missing some key data after
+            # %run.  As best I can see, this is NOT something IPython is doing
+            # at all, and similar problems have been reported before:
+            # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
+            # Since this seems to be done by the interpreter itself, the best
+            # we can do is to at least restore __builtins__ for the user on
+            # exit.
+            self.shell.user_ns['__builtins__'] = builtin_mod
 
-        It adds a '.py' extension to the file if you don't do so yourself, and
-        it asks for confirmation before overwriting existing files."""
+            # Ensure key global structures are restored
+            sys.argv = save_argv
+            if restore_main:
+                sys.modules['__main__'] = restore_main
+            else:
+                # Remove from sys.modules the reference to main_mod we'd
+                # added.  Otherwise it will trap references to objects
+                # contained therein.
+                del sys.modules[main_mod_name]
 
-        opts,args = self.parse_options(parameter_s,'r',mode='list')
-        fname, codefrom = unquote_filename(args[0]), " ".join(args[1:])
-        if not fname.endswith('.py'):
-            fname += '.py'
-        if os.path.isfile(fname):
-            overwrite = self.shell.ask_yes_no('File `%s` exists. Overwrite (y/[N])? ' % fname, default='n')
-            if not overwrite :
-                print 'Operation cancelled.'
-                return
-        try:
-            cmds = self.shell.find_user_code(codefrom, 'r' in opts)
-        except (TypeError, ValueError) as e:
-            print e.args[0]
-            return
-        with io.open(fname,'w', encoding="utf-8") as f:
-            f.write(u"# coding: utf-8\n")
-            f.write(py3compat.cast_unicode(cmds))
-        print 'The following commands were written to file `%s`:' % fname
-        print cmds
+        return stats
 
-    def magic_pastebin(self, parameter_s = ''):
-        """Upload code to Github's Gist paste bin, returning the URL.
+    @skip_doctest
+    def magic_timeit(self, parameter_s =''):
+        """Time execution of a Python statement or expression
         
         Usage:\\
-          %pastebin [-d "Custom description"] 1-7
+          %timeit [-n<N> -r<R> [-t|-c]] statement
           
-        The argument can be an input history range, a filename, or the name of a
-        string or macro.
+        Time execution of a Python statement or expression using the timeit
+        module.
         
         Options:
+        -n<N>: execute the given statement <N> times in a loop. If this value
+        is not given, a fitting value is chosen.
         
-          -d: Pass a custom description for the gist. The default will say
-              "Pasted from IPython".
-        """
-        opts, args = self.parse_options(parameter_s, 'd:')
-        
-        try:
-            code = self.shell.find_user_code(args)
-        except (ValueError, TypeError) as e:
-            print e.args[0]
-            return
-        
-        post_data = json.dumps({
-          "description": opts.get('d', "Pasted from IPython"),
-          "public": True,
-          "files": {
-            "file1.py": {
-              "content": code
-            }
-          }
-        }).encode('utf-8')
-        
-        response = urlopen("https://api.github.com/gists", post_data)
-        response_data = json.loads(response.read().decode('utf-8'))
-        return response_data['html_url']
-
-    def magic_loadpy(self, arg_s):
-        """Alias of `%load`
+        -r<R>: repeat the loop iteration <R> times and take the best result.
+        Default: 3
         
-        `%loadpy` has gained some flexibility and droped the requirement of a `.py`
-        extension. So it has been renamed simply into %load. You can look at
-        `%load`'s docstring for more info.
-        """
-        self.magic_load(arg_s)
+        -t: use time.time to measure the time, which is the default on Unix.
+        This function measures wall time.
 
-    def magic_load(self, arg_s):
-        """Load code into the current frontend.
+        -c: use time.clock to measure the time, which is the default on
+        Windows and measures wall time. On Unix, resource.getrusage is used
+        instead and returns the CPU user time.
 
-        Usage:\\
-          %load [options] source
+        -p<P>: use a precision of <P> digits to display the timing result.
+        Default: 3
 
-          where source can be a filename, URL, input history range or macro
 
-        Options:
+        Examples
         --------
-          -y : Don't ask confirmation for loading source above 200 000 characters.
-
-        This magic command can either take a local filename, a URL, an history
-        range (see %history) or a macro as argument, it will prompt for
-        confirmation before loading source with more than 200 000 characters, unless
-        -y flag is passed or if the frontend does not support raw_input::
-
-        %load myscript.py
-        %load 7-27
-        %load myMacro
-        %load http://www.example.com/myscript.py
-        """
-        opts,args = self.parse_options(arg_s,'y')
-
-        contents = self.shell.find_user_code(args)
-        l = len(contents)
-
-        # 200 000 is ~ 2500 full 80 caracter lines
-        # so in average, more than 5000 lines
-        if l > 200000 and 'y' not in opts:
-            try:
-                ans = self.shell.ask_yes_no(("The text you're trying to load seems pretty big"\
-                " (%d characters). Continue (y/[N]) ?" % l), default='n' )
-            except StdinNotImplementedError:
-                #asume yes if raw input not implemented
-                ans = True
-
-            if ans is False :
-                print 'Operation cancelled.'
-                return
+        ::
 
-        self.set_next_input(contents)
+          In [1]: %timeit pass
+          10000000 loops, best of 3: 53.3 ns per loop
 
-    def _find_edit_target(self, args, opts, last_call):
-        """Utility method used by magic_edit to find what to edit."""
+          In [2]: u = None
 
-        def make_filename(arg):
-            "Make a filename from the given args"
-            arg = unquote_filename(arg)
-            try:
-                filename = get_py_filename(arg)
-            except IOError:
-                # If it ends with .py but doesn't already exist, assume we want
-                # a new file.
-                if arg.endswith('.py'):
-                    filename = arg
-                else:
-                    filename = None
-            return filename
+          In [3]: %timeit u is None
+          10000000 loops, best of 3: 184 ns per loop
 
-        # Set a few locals from the options for convenience:
-        opts_prev = 'p' in opts
-        opts_raw = 'r' in opts
+          In [4]: %timeit -r 4 u == None
+          1000000 loops, best of 4: 242 ns per loop
 
-        # custom exceptions
-        class DataIsObject(Exception): pass
+          In [5]: import time
 
-        # Default line number value
-        lineno = opts.get('n',None)
+          In [6]: %timeit -n1 time.sleep(2)
+          1 loops, best of 3: 2 s per loop
 
-        if opts_prev:
-            args = '_%s' % last_call[0]
-            if not self.shell.user_ns.has_key(args):
-                args = last_call[1]
 
-        # use last_call to remember the state of the previous call, but don't
-        # let it be clobbered by successive '-p' calls.
-        try:
-            last_call[0] = self.shell.displayhook.prompt_count
-            if not opts_prev:
-                last_call[1] = args
-        except:
-            pass
+        The times reported by %timeit will be slightly higher than those
+        reported by the timeit.py script when variables are accessed. This is
+        due to the fact that %timeit executes the statement in the namespace
+        of the shell, compared with timeit.py, which uses a single setup
+        statement to import function or create variables. Generally, the bias
+        does not matter as long as results from timeit.py are not mixed with
+        those from %timeit."""
 
-        # by default this is done with temp files, except when the given
-        # arg is a filename
-        use_temp = True
+        import timeit
+        import math
 
-        data = ''
+        # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
+        # certain terminals.  Until we figure out a robust way of
+        # auto-detecting if the terminal can deal with it, use plain 'us' for
+        # microseconds.  I am really NOT happy about disabling the proper
+        # 'micro' prefix, but crashing is worse... If anyone knows what the
+        # right solution for this is, I'm all ears...
+        #
+        # Note: using
+        #
+        # s = u'\xb5'
+        # s.encode(sys.getdefaultencoding())
+        #
+        # is not sufficient, as I've seen terminals where that fails but
+        # print s
+        #
+        # succeeds
+        #
+        # See bug: https://bugs.launchpad.net/ipython/+bug/348466
 
-        # First, see if the arguments should be a filename.
-        filename = make_filename(args)
-        if filename:
-            use_temp = False
-        elif args:
-            # Mode where user specifies ranges of lines, like in %macro.
-            data = self.shell.extract_input_lines(args, opts_raw)
-            if not data:
-                try:
-                    # Load the parameter given as a variable. If not a string,
-                    # process it as an object instead (below)
+        #units = [u"s", u"ms",u'\xb5',"ns"]
+        units = [u"s", u"ms",u'us',"ns"]
 
-                    #print '*** args',args,'type',type(args)  # dbg
-                    data = eval(args, self.shell.user_ns)
-                    if not isinstance(data, basestring):
-                        raise DataIsObject
+        scaling = [1, 1e3, 1e6, 1e9]
 
-                except (NameError,SyntaxError):
-                    # given argument is not a variable, try as a filename
-                    filename = make_filename(args)
-                    if filename is None:
-                        warn("Argument given (%s) can't be found as a variable "
-                             "or as a filename." % args)
+        opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
+                                        posix=False, strict=False)
+        if stmt == "":
                         return
-                    use_temp = False
-
-                except DataIsObject:
-                    # macros have a special edit function
-                    if isinstance(data, Macro):
-                        raise MacroToEdit(data)
+        timefunc = timeit.default_timer
+        number = int(getattr(opts, "n", 0))
+        repeat = int(getattr(opts, "r", timeit.default_repeat))
+        precision = int(getattr(opts, "p", 3))
+        if hasattr(opts, "t"):
+            timefunc = time.time
+        if hasattr(opts, "c"):
+            timefunc = clock
 
-                    # For objects, try to edit the file where they are defined
-                    try:
-                        filename = inspect.getabsfile(data)
-                        if 'fakemodule' in filename.lower() and inspect.isclass(data):
-                            # class created by %edit? Try to find source
-                            # by looking for method definitions instead, the
-                            # __module__ in those classes is FakeModule.
-                            attrs = [getattr(data, aname) for aname in dir(data)]
-                            for attr in attrs:
-                                if not inspect.ismethod(attr):
-                                    continue
-                                filename = inspect.getabsfile(attr)
-                                if filename and 'fakemodule' not in filename.lower():
-                                    # change the attribute to be the edit target instead
-                                    data = attr
-                                    break
+        timer = timeit.Timer(timer=timefunc)
+        # this code has tight coupling to the inner workings of timeit.Timer,
+        # but is there a better way to achieve that the code stmt has access
+        # to the shell namespace?
 
-                        datafile = 1
-                    except TypeError:
-                        filename = make_filename(args)
-                        datafile = 1
-                        warn('Could not find file where `%s` is defined.\n'
-                             'Opening a file named `%s`' % (args,filename))
-                    # Now, make sure we can actually read the source (if it was in
-                    # a temp file it's gone by now).
-                    if datafile:
-                        try:
-                            if lineno is None:
-                                lineno = inspect.getsourcelines(data)[1]
-                        except IOError:
-                            filename = make_filename(args)
-                            if filename is None:
-                                warn('The file `%s` where `%s` was defined cannot '
-                                     'be read.' % (filename,data))
-                                return
-                    use_temp = False
+        src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
+                                 'setup': "pass"}
+        # Track compilation time so it can be reported if too long
+        # Minimum time above which compilation time will be reported
+        tc_min = 0.1
 
-        if use_temp:
-            filename = self.shell.mktempfile(data)
-            print 'IPython will make a temporary file named:',filename
+        t0 = clock()
+        code = compile(src, "<magic-timeit>", "exec")
+        tc = clock()-t0
 
-        return filename, lineno, use_temp
+        ns = {}
+        exec code in self.shell.user_ns, ns
+        timer.inner = ns["inner"]
 
-    def _edit_macro(self,mname,macro):
-        """open an editor with the macro data in a file"""
-        filename = self.shell.mktempfile(macro.value)
-        self.shell.hooks.editor(filename)
+        if number == 0:
+            # determine number so that 0.2 <= total time < 2.0
+            number = 1
+            for i in range(1, 10):
+                if timer.timeit(number) >= 0.2:
+                    break
+                number *= 10
 
-        # and make a new macro object, to replace the old one
-        mfile = open(filename)
-        mvalue = mfile.read()
-        mfile.close()
-        self.shell.user_ns[mname] = Macro(mvalue)
+        best = min(timer.repeat(repeat, number)) / number
 
-    def magic_ed(self,parameter_s=''):
-        """Alias to %edit."""
-        return self.magic_edit(parameter_s)
+        if best > 0.0 and best < 1000.0:
+            order = min(-int(math.floor(math.log10(best)) // 3), 3)
+        elif best >= 1000.0:
+            order = 0
+        else:
+            order = 3
+        print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
+                                                          precision,
+                                                          best * scaling[order],
+                                                          units[order])
+        if tc > tc_min:
+            print "Compiler time: %.2f s" % tc
 
     @skip_doctest
-    def magic_edit(self,parameter_s='',last_call=['','']):
-        """Bring up an editor and execute the resulting code.
-
-        Usage:
-          %edit [options] [args]
-
-        %edit runs IPython's editor hook. The default version of this hook is
-        set to call the editor specified by your $EDITOR environment variable.
-        If this isn't found, it will default to vi under Linux/Unix and to
-        notepad under Windows. See the end of this docstring for how to change
-        the editor hook.
-
-        You can also set the value of this editor via the
-        ``TerminalInteractiveShell.editor`` option in your configuration file.
-        This is useful if you wish to use a different editor from your typical
-        default with IPython (and for Windows users who typically don't set
-        environment variables).
+    @needs_local_scope
+    def magic_time(self,parameter_s, user_locals):
+        """Time execution of a Python statement or expression.
 
-        This command allows you to conveniently edit multi-line code right in
-        your IPython session.
+        The CPU and wall clock times are printed, and the value of the
+        expression (if any) is returned.  Note that under Win32, system time
+        is always reported as 0, since it can not be measured.
 
-        If called without arguments, %edit opens up an empty editor with a
-        temporary file and will execute the contents of this file when you
-        close it (don't forget to save it!).
+        This function provides very basic timing functionality.  In Python
+        2.3, the timeit module offers more control and sophistication, so this
+        could be rewritten to use it (patches welcome).
 
+        Examples
+        --------
+        ::
 
-        Options:
+          In [1]: time 2**128
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00
+          Out[1]: 340282366920938463463374607431768211456L
 
-        -n <number>: open the editor at a specified line number.  By default,
-        the IPython editor hook uses the unix syntax 'editor +N filename', but
-        you can configure this by providing your own modified hook if your
-        favorite editor supports line-number specifications with a different
-        syntax.
+          In [2]: n = 1000000
 
-        -p: this will call the editor with the same data as the previous time
-        it was used, regardless of how long ago (in your current session) it
-        was.
+          In [3]: time sum(range(n))
+          CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
+          Wall time: 1.37
+          Out[3]: 499999500000L
 
-        -r: use 'raw' input.  This option only applies to input taken from the
-        user's history.  By default, the 'processed' history is used, so that
-        magics are loaded in their transformed version to valid Python.  If
-        this option is given, the raw input as typed as the command line is
-        used instead.  When you exit the editor, it will be executed by
-        IPython's own processor.
+          In [4]: time print 'hello world'
+          hello world
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00
 
-        -x: do not execute the edited code immediately upon exit. This is
-        mainly useful if you are editing programs which need to be called with
-        command line arguments, which you can then do using %run.
+          Note that the time needed by Python to compile the given expression
+          will be reported if it is more than 0.1s.  In this example, the
+          actual exponentiation is done by Python at compilation time, so while
+          the expression can take a noticeable amount of time to compute, that
+          time is purely due to the compilation:
 
+          In [5]: time 3**9999;
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00 s
 
-        Arguments:
+          In [6]: time 3**999999;
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00 s
+          Compiler : 0.78 s
+          """
 
-        If arguments are given, the following possibilities exist:
+        # fail immediately if the given expression can't be compiled
 
-        - If the argument is a filename, IPython will load that into the
-          editor. It will execute its contents with execfile() when you exit,
-          loading any code in the file into your interactive namespace.
+        expr = self.shell.prefilter(parameter_s,False)
 
-        - The arguments are ranges of input history,  e.g. "7 ~1/4-6".
-          The syntax is the same as in the %history magic.
+        # Minimum time above which compilation time will be reported
+        tc_min = 0.1
 
-        - If the argument is a string variable, its contents are loaded
-          into the editor. You can thus edit any string which contains
-          python code (including the result of previous edits).
+        try:
+            mode = 'eval'
+            t0 = clock()
+            code = compile(expr,'<timed eval>',mode)
+            tc = clock()-t0
+        except SyntaxError:
+            mode = 'exec'
+            t0 = clock()
+            code = compile(expr,'<timed exec>',mode)
+            tc = clock()-t0
+        # skew measurement as little as possible
+        glob = self.shell.user_ns
+        wtime = time.time
+        # time execution
+        wall_st = wtime()
+        if mode=='eval':
+            st = clock2()
+            out = eval(code, glob, user_locals)
+            end = clock2()
+        else:
+            st = clock2()
+            exec code in glob, user_locals
+            end = clock2()
+            out = None
+        wall_end = wtime()
+        # Compute actual times and report
+        wall_time = wall_end-wall_st
+        cpu_user = end[0]-st[0]
+        cpu_sys = end[1]-st[1]
+        cpu_tot = cpu_user+cpu_sys
+        print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
+              (cpu_user,cpu_sys,cpu_tot)
+        print "Wall time: %.2f s" % wall_time
+        if tc > tc_min:
+            print "Compiler : %.2f s" % tc
+        return out
 
-        - If the argument is the name of an object (other than a string),
-          IPython will try to locate the file where it was defined and open the
-          editor at the point where it is defined. You can use `%edit function`
-          to load an editor exactly at the point where 'function' is defined,
-          edit it and have the file be executed automatically.
+    @skip_doctest
+    def magic_macro(self,parameter_s = ''):
+        """Define a macro for future re-execution. It accepts ranges of history,
+        filenames or string objects.
 
-        - If the object is a macro (see %macro for details), this opens up your
-          specified editor with a temporary file containing the macro's data.
-          Upon exit, the macro is reloaded with the contents of the file.
+        Usage:\\
+          %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
 
-        Note: opening at an exact line is only supported under Unix, and some
-        editors (like kedit and gedit up to Gnome 2.8) do not understand the
-        '+NUMBER' parameter necessary for this feature. Good editors like
-        (X)Emacs, vi, jed, pico and joe all do.
+        Options:
 
-        After executing your code, %edit will return as output the code you
-        typed in the editor (except when it was an existing file). This way
-        you can reload the code in further invocations of %edit as a variable,
-        via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
-        the output.
+          -r: use 'raw' input.  By default, the 'processed' history is used,
+          so that magics are loaded in their transformed version to valid
+          Python.  If this option is given, the raw input as typed as the
+          command line is used instead.
 
-        Note that %edit is also available through the alias %ed.
+        This will define a global variable called `name` which is a string
+        made of joining the slices and lines you specify (n1,n2,... numbers
+        above) from your input history into a single string. This variable
+        acts like an automatic function which re-executes those lines as if
+        you had typed them. You just type 'name' at the prompt and the code
+        executes.
 
-        This is an example of creating a simple function inside the editor and
-        then modifying it. First, start up the editor::
+        The syntax for indicating input ranges is described in %history.
 
-          In [1]: ed
-          Editing... done. Executing edited code...
-          Out[1]: 'def foo():\\n    print "foo() was defined in an editing
-          session"\\n'
+        Note: as a 'hidden' feature, you can also use traditional python slice
+        notation, where N:M means numbers N through M-1.
 
-        We can then call the function foo()::
+        For example, if your history contains (%hist prints it)::
 
-          In [2]: foo()
-          foo() was defined in an editing session
+          44: x=1
+          45: y=3
+          46: z=x+y
+          47: print x
+          48: a=5
+          49: print 'x',x,'y',y
 
-        Now we edit foo.  IPython automatically loads the editor with the
-        (temporary) file where foo() was previously defined::
+        you can create a macro with lines 44 through 47 (included) and line 49
+        called my_macro with::
 
-          In [3]: ed foo
-          Editing... done. Executing edited code...
+          In [55]: %macro my_macro 44-47 49
 
-        And if we call foo() again we get the modified version::
+        Now, typing `my_macro` (without quotes) will re-execute all this code
+        in one pass.
 
-          In [4]: foo()
-          foo() has now been changed!
+        You don't need to give the line-numbers in order, and any given line
+        number can appear multiple times. You can assemble macros with any
+        lines from your input history in any order.
 
-        Here is an example of how to edit a code snippet successive
-        times. First we call the editor::
+        The macro is a simple object which holds its value in an attribute,
+        but IPython's display system checks for macros and executes them as
+        code instead of printing them when you type their name.
 
-          In [5]: ed
-          Editing... done. Executing edited code...
-          hello
-          Out[5]: "print 'hello'\\n"
+        You can view a macro's contents by explicitly printing it with::
 
-        Now we call it again with the previous output (stored in _)::
+          print macro_name
 
-          In [6]: ed _
-          Editing... done. Executing edited code...
-          hello world
-          Out[6]: "print 'hello world'\\n"
+        """
+        opts,args = self.parse_options(parameter_s,'r',mode='list')
+        if not args:   # List existing macros
+            return sorted(k for k,v in self.shell.user_ns.iteritems() if\
+                                                        isinstance(v, Macro))
+        if len(args) == 1:
+            raise UsageError(
+                "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
+        name, codefrom = args[0], " ".join(args[1:])
 
-        Now we call it with the output #8 (stored in _8, also as Out[8])::
+        #print 'rng',ranges  # dbg
+        try:
+            lines = self.shell.find_user_code(codefrom, 'r' in opts)
+        except (ValueError, TypeError) as e:
+            print e.args[0]
+            return
+        macro = Macro(lines)
+        self.shell.define_macro(name, macro)
+        print 'Macro `%s` created. To execute, type its name (without quotes).' % name
+        print '=== Macro contents: ==='
+        print macro,
 
-          In [7]: ed _8
-          Editing... done. Executing edited code...
-          hello again
-          Out[7]: "print 'hello again'\\n"
 
+class AutoMagics(MagicFunctions):
+    """Magics that control various autoX behaviors."""
 
-        Changing the default editor hook:
+    def __init__(self, shell):
+        super(ProfileMagics, self).__init__(shell)
+        # namespace for holding state we may need
+        self._magic_state = Bunch()
 
-        If you wish to write your own editor hook, you can put it in a
-        configuration file which you load at startup time.  The default hook
-        is defined in the IPython.core.hooks module, and you can use that as a
-        starting example for further modifications.  That file also has
-        general instructions on how to set a new hook for use once you've
-        defined it."""
-        opts,args = self.parse_options(parameter_s,'prxn:')
+    def magic_automagic(self, parameter_s = ''):
+        """Make magic functions callable without having to type the initial %.
 
-        try:
-            filename, lineno, is_temp = self._find_edit_target(args, opts, last_call)
-        except MacroToEdit as e:
-            self._edit_macro(args, e.args[0])
-            return
+        Without argumentsl toggles on/off (when off, you must call it as
+        %automagic, of course).  With arguments it sets the value, and you can
+        use any of (case insensitive):
 
-        # do actual editing here
-        print 'Editing...',
-        sys.stdout.flush()
-        try:
-            # Quote filenames that may have spaces in them
-            if ' ' in filename:
-                filename = "'%s'" % filename
-            self.shell.hooks.editor(filename,lineno)
-        except TryNext:
-            warn('Could not open editor')
-            return
+         - on,1,True: to activate
 
-        # XXX TODO: should this be generalized for all string vars?
-        # For now, this is special-cased to blocks created by cpaste
-        if args.strip() == 'pasted_block':
-            self.shell.user_ns['pasted_block'] = file_read(filename)
+         - off,0,False: to deactivate.
 
-        if 'x' in opts:  # -x prevents actual execution
-            print
-        else:
-            print 'done. Executing edited code...'
-            if 'r' in opts:    # Untranslated IPython code
-                self.shell.run_cell(file_read(filename),
-                                                    store_history=False)
-            else:
-                self.shell.safe_execfile(filename, self.shell.user_ns,
-                                         self.shell.user_ns)
+        Note that magic functions have lowest priority, so if there's a
+        variable whose name collides with that of a magic fn, automagic won't
+        work for that function (you get the variable instead). However, if you
+        delete the variable (del var), the previously shadowed magic function
+        becomes visible to automagic again."""
 
-        if is_temp:
-            try:
-                return open(filename).read()
-            except IOError,msg:
-                if msg.filename == filename:
-                    warn('File not found. Did you forget to save?')
-                    return
+        arg = parameter_s.lower()
+        if parameter_s in ('on','1','true'):
+            self.shell.automagic = True
+        elif parameter_s in ('off','0','false'):
+            self.shell.automagic = False
                 else:
-                    self.shell.showtraceback()
-
-    def magic_xmode(self,parameter_s = ''):
-        """Switch modes for the exception handlers.
+            self.shell.automagic = not self.shell.automagic
+        print '\n' + Magic.auto_status[self.shell.automagic]
 
-        Valid modes: Plain, Context and Verbose.
+    @skip_doctest
+    def magic_autocall(self, parameter_s = ''):
+        """Make functions callable without having to type parentheses.
 
-        If called without arguments, acts as a toggle."""
+        Usage:
 
-        def xmode_switch_err(name):
-            warn('Error changing %s exception modes.\n%s' %
-                 (name,sys.exc_info()[1]))
+           %autocall [mode]
 
-        shell = self.shell
-        new_mode = parameter_s.strip().capitalize()
-        try:
-            shell.InteractiveTB.set_mode(mode=new_mode)
-            print 'Exception reporting mode:',shell.InteractiveTB.mode
-        except:
-            xmode_switch_err('user')
+        The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the
+        value is toggled on and off (remembering the previous state).
 
-    def magic_colors(self,parameter_s = ''):
-        """Switch color scheme for prompts, info system and exception handlers.
+        In more detail, these values mean:
 
-        Currently implemented schemes: NoColor, Linux, LightBG.
+        0 -> fully disabled
 
-        Color scheme names are not case-sensitive.
+        1 -> active, but do not apply if there are no arguments on the line.
 
-        Examples
-        --------
-        To get a plain black and white terminal::
+        In this mode, you get::
 
-          %colors nocolor
-        """
+          In [1]: callable
+          Out[1]: <built-in function callable>
 
-        def color_switch_err(name):
-            warn('Error changing %s color schemes.\n%s' %
-                 (name,sys.exc_info()[1]))
+          In [2]: callable 'hello'
+          ------> callable('hello')
+          Out[2]: False
 
+        2 -> Active always.  Even if no arguments are present, the callable
+        object is called::
 
-        new_scheme = parameter_s.strip()
-        if not new_scheme:
-            raise UsageError(
-                "%colors: you must specify a color scheme. See '%colors?'")
-            return
-        # local shortcut
-        shell = self.shell
+          In [2]: float
+          ------> float()
+          Out[2]: 0.0
 
-        import IPython.utils.rlineimpl as readline
+        Note that even with autocall off, you can still use '/' at the start of
+        a line to treat the first argument on the command line as a function
+        and add parentheses to it::
 
-        if not shell.colors_force and \
-                not readline.have_readline and sys.platform == "win32":
-            msg = """\
-Proper color support under MS Windows requires the pyreadline library.
-You can find it at:
-http://ipython.org/pyreadline.html
-Gary's readline needs the ctypes module, from:
-http://starship.python.net/crew/theller/ctypes
-(Note that ctypes is already part of Python versions 2.5 and newer).
+          In [8]: /str 43
+          ------> str(43)
+          Out[8]: '43'
 
-Defaulting color scheme to 'NoColor'"""
-            new_scheme = 'NoColor'
-            warn(msg)
+        # all-random (note for auto-testing)
+        """
 
-        # readline option is 0
-        if not shell.colors_force and not shell.has_readline:
-            new_scheme = 'NoColor'
+        if parameter_s:
+            arg = int(parameter_s)
+        else:
+            arg = 'toggle'
 
-        # Set prompt colors
-        try:
-            shell.prompt_manager.color_scheme = new_scheme
-        except:
-            color_switch_err('prompt')
+        if not arg in (0,1,2,'toggle'):
+            error('Valid modes: (0->Off, 1->Smart, 2->Full')
+            return
+
+        if arg in (0,1,2):
+            self.shell.autocall = arg
+        else: # toggle
+            if self.shell.autocall:
+                self._magic_state.autocall_save = self.shell.autocall
+                self.shell.autocall = 0
         else:
-            shell.colors = \
-                   shell.prompt_manager.color_scheme_table.active_scheme_name
-        # Set exception colors
         try:
-            shell.InteractiveTB.set_colors(scheme = new_scheme)
-            shell.SyntaxTB.set_colors(scheme = new_scheme)
-        except:
-            color_switch_err('exception')
+                    self.shell.autocall = self._magic_state.autocall_save
+                except AttributeError:
+                    self.shell.autocall = self._magic_state.autocall_save = 1
 
-        # Set info (for 'object?') colors
-        if shell.color_info:
-            try:
-                shell.inspector.set_active_scheme(new_scheme)
-            except:
-                color_switch_err('object inspector')
-        else:
-            shell.inspector.set_active_scheme('NoColor')
+        print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
 
-    def magic_pprint(self, parameter_s=''):
-        """Toggle pretty printing on/off."""
-        ptformatter = self.shell.display_formatter.formatters['text/plain']
-        ptformatter.pprint = bool(1 - ptformatter.pprint)
-        print 'Pretty printing has been turned', \
-              ['OFF','ON'][ptformatter.pprint]
 
-    #......................................................................
-    # Functions to implement unix shell-type things
+class OSMagics(MagicFunctions):
+    """Magics to interact with the underlying OS (shell-type functionality).
+    """
 
     @skip_doctest
     def magic_alias(self, parameter_s = ''):
@@ -3345,133 +3614,146 b' Defaulting color scheme to \'NoColor\'"""'
 
         page.page(self.shell.pycolorize(cont))
 
-    def magic_quickref(self,arg):
-        """ Show a quick reference sheet """
-        import IPython.core.usage
-        qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
 
-        page.page(qr)
+class LoggingMagics(MagicFunctions):
+    """Magics related to all logging machinery."""
+    def magic_logstart(self,parameter_s=''):
+        """Start logging anywhere in a session.
 
-    def magic_doctest_mode(self,parameter_s=''):
-        """Toggle doctest mode on and off.
+        %logstart [-o|-r|-t] [log_name [log_mode]]
 
-        This mode is intended to make IPython behave as much as possible like a
-        plain Python shell, from the perspective of how its prompts, exceptions
-        and output look.  This makes it easy to copy and paste parts of a
-        session into doctests.  It does so by:
+        If no name is given, it defaults to a file named 'ipython_log.py' in your
+        current directory, in 'rotate' mode (see below).
 
-        - Changing the prompts to the classic ``>>>`` ones.
-        - Changing the exception reporting mode to 'Plain'.
-        - Disabling pretty-printing of output.
+        '%logstart name' saves to file 'name' in 'backup' mode.  It saves your
+        history up to that point and then continues logging.
 
-        Note that IPython also supports the pasting of code snippets that have
-        leading '>>>' and '...' prompts in them.  This means that you can paste
-        doctests from files or docstrings (even if they have leading
-        whitespace), and the code will execute correctly.  You can then use
-        '%history -t' to see the translated history; this will give you the
-        input after removal of all the leading prompts and whitespace, which
-        can be pasted back into an editor.
+        %logstart takes a second optional parameter: logging mode. This can be one
+        of (note that the modes are given unquoted):\\
+          append: well, that says it.\\
+          backup: rename (if exists) to name~ and start name.\\
+          global: single logfile in your home dir, appended to.\\
+          over  : overwrite existing log.\\
+          rotate: create rotating logs name.1~, name.2~, etc.
 
-        With these features, you can switch into this mode easily whenever you
-        need to do testing and changes to doctests, without having to leave
-        your existing IPython session.
-        """
+        Options:
 
-        from IPython.utils.ipstruct import Struct
+          -o: log also IPython's output.  In this mode, all commands which
+          generate an Out[NN] prompt are recorded to the logfile, right after
+          their corresponding input line.  The output lines are always
+          prepended with a '#[Out]# ' marker, so that the log remains valid
+          Python code.
 
-        # Shorthands
-        shell = self.shell
-        pm = shell.prompt_manager
-        meta = shell.meta
-        disp_formatter = self.shell.display_formatter
-        ptformatter = disp_formatter.formatters['text/plain']
-        # dstore is a data store kept in the instance metadata bag to track any
-        # changes we make, so we can undo them later.
-        dstore = meta.setdefault('doctest_mode',Struct())
-        save_dstore = dstore.setdefault
+          Since this marker is always the same, filtering only the output from
+          a log is very easy, using for example a simple awk call::
 
-        # save a few values we'll need to recover later
-        mode = save_dstore('mode',False)
-        save_dstore('rc_pprint',ptformatter.pprint)
-        save_dstore('xmode',shell.InteractiveTB.mode)
-        save_dstore('rc_separate_out',shell.separate_out)
-        save_dstore('rc_separate_out2',shell.separate_out2)
-        save_dstore('rc_prompts_pad_left',pm.justify)
-        save_dstore('rc_separate_in',shell.separate_in)
-        save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
-        save_dstore('prompt_templates',(pm.in_template, pm.in2_template, pm.out_template))
+            awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
 
-        if mode == False:
-            # turn on
-            pm.in_template = '>>> '
-            pm.in2_template = '... '
-            pm.out_template = ''
+          -r: log 'raw' input.  Normally, IPython's logs contain the processed
+          input, so that user lines are logged in their final form, converted
+          into valid Python.  For example, %Exit is logged as
+          _ip.magic("Exit").  If the -r flag is given, all input is logged
+          exactly as typed, with no transformations applied.
 
-            # Prompt separators like plain python
-            shell.separate_in = ''
-            shell.separate_out = ''
-            shell.separate_out2 = ''
+          -t: put timestamps before each input line logged (these are put in
+          comments)."""
 
-            pm.justify = False
+        opts,par = self.parse_options(parameter_s,'ort')
+        log_output = 'o' in opts
+        log_raw_input = 'r' in opts
+        timestamp = 't' in opts
 
-            ptformatter.pprint = False
-            disp_formatter.plain_text_only = True
+        logger = self.shell.logger
 
-            shell.magic('xmode Plain')
+        # if no args are given, the defaults set in the logger constructor by
+        # ipython remain valid
+        if par:
+            try:
+                logfname,logmode = par.split()
+            except:
+                logfname = par
+                logmode = 'backup'
         else:
-            # turn off
-            pm.in_template, pm.in2_template, pm.out_template = dstore.prompt_templates
+            logfname = logger.logfname
+            logmode = logger.logmode
+        # put logfname into rc struct as if it had been called on the command
+        # line, so it ends up saved in the log header Save it in case we need
+        # to restore it...
+        old_logfile = self.shell.logfile
+        if logfname:
+            logfname = os.path.expanduser(logfname)
+        self.shell.logfile = logfname
 
-            shell.separate_in = dstore.rc_separate_in
+        loghead = '# IPython log file\n\n'
+        try:
+            started  = logger.logstart(logfname,loghead,logmode,
+                                       log_output,timestamp,log_raw_input)
+        except:
+            self.shell.logfile = old_logfile
+            warn("Couldn't start log: %s" % sys.exc_info()[1])
+        else:
+            # log input history up to this point, optionally interleaving
+            # output if requested
 
-            shell.separate_out = dstore.rc_separate_out
-            shell.separate_out2 = dstore.rc_separate_out2
+            if timestamp:
+                # disable timestamping for the previous history, since we've
+                # lost those already (no time machine here).
+                logger.timestamp = False
 
-            pm.justify = dstore.rc_prompts_pad_left
+            if log_raw_input:
+                input_hist = self.shell.history_manager.input_hist_raw
+            else:
+                input_hist = self.shell.history_manager.input_hist_parsed
 
-            ptformatter.pprint = dstore.rc_pprint
-            disp_formatter.plain_text_only = dstore.rc_plain_text_only
+            if log_output:
+                log_write = logger.log_write
+                output_hist = self.shell.history_manager.output_hist
+                for n in range(1,len(input_hist)-1):
+                    log_write(input_hist[n].rstrip() + '\n')
+                    if n in output_hist:
+                        log_write(repr(output_hist[n]),'output')
+            else:
+                logger.log_write('\n'.join(input_hist[1:]))
+                logger.log_write('\n')
+            if timestamp:
+                # re-enable timestamping
+                logger.timestamp = True
 
-            shell.magic('xmode ' + dstore.xmode)
+            print ('Activating auto-logging. '
+                   'Current session state plus future input saved.')
+            logger.logstate()
 
-        # Store new mode and inform
-        dstore.mode = bool(1-int(mode))
-        mode_label = ['OFF','ON'][dstore.mode]
-        print 'Doctest mode is:', mode_label
+    def magic_logstop(self,parameter_s=''):
+        """Fully stop logging and close log file.
 
-    def magic_gui(self, parameter_s=''):
-        """Enable or disable IPython GUI event loop integration.
+        In order to start logging again, a new %logstart call needs to be made,
+        possibly (though not necessarily) with a new filename, mode and other
+        options."""
+        self.logger.logstop()
 
-        %gui [GUINAME]
+    def magic_logoff(self,parameter_s=''):
+        """Temporarily stop logging.
 
-        This magic replaces IPython's threaded shells that were activated
-        using the (pylab/wthread/etc.) command line flags.  GUI toolkits
-        can now be enabled at runtime and keyboard
-        interrupts should work without any problems.  The following toolkits
-        are supported:  wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX)::
+        You must have previously started logging."""
+        self.shell.logger.switch_log(0)
+
+    def magic_logon(self,parameter_s=''):
+        """Restart logging.
+
+        This function is for restarting logging which you've temporarily
+        stopped with %logoff. For starting logging for the first time, you
+        must use the %logstart function, which allows you to specify an
+        optional log filename."""
+
+        self.shell.logger.switch_log(1)
 
-            %gui wx      # enable wxPython event loop integration
-            %gui qt4|qt  # enable PyQt4 event loop integration
-            %gui gtk     # enable PyGTK event loop integration
-            %gui gtk3    # enable Gtk3 event loop integration
-            %gui tk      # enable Tk event loop integration
-            %gui OSX     # enable Cocoa event loop integration
-                         # (requires %matplotlib 1.1) 
-            %gui         # disable all event loop integration
+    def magic_logstate(self,parameter_s=''):
+        """Print the status of the logging system."""
 
-        WARNING:  after any of these has been called you can simply create
-        an application object, but DO NOT start the event loop yourself, as
-        we have already handled that.
-        """
-        opts, arg = self.parse_options(parameter_s, '')
-        if arg=='': arg = None
-        try:
-            return self.enable_gui(arg)
-        except Exception as e:
-            # print simple error message, rather than traceback if we can't
-            # hook up the GUI
-            error(str(e))
+        self.shell.logger.logstate()
     
+class ExtensionsMagics(MagicFunctions):
+    """Magics to manage the IPython extensions system."""
     def magic_install_ext(self, parameter_s):
         """Download and install an extension from a URL, e.g.::
         
@@ -3510,6 +3792,9 b' Defaulting color scheme to \'NoColor\'"""'
         """Reload an IPython extension by its module name."""
         self.shell.extension_manager.reload_extension(module_str)
 
+
+class DeprecatedMagics(MagicFunctions):
+    """Magics slated for later removal."""
     def magic_install_profiles(self, s):
         """%install_profiles has been deprecated."""
         print '\n'.join([
@@ -3529,6 +3814,10 b' Defaulting color scheme to \'NoColor\'"""'
             "Add `--reset` to overwrite already existing config files with defaults."
         ])
 
+
+class PylabMagics(MagicFunctions):
+    """Magics related to matplotlib's pylab support"""
+
     @skip_doctest
     def magic_pylab(self, s):
         """Load numpy and matplotlib to work interactively.
@@ -3589,234 +3878,3 b' Defaulting color scheme to \'NoColor\'"""'
             import_all_status = True
 
         self.shell.enable_pylab(s, import_all=import_all_status)
-
-    def magic_tb(self, s):
-        """Print the last traceback with the currently active exception mode.
-
-        See %xmode for changing exception reporting modes."""
-        self.shell.showtraceback()
-
-    @skip_doctest
-    def magic_precision(self, s=''):
-        """Set floating point precision for pretty printing.
-
-        Can set either integer precision or a format string.
-
-        If numpy has been imported and precision is an int,
-        numpy display precision will also be set, via ``numpy.set_printoptions``.
-
-        If no argument is given, defaults will be restored.
-
-        Examples
-        --------
-        ::
-
-            In [1]: from math import pi
-
-            In [2]: %precision 3
-            Out[2]: u'%.3f'
-
-            In [3]: pi
-            Out[3]: 3.142
-
-            In [4]: %precision %i
-            Out[4]: u'%i'
-
-            In [5]: pi
-            Out[5]: 3
-
-            In [6]: %precision %e
-            Out[6]: u'%e'
-
-            In [7]: pi**10
-            Out[7]: 9.364805e+04
-
-            In [8]: %precision
-            Out[8]: u'%r'
-
-            In [9]: pi**10
-            Out[9]: 93648.047476082982
-
-        """
-
-        ptformatter = self.shell.display_formatter.formatters['text/plain']
-        ptformatter.float_precision = s
-        return ptformatter.float_format
-
-
-    @magic_arguments.magic_arguments()
-    @magic_arguments.argument(
-        '-e', '--export', action='store_true', default=False,
-        help='Export IPython history as a notebook. The filename argument '
-             'is used to specify the notebook name and format. For example '
-             'a filename of notebook.ipynb will result in a notebook name '
-             'of "notebook" and a format of "xml". Likewise using a ".json" '
-             'or ".py" file extension will write the notebook in the json '
-             'or py formats.'
-    )
-    @magic_arguments.argument(
-        '-f', '--format',
-        help='Convert an existing IPython notebook to a new format. This option '
-             'specifies the new format and can have the values: xml, json, py. '
-             'The target filename is chosen automatically based on the new '
-             'format. The filename argument gives the name of the source file.'
-    )
-    @magic_arguments.argument(
-        'filename', type=unicode,
-        help='Notebook name or filename'
-    )
-    def magic_notebook(self, s):
-        """Export and convert IPython notebooks.
-
-        This function can export the current IPython history to a notebook file
-        or can convert an existing notebook file into a different format. For
-        example, to export the history to "foo.ipynb" do "%notebook -e foo.ipynb".
-        To export the history to "foo.py" do "%notebook -e foo.py". To convert
-        "foo.ipynb" to "foo.json" do "%notebook -f json foo.ipynb". Possible
-        formats include (json/ipynb, py).
-        """
-        args = magic_arguments.parse_argstring(self.magic_notebook, s)
-
-        from IPython.nbformat import current
-        args.filename = unquote_filename(args.filename)
-        if args.export:
-            fname, name, format = current.parse_filename(args.filename)
-            cells = []
-            hist = list(self.shell.history_manager.get_range())
-            for session, prompt_number, input in hist[:-1]:
-                cells.append(current.new_code_cell(prompt_number=prompt_number,
-                                                   input=input))
-            worksheet = current.new_worksheet(cells=cells)
-            nb = current.new_notebook(name=name,worksheets=[worksheet])
-            with io.open(fname, 'w', encoding='utf-8') as f:
-                current.write(nb, f, format);
-        elif args.format is not None:
-            old_fname, old_name, old_format = current.parse_filename(args.filename)
-            new_format = args.format
-            if new_format == u'xml':
-                raise ValueError('Notebooks cannot be written as xml.')
-            elif new_format == u'ipynb' or new_format == u'json':
-                new_fname = old_name + u'.ipynb'
-                new_format = u'json'
-            elif new_format == u'py':
-                new_fname = old_name + u'.py'
-            else:
-                raise ValueError('Invalid notebook format: %s' % new_format)
-            with io.open(old_fname, 'r', encoding='utf-8') as f:
-                nb = current.read(f, old_format)
-            with io.open(new_fname, 'w', encoding='utf-8') as f:
-                current.write(nb, f, new_format)
-
-    def magic_config(self, s):
-        """configure IPython
-        
-            %config Class[.trait=value]
-        
-        This magic exposes most of the IPython config system. Any
-        Configurable class should be able to be configured with the simple
-        line::
-        
-            %config Class.trait=value
-        
-        Where `value` will be resolved in the user's namespace, if it is an
-        expression or variable name.
-        
-        Examples
-        --------
-        
-        To see what classes are available for config, pass no arguments::
-
-            In [1]: %config
-            Available objects for config:
-                TerminalInteractiveShell
-                HistoryManager
-                PrefilterManager
-                AliasManager
-                IPCompleter
-                PromptManager
-                DisplayFormatter
-
-        To view what is configurable on a given class, just pass the class
-        name::
-
-            In [2]: %config IPCompleter
-            IPCompleter options
-            -----------------
-            IPCompleter.omit__names=<Enum>
-                Current: 2
-                Choices: (0, 1, 2)
-                Instruct the completer to omit private method names
-                Specifically, when completing on ``object.<tab>``.
-                When 2 [default]: all names that start with '_' will be excluded.
-                When 1: all 'magic' names (``__foo__``) will be excluded.
-                When 0: nothing will be excluded.
-            IPCompleter.merge_completions=<CBool>
-                Current: True
-                Whether to merge completion results into a single list
-                If False, only the completion results from the first non-empty completer
-                will be returned.
-            IPCompleter.limit_to__all__=<CBool>
-                Current: False
-                Instruct the completer to use __all__ for the completion
-                Specifically, when completing on ``object.<tab>``.
-                When True: only those names in obj.__all__ will be included.
-                When False [default]: the __all__ attribute is ignored
-            IPCompleter.greedy=<CBool>
-                Current: False
-                Activate greedy completion
-                This will enable completion on elements of lists, results of function calls,
-                etc., but can be unsafe because the code is actually evaluated on TAB.
-
-        but the real use is in setting values::
-
-            In [3]: %config IPCompleter.greedy = True
-
-        and these values are read from the user_ns if they are variables::
-
-            In [4]: feeling_greedy=False
-
-            In [5]: %config IPCompleter.greedy = feeling_greedy
-
-        """
-        from IPython.config.loader import Config
-        # some IPython objects are Configurable, but do not yet have
-        # any configurable traits.  Exclude them from the effects of
-        # this magic, as their presence is just noise:
-        configurables = [ c for c in self.shell.configurables
-                          if c.__class__.class_traits(config=True) ]
-        classnames = [ c.__class__.__name__ for c in configurables ]
-        
-        line = s.strip()
-        if not line:
-            # print available configurable names
-            print "Available objects for config:"
-            for name in classnames:
-                print "    ", name
-            return
-        elif line in classnames:
-            # `%config TerminalInteractiveShell` will print trait info for
-            # TerminalInteractiveShell
-            c = configurables[classnames.index(line)]
-            cls = c.__class__
-            help = cls.class_get_help(c)
-            # strip leading '--' from cl-args:
-            help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
-            print help
-            return
-        elif '=' not in line:
-            raise UsageError("Invalid config statement: %r, should be Class.trait = value" % line)
-            
-        
-        # otherwise, assume we are setting configurables.
-        # leave quotes on args when splitting, because we want
-        # unquoted args to eval in user_ns
-        cfg = Config()
-        exec "cfg."+line in locals(), self.shell.user_ns
-        
-        for configurable in configurables:
-            try:
-                configurable.update_config(cfg)
-            except Exception as e:
-                error(e)
-
-# end Magic