##// END OF EJS Templates
Add Ville's patch for the new %store persistence magic.
Add Ville's patch for the new %store persistence magic.

File last commit:

Show More
2669 lines | 102.4 KiB | text/x-python | PythonLexer
# -*- coding: utf-8 -*-
"""Magic functions for InteractiveShell.
$Id: Magic.py 968 2005-12-29 17:15:38Z fperez $"""
# Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
# Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
# Distributed under the terms of the BSD License. The full license is in
# the file COPYING, distributed as part of this software.
# Modules and globals
from IPython import Release
__author__ = '%s <%s>\n%s <%s>' % \
( Release.authors['Janko'] + Release.authors['Fernando'] )
__license__ = Release.license
# Python standard modules
import __builtin__
import bdb
import inspect
import os
import pdb
import pydoc
import sys
import re
import tempfile
import time
import cPickle as pickle
from cStringIO import StringIO
from getopt import getopt
from pprint import pprint, pformat
# profile isn't bundled by default in Debian for license reasons
import profile,pstats
except ImportError:
profile = pstats = None
# Homebrewed
from IPython import Debugger, OInspect, wildcard
from IPython.FakeModule import FakeModule
from IPython.Itpl import Itpl, itpl, printpl,itplns
from IPython.PyColorize import Parser
from IPython.Struct import Struct
from IPython.genutils import *
# Utility functions
def on_off(tag):
"""Return an ON/OFF string for a 1/0 input. Simple utility function."""
return ['OFF','ON'][tag]
# Utility classes
class Macro(list):
"""Simple class to store the value of macros as strings.
This allows us to later exec them by checking when something is an
instance of this class."""
def __init__(self,data):
self.value = ''.join(data)
# Main class implementing Magic functionality
class Magic:
"""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.']
# some utility functions
def __init__(self,shell):
self.options_table = {}
if profile is None:
self.magic_prun = self.profile_missing_notice
self.shell = shell
def profile_missing_notice(self, *args, **kwargs):
The profile module could not be found. If you are a Debian user,
it has been removed from the standard Debian package because of its non-free
license. To use profiling, please install"python2.3-profiler" from non-free.""")
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
def lsmagic(self):
"""Return a list of currently available magic functions.
Gives a list of the bare names after mangling (['ls','cd', ...], not
# FIXME. This needs a cleanup, in the way the magics list is built.
# magics in class definition
class_magic = lambda fn: fn.startswith('magic_') and \
# in instance namespace (run-time user additions)
inst_magic = lambda fn: fn.startswith('magic_') and \
# and bound magics by user (so they can access self):
inst_bound_magic = lambda fn: fn.startswith('magic_') and \
magics = filter(class_magic,Magic.__dict__.keys()) + \
filter(inst_magic,self.__dict__.keys()) + \
out = []
for fn in magics:
return out
def extract_input_slices(self,slices):
"""Return as a string a set of input history slices.
The set of slices is given as a list of strings (like ['1','4:8','9'],
since this function is for use by magic functions which get their
arguments as strings."""
cmds = []
for chunk in slices:
if ':' in chunk:
ini,fin = map(int,chunk.split(':'))
ini = int(chunk)
fin = ini+1
return cmds
def _ofind(self,oname):
"""Find an object in the available namespaces.
self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
Has special code to detect magic functions.
oname = oname.strip()
# Namespaces to search in:
user_ns = self.shell.user_ns
internal_ns = self.shell.internal_ns
builtin_ns = __builtin__.__dict__
alias_ns = self.shell.alias_table
# Put them in a list. The order is important so that we find things in
# the same order that Python finds them.
namespaces = [ ('Interactive',user_ns),
('IPython internal',internal_ns),
('Python builtin',builtin_ns),
# initialize results to 'null'
found = 0; obj = None; ospace = None; ds = None;
ismagic = 0; isalias = 0
# Look for the given name by splitting it in parts. If the head is
# found, then we look for all the remaining parts as members, and only
# declare success if we can find them all.
oname_parts = oname.split('.')
oname_head, oname_rest = oname_parts[0],oname_parts[1:]
for nsname,ns in namespaces:
obj = ns[oname_head]
except KeyError:
for part in oname_rest:
obj = getattr(obj,part)
# Blanket except b/c some badly implemented objects
# allow __getattr__ to raise exceptions other than
# AttributeError, which then crashes IPython.
# If we finish the for loop (no break), we got all members
found = 1
ospace = nsname
if ns == alias_ns:
isalias = 1
break # namespace loop
# Try to see if it's magic
if not found:
if oname.startswith(self.shell.ESC_MAGIC):
oname = oname[1:]
obj = getattr(self,'magic_'+oname,None)
if obj is not None:
found = 1
ospace = 'IPython internal'
ismagic = 1
# Last try: special-case some literals like '', [], {}, etc:
if not found and oname_head in ["''",'""','[]','{}','()']:
obj = eval(oname_head)
found = 1
ospace = 'Interactive'
return {'found':found, 'obj':obj, 'namespace':ospace,
'ismagic':ismagic, 'isalias':isalias}
def arg_err(self,func):
"""Print docstring if incorrect arguments were passed"""
print 'Error in arguments:'
print OInspect.getdoc(func)
def format_latex(self,str):
"""Format a string for latex inclusion."""
# Characters that need to be escaped for latex:
escape_re = re.compile(r'(%|_|\$)',re.MULTILINE)
# Magic command names as headers:
cmd_name_re = re.compile(r'^(%s.*?):' % self.shell.ESC_MAGIC,
# Magic commands
cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % self.shell.ESC_MAGIC,
# Paragraph continue
par_re = re.compile(r'\\$',re.MULTILINE)
str = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',str)
str = cmd_re.sub(r'\\texttt{\g<cmd>}',str)
str = par_re.sub(r'\\\\',str)
str = escape_re.sub(r'\\\1',str)
return str
def format_screen(self,str):
"""Format a string for screen printing.
This removes some latex-type format codes."""
# Paragraph continue
par_re = re.compile(r'\\$',re.MULTILINE)
str = par_re.sub('',str)
return str
def parse_options(self,arg_str,opt_str,*long_opts,**kw):
"""Parse options passed to an argument string.
The interface is similar to that of getopt(), but it returns back a
Struct with the options as keys and the stripped argument string still
as a string.
arg_str is quoted as a true sys.argv vector by using shlex.split.
This allows us to easily expand variables, glob files, quote
arguments, etc.
-mode: default 'string'. If given as 'list', the argument string is
returned as a list (split on whitespace) instead of a string.
-list_all: put all option values in lists. Normally only options
appearing more than once are put in a list."""
# inject default options at the beginning of the input line
caller = sys._getframe(1).f_code.co_name.replace('magic_','')
arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
mode = kw.get('mode','string')
if mode not in ['string','list']:
raise ValueError,'incorrect mode given: %s' % mode
# Get options
list_all = kw.get('list_all',0)
# Check if we have more than one argument to warrant extra processing:
odict = {} # Dictionary with options
args = arg_str.split()
if len(args) >= 1:
# If the list of inputs only has 0 or 1 thing in it, there's no
# need to look for options
argv = shlex_split(arg_str)
# Do regular option processing
opts,args = getopt(argv,opt_str,*long_opts)
for o,a in opts:
if o.startswith('--'):
o = o[2:]
o = o[1:]
except AttributeError:
odict[o] = [odict[o],a]
except KeyError:
if list_all:
odict[o] = [a]
odict[o] = a
# Prepare opts,args for return
opts = Struct(odict)
if mode == 'string':
args = ' '.join(args)
return opts,args
# And now the actual magic functions
# Functions for IPython shell work (vars,funcs, config, etc)
def magic_lsmagic(self, parameter_s = ''):
"""List currently available magic functions."""
mesc = self.shell.ESC_MAGIC
print 'Available magic functions:\n'+mesc+\
(' '+mesc).join(self.lsmagic())
print '\n' + Magic.auto_status[self.shell.rc.automagic]
return None
def magic_magic(self, parameter_s = ''):
"""Print information about the magic function system."""
mode = ''
if parameter_s.split()[0] == '-latex':
mode = 'latex'
magic_docs = []
for fname in self.lsmagic():
mname = 'magic_' + fname
for space in (Magic,self,self.__class__):
fn = space.__dict__[mname]
except KeyError:
magic_docs.append('%s%s:\n\t%s\n' %(self.shell.ESC_MAGIC,
magic_docs = ''.join(magic_docs)
if mode == 'latex':
print self.format_latex(magic_docs)
magic_docs = self.format_screen(magic_docs)
outmsg = """
IPython's 'magic' functions
The magic function system provides a series of functions which allow you to
control the behavior of IPython itself, plus a lot of system-type
features. All these functions are prefixed with a % character, but parameters
are given without parentheses or quotes.
NOTE: If you have 'automagic' enabled (via the command line option or with the
%automagic function), you don't need to type in the % explicitly. By default,
IPython ships with automagic on, so you should only rarely need the % escape.
Example: typing '%cd mydir' (without the quotes) changes you working directory
to 'mydir', if it exists.
You can define your own magic functions to extend the system. See the supplied
ipythonrc and example-magic.py files for details (in your ipython
configuration directory, typically $HOME/.ipython/).
You can also define your own aliased names for magic functions. In your
ipythonrc file, placing a line like:
execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
will define %pf as a new name for %profile.
You can also call magics in code using the ipmagic() function, which IPython
automatically adds to the builtin namespace. Type 'ipmagic?' for details.
For a list of the available magic functions, use %lsmagic. For a description
of any of them, type %magic_name?, e.g. '%cd?'.
Currently the magic system has the following functions:\n"""
mesc = self.shell.ESC_MAGIC
outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
"\n\n%s%s\n\n%s" % (outmsg,
(' '+mesc).join(self.lsmagic()),
Magic.auto_status[self.shell.rc.automagic] ) )
def magic_automagic(self, parameter_s = ''):
"""Make magic functions callable without having to type the initial %.
Toggles on/off (when off, you must call it as %automagic, of
course). 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
rc.automagic = not rc.automagic
print '\n' + Magic.auto_status[rc.automagic]
def magic_autocall(self, parameter_s = ''):
"""Make functions callable without having to type parentheses.
This toggles the autocall command line option on and off."""
rc = self.shell.rc
rc.autocall = not rc.autocall
print "Automatic calling is:",['OFF','ON'][rc.autocall]
def magic_autoindent(self, parameter_s = ''):
"""Toggle autoindent on/off (if available)."""
print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
def magic_system_verbose(self, parameter_s = ''):
"""Toggle verbose printing of system calls on/off."""
print "System verbose printing is:",\
def magic_history(self, parameter_s = ''):
"""Print input history (_i<n> variables), with most recent last.
%history [-n] -> print at most 40 inputs (some may be multi-line)\\
%history [-n] n -> print at most n inputs\\
%history [-n] n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
Each input's number <n> is shown, and is accessible as the
automatically generated variable _i<n>. Multi-line statements are
printed starting at a new line for easy copy/paste.
If option -n is used, input numbers are not printed. This is useful if
you want to get a printout of many lines which can be directly pasted
into a text editor.
This feature is only available if numbered prompts are in use."""
if not self.shell.outputcache.do_full_cache:
print 'This feature is only available if numbered prompts are in use.'
opts,args = self.parse_options(parameter_s,'n',mode='list')
default_length = 40
if len(args) == 0:
final = self.shell.outputcache.prompt_count
init = max(1,final-default_length)
elif len(args) == 1:
final = self.shell.outputcache.prompt_count
init = max(1,final-int(args[0]))
elif len(args) == 2:
init,final = map(int,args)
warn('%hist takes 0, 1 or 2 arguments separated by spaces.')
print self.magic_hist.__doc__
width = len(str(final))
line_sep = ['','\n']
input_hist = self.shell.input_hist
print_nums = not opts.has_key('n')
for in_num in range(init,final):
inline = input_hist[in_num]
multiline = inline.count('\n') > 1
if print_nums:
print str(in_num).ljust(width)+':'+ line_sep[multiline],
if inline.startswith('#'+self.shell.ESC_MAGIC) or \
print inline[1:],
print inline,
def magic_hist(self, parameter_s=''):
"""Alternate name for %history."""
return self.magic_history(parameter_s)
def magic_p(self, parameter_s=''):
"""Just a short alias for Python's 'print'."""
exec 'print ' + parameter_s in self.shell.user_ns
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
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 != 'ipmagic("r")\n' and \
(input.startswith(start) or input.startswith(start_magic)):
#print 'match',`input` # dbg
print 'Executing:',input,
print 'No previous input matching `%s` found.' % start
def magic_page(self, parameter_s=''):
"""Pretty print the object and display it through a pager.
If no parameter is given, use _ (last output)."""
# After a function contributed by Olivier Aubert, slightly modified.
oname = parameter_s and parameter_s or '_'
info = self._ofind(oname)
if info['found']:
print 'Object `%s` not found' % oname
def magic_profile(self, parameter_s=''):
"""Print your currently active IPyhton profile."""
if self.shell.rc.profile:
printpl('Current IPython profile: $self.shell.rc.profile.')
print 'No profile active.'
def _inspect(self,meth,oname,**kw):
"""Generic interface to the inspector system.
This function is meant to be called by pdef, pdoc & friends."""
oname = oname.strip()
info = Struct(self._ofind(oname))
if info.found:
pmethod = getattr(self.shell.inspector,meth)
formatter = info.ismagic and self.format_screen or None
if meth == 'pdoc':
elif meth == 'pinfo':
print 'Object `%s` not found.' % oname
return 'not found' # so callers can take other action
def magic_pdef(self, parameter_s=''):
"""Print the definition header for any callable object.
If the object is a class, print the constructor information."""
def magic_pdoc(self, parameter_s=''):
"""Print the docstring for an object.
If the given object is a class, it will print both the class and the
constructor docstrings."""
def magic_psource(self, parameter_s=''):
"""Print (or run through pager) the source code for an object."""
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
# 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':
filename = get_py_filename(parameter_s)
except IOError,msg:
print msg
def magic_pinfo(self, parameter_s=''):
"""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:
def magic_psearch(self, parameter_s=''):
"""Search for object in namespaces by wildcard.
%psearch [options] PATTERN [OBJECT TYPE]
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
%psearch -i a* function
-i a* function?
?-i a* function
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.
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).
-a: makes the pattern match even objects whose names start with a
single underscore. These names are normally ommitted from the
-i/-c: make the pattern case insensitive/sensitive. If neither of
these options is given, the default is read from your ipythonrc
file. The option name which sets this value is
'wildcards_case_sensitive'. If this option is not specified in your
ipythonrc file, IPython's internal default is to do a case sensitive
-e/-s NAMESPACE: exclude/search a given namespace. The pattern you
specifiy 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.
'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).
%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
Case sensitve search:
%psearch -c a* list all object beginning with lower case a
Show objects beginning with a single _:
%psearch -a _* list objects beginning with a single underscore"""
# default namespaces to be searched
def_search = ['user','builtin']
# 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
# select case options
if opts.has_key('i'):
ignore_case = True
elif opts.has_key('c'):
ignore_case = False
ignore_case = not shell.rc.wildcards_case_sensitive
# Build list of namespaces to search from user options
ns_exclude = ns_exclude=opt('e',[])
ns_search = [nm for nm in def_search if nm not in ns_exclude]
# Call the actual search
def magic_who_ls(self, parameter_s=''):
"""Return a sorted list of all interactive variables.
If arguments are given, only variables of types matching these
arguments are returned."""
user_ns = self.shell.user_ns
out = []
typelist = parameter_s.split()
for i in self.shell.user_ns.keys():
if not (i.startswith('_') or i.startswith('_i')) \
and not (self.shell.internal_ns.has_key(i) or
if typelist:
if type(user_ns[i]).__name__ in typelist:
return out
def magic_who(self, parameter_s=''):
"""Print all interactive variables, with some minimal formatting.
If any arguments are given, only variables whose type matches one of
these are printed. For example:
%who function str
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:
In [1]: type('hello')\\
Out[1]: <type 'str'>
indicates that the type name for strings is 'str'.
%who always excludes executed names loaded through your configuration
file and things which are internal to IPython.
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."""
varlist = self.magic_who_ls(parameter_s)
if not varlist:
print 'Interactive namespace is empty.'
# if we have variables, move on...
# stupid flushing problem: when prompts have no separators, stdout is
# getting lost. I'm starting to think this is a python bug. I'm having
# to force a flush with a print because even a sys.stdout.flush
# doesn't seem to do anything!
count = 0
for i in varlist:
print i+'\t',
count += 1
if count > 8:
count = 0
sys.stdout.flush() # FIXME. Why the hell isn't this flushing???
print # well, this does force a flush at the expense of an extra \n
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 Numeric arrays, a summary with shape, number of elements,
typecode and size in memory.
- Everything else: a string representation, snipping their middle if
too long."""
varnames = self.magic_who_ls(parameter_s)
if not varnames:
print 'Interactive namespace is empty.'
# if we have variables, move on...
# for these types, show len() instead of data:
seq_types = [types.DictType,types.ListType,types.TupleType]
# for Numeric arrays, display summary info
import Numeric
except ImportError:
array_type = None
array_type = Numeric.ArrayType.__name__
# Find all variable names and types so we can figure out column sizes
get_vars = lambda i: self.shell.user_ns[i]
type_name = lambda v: type(v).__name__
varlist = map(get_vars,varnames)
typelist = map(type_name,varlist)
# column labels and # of spaces as separator
varlabel = 'Variable'
typelabel = 'Type'
datalabel = 'Data/Info'
colsep = 3
# variable format strings
vformat = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
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 itpl(vformat),
if vtype in seq_types:
print len(var)
elif vtype==array_type:
vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
vsize = Numeric.size(var)
vbytes = vsize*var.itemsize()
if vbytes < 100000:
print aformat % (vshape,vsize,var.typecode(),vbytes)
print aformat % (vshape,vsize,var.typecode(),vbytes),
if vbytes < Mb:
print '(%s kb)' % (vbytes/kb,)
print '(%s Mb)' % (vbytes/Mb,)
vstr = str(var)
if len(vstr) < 50:
print vstr
def magic_reset(self, parameter_s=''):
"""Resets the namespace by removing all names defined by the user.
Input/Output history are left around in case you need them."""
ans = raw_input(
"Once deleted, variables cannot be recovered. Proceed (y/n)? ")
if not ans.lower() == 'y':
print 'Nothing done.'
user_ns = self.shell.user_ns
for i in self.magic_who_ls():
def magic_config(self,parameter_s=''):
"""Show IPython's internal configuration."""
page('Current configuration structure:\n'+
def magic_logstart(self,parameter_s=''):
"""Start logging anywhere in a session.
%logstart [-o|-t] [log_name [log_mode]]
If no name is given, it defaults to a file named 'ipython_log.py' in your
current directory, in 'rotate' mode (see below).
'%logstart name' saves to file 'name' in 'backup' mode. It saves your
history up to that point and then continues logging.
%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.
-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.
-t: put timestamps before each input line logged (these are put in
opts,par = self.parse_options(parameter_s,'ot')
log_output = 'o' in opts
timestamp = 't' in opts
rc = self.shell.rc
logger = self.shell.logger
# if no args are given, the defaults set in the logger constructor by
# ipytohn remain valid
if par:
logfname,logmode = par.split()
logfname = par
logmode = 'backup'
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 = rc.opts.get('logfile','')
if logfname:
logfname = os.path.expanduser(logfname)
rc.opts.logfile = logfname
loghead = self.shell.loghead_tpl % (rc.opts,rc.args)
started = logger.logstart(logfname,loghead,logmode,
rc.opts.logfile = old_logfile
warn("Couldn't start log: %s" % sys.exc_info()[1])
# log input history up to this point, optionally interleaving
# output if requested
if timestamp:
# disable timestamping for the previous history, since we've
# lost those already (no time machine here).
logger.timestamp = False
if log_output:
log_write = logger.log_write
input_hist = self.shell.input_hist
output_hist = self.shell.output_hist
for n in range(1,len(input_hist)-1):
if n in output_hist:
if timestamp:
# re-enable timestamping
logger.timestamp = True
print ('Activating auto-logging. '
'Current session state plus future input saved.')
def magic_logoff(self,parameter_s=''):
"""Temporarily stop logging.
You must have previously started logging."""
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."""
def magic_logstate(self,parameter_s=''):
"""Print the status of the logging system."""
def magic_pdb(self, parameter_s=''):
"""Control the calling of the pdb interactive debugger.
Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
argument it works as a toggle.
When an exception is triggered, IPython can optionally call the
interactive pdb debugger after the traceback printout. %pdb toggles
this feature on and off."""
par = parameter_s.strip().lower()
if par:
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.')
# toggle
new_pdb = not self.shell.InteractiveTB.call_pdb
# set on the shell
self.shell.call_pdb = new_pdb
print 'Automatic pdb calling has been turned',on_off(new_pdb)
def magic_prun(self, parameter_s ='',user_mode=1,
"""Run a statement through the python code profiler.
%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.
-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.
Since magic functions have a particular form of calling which prevents
you from writing something like:\\
In [1]: p = %prun -r print 4 # invalid!\\
you must instead use IPython's automatic variables to assign this:\\
In [1]: %prun -r print 4 \\
Out[1]: <pstats.Stats instance at 0x8222cec>\\
In [2]: stats = _
If you really need to assign this value via an explicit function call,
you can always tap directly into the true name of the magic function
by using the ipmagic function (which IPython automatically adds to the
In [3]: stats = ipmagic('prun','-r print 4')
You can type ipmagic? for more details on ipmagic.
-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
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 understod 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.
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=[''])
# protect user quote marks
parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
if user_mode: # regular user call
opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
namespace = self.shell.user_ns
else: # called to run a program by %run -p
filename = get_py_filename(arg_lst[0])
except IOError,msg:
arg_str = 'execfile(filename,prog_ns)'
namespace = locals()
prof = profile.Profile()
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:
except ValueError:
except ValueError:
# trap output
sys_stdout = sys.stdout
stdout_trap = StringIO()
sys.stdout = stdout_trap
sys.stdout = sys_stdout
output = stdout_trap.getvalue()
output = output.rstrip()
print sys_exit,
dump_file = opts.D[0]
text_file = opts.T[0]
if dump_file:
print '\n*** Profile stats marshalled to file',\
if text_file:
print '\n*** Profile printout saved to text file',\
if opts.has_key('r'):
return stats
return None
def magic_run(self, parameter_s ='',runner=None):
"""Run the named file inside IPython as a program.
%run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
Parameters after the filename are passed as command-line arguments to
the program (put in sys.argv). Then, control returns to IPython's
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).
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. 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.
-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.
-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.
-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.
-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).
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.
For example (testing the script uniq_stable.py):
In [1]: run -t uniq_stable
IPython CPU timings (estimated):\\
User : 0.19597 s.\\
System: 0.0 s.\\
In [2]: run -t -N5 uniq_stable
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.
-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:
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:
%run -d -b40 myscript
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.
When the pdb debugger starts, you will see a (Pdb) prompt. You must
first enter 'c' (without qoutes) to start execution up to the first
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.
-p: run program under the control of the Python profiler module (which
prints a detailed report of execution times, function calls, etc).
You can pass other options after -p which affect the behavior of the
profiler itself. See the docs for %prun for details.
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).
Internally this triggers a call to %prun, see its documentation for
details on the options available specifically for profiling."""
# 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:e',
filename = get_py_filename(arg_lst[0])
except IndexError:
warn('you must provide at least a filename.')
print '\n%run:\n',OInspect.getdoc(self.magic_run)
except IOError,msg:
# Control the response to exit() calls made by the script being run
exit_ignore = opts.has_key('e')
# 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
sys.argv = [filename]+ arg_lst[1:] # put in the proper filename
if opts.has_key('i'):
prog_ns = self.shell.user_ns
__name__save = self.shell.user_ns['__name__']
prog_ns['__name__'] = '__main__'
if opts.has_key('n'):
name = os.path.splitext(os.path.basename(filename))[0]
name = '__main__'
prog_ns = {'__name__':name}
# pickle fix. See iplib for an explanation
sys.modules[prog_ns['__name__']] = FakeModule(prog_ns)
stats = None
if opts.has_key('p'):
stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
if opts.has_key('d'):
deb = Debugger.Pdb(self.shell.rc.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):
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)
# 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 "ipdb> prompt to start your script."
deb.run('execfile("%s")' % filename,prog_ns)
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).
if runner is None:
runner = self.shell.safe_execfile
if opts.has_key('t'):
nruns = int(opts['N'][0])
if nruns < 1:
error('Number of runs must be >=1')
except (KeyError):
nruns = 1
if nruns == 1:
t0 = clock2()
t1 = clock2()
t_usr = t1[0]-t0[0]
t_sys = t1[1]-t1[1]
print "\nIPython CPU timings (estimated):"
print " User : %10s s." % t_usr
print " System: %10s s." % t_sys
runs = range(nruns)
t0 = clock2()
for nr in runs:
t1 = clock2()
t_usr = t1[0]-t0[0]
t_sys = t1[1]-t1[1]
print "\nIPython CPU timings (estimated):"
print "Total runs performed:",nruns
print " Times : %10s %10s" % ('Total','Per run')
print " User : %10s s, %10s s." % (t_usr,t_usr/nruns)
print " System: %10s s, %10s s." % (t_sys,t_sys/nruns)
if opts.has_key('i'):
self.shell.user_ns['__name__'] = __name__save
# update IPython interactive namespace
del prog_ns['__name__']
sys.argv = save_argv
return stats
def magic_runlog(self, parameter_s =''):
"""Run files as logs.
%runlog file1 file2 ...
Run the named files (treating them as log files) in sequence inside
the interpreter, and return to the prompt. This is much slower than
%run because each line is executed in a try/except block, but it
allows running files with syntax errors in them.
Normally IPython will guess when a file is one of its own logfiles, so
you can typically use %run even for logs. This shorthand allows you to
force any file to be treated as a log file."""
for f in parameter_s.split():
def magic_time(self,parameter_s = ''):
"""Time execution of a Python statement or expression.
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.
This function provides very basic timing functionality. In Python
2.3, the timeit module offers more control and sophistication, but for
now IPython supports Python 2.2, so we can not rely on timeit being
Some examples:
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
In [2]: n = 1000000
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
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
# fail immediately if the given expression can't be compiled
mode = 'eval'
code = compile(parameter_s,'<timed eval>',mode)
except SyntaxError:
mode = 'exec'
code = compile(parameter_s,'<timed exec>',mode)
# skew measurement as little as possible
glob = self.shell.user_ns
clk = clock2
wtime = time.time
# time execution
wall_st = wtime()
if mode=='eval':
st = clk()
out = eval(code,glob)
end = clk()
st = clk()
exec code in glob
end = clk()
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" % \
print "Wall time: %.2f" % wall_time
return out
def magic_macro(self,parameter_s = ''):
"""Define a set of input lines as a macro for future re-execution.
%macro name n1:n2 n3:n4 ... n5 .. n6 ...
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
Note that the slices use the standard Python slicing notation (5:8
means include lines numbered 5,6,7).
For example, if your history contains (%hist prints it):
44: x=1\\
45: y=3\\
46: z=x+y\\
47: print x\\
48: a=5\\
49: print 'x',x,'y',y\\
you can create a macro with lines 44 through 47 (included) and line 49
called my_macro with:
In [51]: %macro my_macro 44:48 49
Now, typing `my_macro` (without quotes) will re-execute all this code
in one pass.
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.
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.
You can view a macro's contents by explicitly printing it with:
'print macro_name'.
For one-off cases which DON'T contain magic function calls in them you
can obtain similar results by explicitly executing slices from your
input history with:
In [60]: exec In[44:48]+In[49]"""
args = parameter_s.split()
name,ranges = args[0], args[1:]
#print 'rng',ranges # dbg
lines = self.extract_input_slices(ranges)
macro = Macro(lines)
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 to a given filename.
%save filename n1:n2 n3:n4 ... n5 .. n6 ...
This function uses the same syntax as %macro for line extraction, but
instead of creating a macro it saves the resulting string to the
filename you specify.
It adds a '.py' extension to the file if you don't do so yourself, and
it asks for confirmation before overwriting existing files."""
args = parameter_s.split()
fname,ranges = args[0], 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.'
cmds = ''.join(self.extract_input_slices(ranges))
f = file(fname,'w')
print 'The following commands were written to file `%s`:' % fname
print cmds
def magic_ed(self,parameter_s = ''):
"""Alias to %edit."""
return self.magic_edit(parameter_s)
def magic_edit(self,parameter_s = '',last_call=['','']):
"""Bring up an editor and execute the resulting code.
%edit [options] [args]
%edit runs IPython's editor hook. The default version of this hook is
set to call the __IPYTHON__.rc.editor command. This is read from your
environment variable $EDITOR. 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 command line option
'-editor' or in your ipythonrc file. This is useful if you wish to use
specifically for IPython an editor different from your typical default
(and for Windows users who typically don't set environment variables).
This command allows you to conveniently edit multi-line code right in
your IPython session.
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!).
-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
-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.
If arguments are given, the following possibilites exist:
- The arguments are numbers or pairs of colon-separated numbers (like
1 4:8 9). These are interpreted as lines of previous input to be
loaded into the editor. The syntax is the same of the %macro command.
- If the argument doesn't start with a number, it is evaluated as a
variable and its contents loaded into the editor. You can thus edit
any string which contains python code (including the result of
previous edits).
- 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.
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.
- If the argument is not found as a variable, IPython will look for a
file with that name (adding .py if necessary) and load it into the
editor. It will execute its contents with execfile() when you exit,
loading any code in the file into your interactive namespace.
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.
Note that %edit is also available through the alias %ed.
This is an example of creating a simple function inside the editor and
then modifying it. First, start up the editor:
In [1]: ed\\
Editing... done. Executing edited code...\\
Out[1]: 'def foo():\\n print "foo() was defined in an editing session"\\n'
We can then call the function foo():
In [2]: foo()\\
foo() was defined in an editing session
Now we edit foo. IPython automatically loads the editor with the
(temporary) file where foo() was previously defined:
In [3]: ed foo\\
Editing... done. Executing edited code...
And if we call foo() again we get the modified version:
In [4]: foo()\\
foo() has now been changed!
Here is an example of how to edit a code snippet successive
times. First we call the editor:
In [8]: ed\\
Editing... done. Executing edited code...\\
Out[8]: "print 'hello'\\n"
Now we call it again with the previous output (stored in _):
In [9]: ed _\\
Editing... done. Executing edited code...\\
hello world\\
Out[9]: "print 'hello world'\\n"
Now we call it with the output #8 (stored in _8, also as Out[8]):
In [10]: ed _8\\
Editing... done. Executing edited code...\\
hello again\\
Out[10]: "print 'hello again'\\n"
Changing the default editor hook:
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.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."""
# FIXME: This function has become a convoluted mess. It needs a
# ground-up rewrite with clean, simple logic.
def make_filename(arg):
"Make a filename from the given args"
filename = get_py_filename(arg)
except IOError:
if args.endswith('.py'):
filename = arg
filename = None
return filename
# custom exceptions
class DataIsObject(Exception): pass
opts,args = self.parse_options(parameter_s,'px')
# Default line number value
lineno = None
if opts.has_key('p'):
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.
last_call[0] = self.shell.outputcache.prompt_count
if not opts.has_key('p'):
last_call[1] = parameter_s
# by default this is done with temp files, except when the given
# arg is a filename
use_temp = 1
if re.match(r'\d',args):
# Mode where user specifies ranges of lines, like in %macro.
# This means that you can't edit files whose names begin with
# numbers this way. Tough.
ranges = args.split()
data = ''.join(self.extract_input_slices(ranges))
elif args.endswith('.py'):
filename = make_filename(args)
data = ''
use_temp = 0
elif args:
# Load the parameter given as a variable. If not a string,
# process it as an object instead (below)
#print '*** args',args,'type',type(args) # dbg
data = eval(args,self.shell.user_ns)
if not type(data) in StringTypes:
raise DataIsObject
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)
data = ''
use_temp = 0
except DataIsObject:
# For objects, try to edit the file where they are defined
filename = inspect.getabsfile(data)
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:
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))
use_temp = 0
data = ''
if use_temp:
filename = tempfile.mktemp('.py')
if data and use_temp:
tmp_file = open(filename,'w')
# do actual editing here
print 'Editing...',
if opts.has_key('x'): # -x prevents actual execution
print 'done. Executing edited code...'
except IOError,msg:
if msg.filename == filename:
warn('File not found. Did you forget to save?')
if use_temp:
contents = open(filename).read()
return contents
def magic_xmode(self,parameter_s = ''):
"""Switch modes for the exception handlers.
Valid modes: Plain, Context and Verbose.
If called without arguments, acts as a toggle."""
def xmode_switch_err(name):
warn('Error changing %s exception modes.\n%s' %
shell = self.shell
new_mode = parameter_s.strip().capitalize()
print 'Exception reporting mode:',shell.InteractiveTB.mode
# threaded shells use a special handler in sys.excepthook
if shell.isthreaded:
def magic_colors(self,parameter_s = ''):
"""Switch color scheme for prompts, info system and exception handlers.
Currently implemented schemes: NoColor, Linux, LightBG.
Color scheme names are not case-sensitive."""
def color_switch_err(name):
warn('Error changing %s color schemes.\n%s' %
new_scheme = parameter_s.strip()
if not new_scheme:
print 'You must specify a color scheme.'
# Under Windows, check for Gary Bishop's readline, which is necessary
# for ANSI coloring
if os.name in ['nt','dos']:
import readline
except ImportError:
has_readline = 0
except AttributeError:
has_readline = 0
has_readline = 1
if not has_readline:
msg = """\
Proper color support under MS Windows requires Gary Bishop's readline library.
You can find it at:
Gary's readline needs the ctypes module, from:
Defaulting color scheme to 'NoColor'"""
new_scheme = 'NoColor'
# local shortcut
shell = self.shell
# Set prompt colors
shell.rc.colors = \
# Set exception colors
shell.InteractiveTB.set_colors(scheme = new_scheme)
shell.SyntaxTB.set_colors(scheme = new_scheme)
# threaded shells use a verbose traceback in sys.excepthook
if shell.isthreaded:
color_switch_err('system exception handler')
# Set info (for 'object?') colors
if shell.rc.color_info:
color_switch_err('object inspector')
def magic_color_info(self,parameter_s = ''):
"""Toggle color_info.
The color_info configuration parameter controls whether colors are
used for displaying object details (by things like %psource, %pfile or
the '?' system). This function toggles this value with each call.
Note that unless you have a fairly recent pager (less works better
than more) in your system, using colored object information displays
will not work properly. Test it and see."""
self.shell.rc.color_info = 1 - self.shell.rc.color_info