head, tail = dh[:-10], dh[-10:]

newhead = []

done = set()

for h in head:

if h in done:

continue

newhead.append(h)

done.add(h)

"""Magic functions for InteractiveShell.

# class globals

auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',

'Automagic is ON, % prefix NOT needed for magic functions.']

configurables = 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 = []

# namespace for holding state we may need

self._magic_state = Bunch()

def profile_missing_notice(self, *args, **kwargs):

error("""\

python-profiler package 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.

# 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 \

callable(Magic.__dict__[fn])

# in instance namespace (run-time user additions)

inst_magic = lambda fn: fn.startswith('magic_') and \

callable(self.__dict__[fn])

# and bound magics by user (so they can access self):

inst_bound_magic = lambda fn: fn.startswith('magic_') and \

callable(self.__class__.__dict__[fn])

magics = filter(class_magic,Magic.__dict__.keys()) + \

filter(inst_magic,self.__dict__.keys()) + \

filter(inst_bound_magic,self.__class__.__dict__.keys())

out = []

for fn in set(magics):

out.append(fn.replace('magic_','',1))

out.sort()

return out

def extract_input_lines(self, range_str, raw=False):

"""Return as a string a set of input history slices.

lines = self.shell.history_manager.\

get_range_by_str(range_str, raw=raw)

return "\n".join(x for _, _, x in lines)

def arg_err(self,func):

"""Print docstring if incorrect arguments were passed"""

print 'Error in arguments:'

print oinspect.getdoc(func)

def format_latex(self,strng):

"""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.*?):' % ESC_MAGIC,

re.MULTILINE)

# Magic commands

cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,

re.MULTILINE)

# Paragraph continue

par_re = re.compile(r'\\$',re.MULTILINE)

# The "\n" symbol

newline_re = re.compile(r'\\n')

# Now build the string for output:

#strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)

strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',

strng)

strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)

strng = par_re.sub(r'\\\\',strng)

strng = escape_re.sub(r'\\\1',strng)

strng = newline_re.sub(r'\\textbackslash{}n',strng)

return strng

def parse_options(self,arg_str,opt_str,*long_opts,**kw):

"""Parse options passed to an argument string.

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

posix = kw.get('posix', os.name == 'posix')

strict = kw.get('strict', True)

# 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 = arg_split(arg_str, posix, strict)

# Do regular option processing

try:

opts,args = getopt(argv,opt_str,*long_opts)

except GetoptError,e:

raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,

" ".join(long_opts)))

for o,a in opts:

if o.startswith('--'):

o = o[2:]

else:

o = o[1:]

try:

odict[o].append(a)

except AttributeError:

odict[o] = [odict[o],a]

except KeyError:

if list_all:

odict[o] = [a]

else:

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 = ESC_MAGIC

print 'Available magic functions:\n'+mesc+\

(' '+mesc).join(self.lsmagic())

print '\n' + Magic.auto_status[self.shell.automagic]

return None

def magic_magic(self, parameter_s = ''):

"""Print information about the magic function system.

mode = ''

try:

if parameter_s.split()[0] == '-latex':

mode = 'latex'

if parameter_s.split()[0] == '-brief':

mode = 'brief'

if parameter_s.split()[0] == '-rest':

mode = 'rest'

rest_docs = []

except:

pass

magic_docs = []

for fname in self.lsmagic():

mname = 'magic_' + fname

for space in (Magic,self,self.__class__):

try:

fn = space.__dict__[mname]

except KeyError:

pass

else:

break

if mode == 'brief':

# only first line

if fn.__doc__:

fndoc = fn.__doc__.split('\n',1)[0]

else:

fndoc = 'No documentation'

else:

if fn.__doc__:

fndoc = fn.__doc__.rstrip()

else:

fndoc = 'No documentation'

if mode == 'rest':

rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(ESC_MAGIC,

fname,fndoc))

else:

magic_docs.append('%s%s:\n\t%s\n' %(ESC_MAGIC,

fname,fndoc))

magic_docs = ''.join(magic_docs)

if mode == 'rest':

return "".join(rest_docs)

if mode == 'latex':

print self.format_latex(magic_docs)

return

else:

magic_docs = format_screen(magic_docs)

if mode == 'brief':

return magic_docs

outmsg = """

mesc = ESC_MAGIC

outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"

"\n\n%s%s\n\n%s" % (outmsg,

magic_docs,mesc,mesc,

(' '+mesc).join(self.lsmagic()),

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

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.

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.

# After a function contributed by Olivier Aubert, slightly modified.

# Process options/args

opts,args = self.parse_options(parameter_s,'r')

raw = 'r' in opts

oname = args and args or '_'

info = self._ofind(oname)

if info['found']:

txt = (raw and str or pformat)( info['obj'] )

page.page(txt)

else:

print 'Object `%s` not found' % oname

def magic_profile(self, parameter_s=''):

"""Print your currently active IPython profile."""

from IPython.core.application import BaseIPythonApplication

if BaseIPythonApplication.initialized():

print BaseIPythonApplication.instance().profile

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.

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

self.shell._inspect('pinfo', parameter_s, detail_level=1,

namespaces=namespaces)

@skip_doctest

def magic_pdef(self, parameter_s='', namespaces=None):

"""Print the definition header for any callable object.

self._inspect('pdef',parameter_s, namespaces)

def magic_pdoc(self, parameter_s='', namespaces=None):

"""Print the docstring for an object.

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)

def magic_pfile(self, parameter_s=''):

"""Print (or run through pager) the file where an object is defined.

# 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(file(filename).read()))

def magic_psearch(self, parameter_s=''):

"""Search for object in namespaces by wildcard.

try:

parameter_s.encode('ascii')

except UnicodeEncodeError:

print 'Python identifiers can only contain ascii characters.'

return

# default namespaces to be searched

def_search = ['user_local', 'user_global', '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

else:

ignore_case = not shell.wildcards_case_sensitive

# 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]

# Call the actual search

try:

psearch(args,shell.ns_table,ns_search,

show_all=opt('a'),ignore_case=ignore_case)

except:

shell.showtraceback()

@skip_doctest

def magic_who_ls(self, parameter_s=''):

"""Return a sorted list of all interactive variables.

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

@skip_doctest

def magic_who(self, parameter_s=''):

"""Print all interactive variables, with some minimal formatting.

varlist = self.magic_who_ls(parameter_s)

if not varlist:

if parameter_s:

print 'No variables match your requested type.'

else:

print 'Interactive namespace is empty.'

return

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

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

return

# 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:

from numpy import ndarray

except ImportError:

pass

else:

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:

typelist.append(tt)

# 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

else:

# Numeric

vsize = Numeric.size(var)

vbytes = vsize*var.itemsize()

vdtype = var.typecode()

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:

try:

vstr = str(var)

except UnicodeEncodeError:

vstr = unicode(var).encode(sys.getdefaultencoding(),

'backslashreplace')

vstr = vstr.replace('\n','\\n')

if len(vstr) < 50:

print vstr

else:

print vstr[:25] + "<...>" + vstr[-25:]

def magic_reset(self, parameter_s=''):

"""Resets the namespace by removing all names defined by the user, if