IPython/Extensions/ipy_legacy.py

""" Legacy stuff

Various stuff that are there for historical / familiarity reasons.

This is automatically imported by default profile, though not other profiles
(e.g. 'sh' profile).

Stuff that is considered obsolete / redundant is gradually moved here.

"""

import IPython.ipapi
ip = IPython.ipapi.get()

import os,sys

from IPython.genutils import *

# use ?
def magic_pdef(self, parameter_s='', namespaces=None):
    """Print the definition header for any callable object.

    If the object is a class, print the constructor information."""
    self._inspect('pdef',parameter_s, namespaces)

ip.expose_magic("pdef", magic_pdef)

# use ?
def magic_pdoc(self, parameter_s='', namespaces=None):
    """Print the docstring for an object.

    If the given object is a class, it will print both the class and the
    constructor docstrings."""
    self._inspect('pdoc',parameter_s, namespaces)

ip.expose_magic("pdoc", magic_pdoc)

# use ??
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)

ip.expose_magic("pdoc", magic_psource)

# use ?
def magic_pfile(self, parameter_s=''):
    """Print (or run through pager) the file where an object is defined.

    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 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(self.shell.inspector.format(file(filename).read()))

ip.expose_magic("pfile", magic_pfile)

# use rehashx

def magic_rehash(self, parameter_s = ''):
    """Update the alias table with all entries in $PATH.

    This version does no checks on execute permissions or whether the
    contents of $PATH are truly files (instead of directories or something
    else).  For such a safer (but slower) version, use %rehashx."""

    # This function (and rehashx) manipulate the alias_table directly
    # rather than calling magic_alias, for speed reasons.  A rehash on a
    # typical Linux box involves several thousand entries, so efficiency
    # here is a top concern.

    path = filter(os.path.isdir,os.environ.get('PATH','').split(os.pathsep))
    alias_table = self.shell.alias_table
    for pdir in path:
        for ff in os.listdir(pdir):
            # each entry in the alias table must be (N,name), where
            # N is the number of positional arguments of the alias.
            alias_table[ff] = (0,ff)
    # Make sure the alias table doesn't contain keywords or builtins
    self.shell.alias_table_validate()
    # Call again init_auto_alias() so we get 'rm -i' and other modified
    # aliases since %rehash will probably clobber them
    self.shell.init_auto_alias()

ip.expose_magic("rehash", magic_rehash)

#use cd -<tab>
def magic_dhist(self, parameter_s=''):
    """Print your history of visited directories.

    %dhist       -> print full history\\
    %dhist n     -> print last n entries only\\
    %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\

    This history is automatically maintained by the %cd command, and
    always available as the global list variable _dh. You can use %cd -<n>
    to go to directory number <n>."""

    dh = self.shell.user_ns['_dh']
    if parameter_s:
        try:
            args = map(int,parameter_s.split())
        except:
            self.arg_err(Magic.magic_dhist)
            return
        if len(args) == 1:
            ini,fin = max(len(dh)-(args[0]),0),len(dh)
        elif len(args) == 2:
            ini,fin = args
        else:
            self.arg_err(Magic.magic_dhist)
            return
    else:
        ini,fin = 0,len(dh)
    nlprint(dh,
            header = 'Directory history (kept in _dh)',
            start=ini,stop=fin)

ip.expose_magic("dhist", magic_dhist)

# Exit
def magic_Quit(self, parameter_s=''):
    """Exit IPython without confirmation (like %Exit)."""

    self.shell.exit_now = True

ip.expose_magic("Quit", magic_Quit)


# make it autocallable fn if you really need it
def magic_p(self, parameter_s=''):
    """Just a short alias for Python's 'print'."""
    exec 'print ' + parameter_s in self.shell.user_ns

ip.expose_magic("p", magic_p)

# up + enter. One char magic.
def magic_r(self, parameter_s=''):
    """Repeat previous input.

    If given an argument, repeats the previous command which starts with
    the same string, otherwise it just repeats the previous input.

    Shell escaped commands (with ! as first character) are not recognized
    by this system, only pure python code and magic commands.
    """

    start = parameter_s.strip()
    esc_magic = self.shell.ESC_MAGIC
    # Identify magic commands even if automagic is on (which means
    # the in-memory version is different from that typed by the user).
    if self.shell.rc.automagic:
        start_magic = esc_magic+start
    else:
        start_magic = start
    # Look through the input history in reverse
    for n in range(len(self.shell.input_hist)-2,0,-1):
        input = self.shell.input_hist[n]
        # skip plain 'r' lines so we don't recurse to infinity
        if input != '_ip.magic("r")\n' and \
               (input.startswith(start) or input.startswith(start_magic)):
            #print 'match',`input`  # dbg
            print 'Executing:',input,
            self.shell.runlines(input)
            return
    print 'No previous input matching `%s` found.' % start

ip.expose_magic("r", magic_r)


# use _ip.option.automagic

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."""

    rc = self.shell.rc
    arg = parameter_s.lower()
    if parameter_s in ('on','1','true'):
        rc.automagic = True
    elif parameter_s in ('off','0','false'):
        rc.automagic = False
    else:
        rc.automagic = not rc.automagic
    print '\n' + Magic.auto_status[rc.automagic]

ip.expose_magic("automagic", magic_automagic)

# use _ip.options.autocall
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)."""

    rc = self.shell.rc

    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):
        rc.autocall = arg
    else: # toggle
        if rc.autocall:
            self._magic_state.autocall_save = rc.autocall
            rc.autocall = 0
        else:
            try:
                rc.autocall = self._magic_state.autocall_save
            except AttributeError:
                rc.autocall = self._magic_state.autocall_save = 1

    print "Automatic calling is:",['OFF','Smart','Full'][rc.autocall]

ip.expose_magic("autocall", magic_autocall)