if et==bdb.BdbQuit:

print 'Exiting Debugger.'

else:

"""Class for local debugging, similar to pdb.set_trace.

def __init__(self,colors=None):

"""Create a local debugger instance.

try:

ip = get_ipython()

except NameError:

# Outside of ipython, we set our own exception hook manually

BdbQuit_excepthook.excepthook_ori = sys.excepthook

sys.excepthook = BdbQuit_excepthook

def_colors = 'NoColor'

try:

# Limited tab completion support

import readline

readline.parse_and_bind('tab: complete')

except ImportError:

pass

else:

# In ipython, we use its custom exception handler mechanism

def_colors = ip.colors

ip.set_custom_exc((bdb.BdbQuit,), BdbQuit_IPython_excepthook)

if colors is None:

colors = def_colors

self.debugger = Pdb(colors)

def __call__(self):

"""Starts an interactive debugger at the point where called.

"""Make new_fn have old_fn's doc string. This is particularly useful

def wrapper(*args, **kw):

return new_fn(*args, **kw)

if old_fn.__doc__:

wrapper.__doc__ = old_fn.__doc__ + additional_text

"""Return the contents of a named file as a list of lines.

try:

outfile = open(fname)

except IOError:

return []

else:

out = outfile.readlines()

outfile.close()

"""Modified Pdb class, does not load readline."""

def __init__(self,color_scheme='NoColor',completekey=None,

stdin=None, stdout=None):

# Parent constructor:

if has_pydb and completekey is None:

OldPdb.__init__(self,stdin=stdin,stdout=io.stdout)

else:

OldPdb.__init__(self,completekey,stdin,stdout)

self.prompt = prompt # The default prompt is '(Pdb)'

# IPython changes...

self.is_pydb = has_pydb

self.shell = ipapi.get()

if self.is_pydb:

# interactiveshell.py's ipalias seems to want pdb's checkline

# which located in pydb.fn

import pydb.fns

self.checkline = lambda filename, lineno: \

pydb.fns.checkline(self, filename, lineno)

self.curframe = None

self.do_restart = self.new_do_restart

self.old_all_completions = self.shell.Completer.all_completions

self.shell.Completer.all_completions=self.all_completions

self.do_list = decorate_fn_with_doc(self.list_command_pydb,

OldPdb.do_list)

self.do_l = self.do_list

self.do_frame = decorate_fn_with_doc(self.new_do_frame,

OldPdb.do_frame)

self.aliases = {}

# Create color table: we copy the default one from the traceback

# module and add a few attributes needed for debugging

self.color_scheme_table = exception_colors()

# shorthands

C = coloransi.TermColors

cst = self.color_scheme_table

cst['NoColor'].colors.breakpoint_enabled = C.NoColor

cst['NoColor'].colors.breakpoint_disabled = C.NoColor

cst['Linux'].colors.breakpoint_enabled = C.LightRed

cst['Linux'].colors.breakpoint_disabled = C.Red

cst['LightBG'].colors.breakpoint_enabled = C.LightRed

cst['LightBG'].colors.breakpoint_disabled = C.Red

self.set_colors(color_scheme)

# Add a python parser so we can syntax highlight source while

# debugging.

self.parser = PyColorize.Parser()

def set_colors(self, scheme):

"""Shorthand access to the color table scheme selector method."""

self.color_scheme_table.set_active_scheme(scheme)

def interaction(self, frame, traceback):

self.shell.set_completer_frame(frame)

OldPdb.interaction(self, frame, traceback)

def new_do_up(self, arg):

OldPdb.do_up(self, arg)

self.shell.set_completer_frame(self.curframe)

do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)

def new_do_down(self, arg):

OldPdb.do_down(self, arg)

self.shell.set_completer_frame(self.curframe)

do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)

def new_do_frame(self, arg):

OldPdb.do_frame(self, arg)

self.shell.set_completer_frame(self.curframe)

def new_do_quit(self, arg):

if hasattr(self, 'old_all_completions'):

self.shell.Completer.all_completions=self.old_all_completions

return OldPdb.do_quit(self, arg)

do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)

def new_do_restart(self, arg):

"""Restart command. In the context of ipython this is exactly the same

self.msg("Restart doesn't make sense here. Using 'quit' instead.")

return self.do_quit(arg)

def postloop(self):

self.shell.set_completer_frame(None)

def print_stack_trace(self):

try:

for frame_lineno in self.stack:

self.print_stack_entry(frame_lineno, context = 5)

except KeyboardInterrupt:

pass

def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',

context = 3):

#frame, lineno = frame_lineno

print >>io.stdout, self.format_stack_entry(frame_lineno, '', context)

# vds: >>

frame, lineno = frame_lineno

filename = frame.f_code.co_filename

self.shell.hooks.synchronize_with_editor(filename, lineno, 0)

# vds: <<

def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):

import linecache, repr

ret = []

Colors = self.color_scheme_table.active_colors

ColorsNormal = Colors.Normal

tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)

tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)

tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)

tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,

ColorsNormal)

frame, lineno = frame_lineno

return_value = ''

if '__return__' in frame.f_locals:

rv = frame.f_locals['__return__']

#return_value += '->'

return_value += repr.repr(rv) + '\n'

ret.append(return_value)

#s = filename + '(' + `lineno` + ')'

filename = self.canonic(frame.f_code.co_filename)

link = tpl_link % filename

if frame.f_code.co_name:

func = frame.f_code.co_name

else:

func = "<lambda>"

call = ''

if func != '?':

if '__args__' in frame.f_locals:

args = repr.repr(frame.f_locals['__args__'])

else:

args = '()'

call = tpl_call % (func, args)

# The level info should be generated in the same format pdb uses, to

# avoid breaking the pdbtrack functionality of python-mode in *emacs.

if frame is self.curframe:

ret.append('> ')

else:

ret.append(' ')

ret.append('%s(%s)%s\n' % (link,lineno,call))

start = lineno - 1 - context//2

lines = linecache.getlines(filename)

start = max(start, 0)

start = min(start, len(lines) - context)

lines = lines[start : start + context]

for i,line in enumerate(lines):

show_arrow = (start + 1 + i == lineno)

linetpl = (frame is self.curframe or show_arrow) \

and tpl_line_em \

or tpl_line

ret.append(self.__format_line(linetpl, filename,

start + 1 + i, line,

arrow = show_arrow) )

return ''.join(ret)

def __format_line(self, tpl_line, filename, lineno, line, arrow = False):

bp_mark = ""

bp_mark_color = ""

scheme = self.color_scheme_table.active_scheme_name

new_line, err = self.parser.format2(line, 'str', scheme)

if not err: line = new_line

bp = None

if lineno in self.get_file_breaks(filename):

bps = self.get_breaks(filename, lineno)

bp = bps[-1]

if bp:

Colors = self.color_scheme_table.active_colors

bp_mark = str(bp.number)

bp_mark_color = Colors.breakpoint_enabled

if not bp.enabled:

bp_mark_color = Colors.breakpoint_disabled

numbers_width = 7

if arrow:

# This is the line with the error

pad = numbers_width - len(str(lineno)) - len(bp_mark)

if pad >= 3:

marker = '-'*(pad-3) + '-> '

elif pad == 2:

marker = '> '

elif pad == 1:

marker = '>'

else:

marker = ''

num = '%s%s' % (marker, str(lineno))

line = tpl_line % (bp_mark_color + bp_mark, num, line)

else:

num = '%*s' % (numbers_width - len(bp_mark), str(lineno))

line = tpl_line % (bp_mark_color + bp_mark, num, line)

return line

def list_command_pydb(self, arg):

"""List command to use if we have a newer pydb installed"""

filename, first, last = OldPdb.parse_list_cmd(self, arg)

if filename is not None:

self.print_list_lines(filename, first, last)

def print_list_lines(self, filename, first, last):

"""The printing (as opposed to the parsing part of a 'list'

try:

Colors = self.color_scheme_table.active_colors

ColorsNormal = Colors.Normal

tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)

tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)

src = []

for lineno in range(first, last+1):

line = linecache.getline(filename, lineno)

if not line:

break

if lineno == self.curframe.f_lineno:

line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)

else:

line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)

src.append(line)

self.lineno = lineno

print >>io.stdout, ''.join(src)

except KeyboardInterrupt:

pass

def do_list(self, arg):

self.lastcmd = 'list'

last = None

if arg:

try:

x = eval(arg, {}, {})

if type(x) == type(()):

first, last = x

first = int(first)

last = int(last)

if last < first:

# Assume it's a count

last = first + last

else:

first = max(1, int(x) - 5)

except:

print '*** Error in argument:', `arg`

return

elif self.lineno is None:

first = max(1, self.curframe.f_lineno - 5)

else:

first = self.lineno + 1

if last is None:

last = first + 10

self.print_list_lines(self.curframe.f_code.co_filename, first, last)

# vds: >>

lineno = first

filename = self.curframe.f_code.co_filename

self.shell.hooks.synchronize_with_editor(filename, lineno, 0)

# vds: <<

do_l = do_list

def do_pdef(self, arg):

"""The debugger interface to magic_pdef"""

namespaces = [('Locals', self.curframe.f_locals),

('Globals', self.curframe.f_globals)]

self.shell.magic_pdef(arg, namespaces=namespaces)

def do_pdoc(self, arg):

"""The debugger interface to magic_pdoc"""

namespaces = [('Locals', self.curframe.f_locals),

('Globals', self.curframe.f_globals)]

self.shell.magic_pdoc(arg, namespaces=namespaces)

def do_pinfo(self, arg):

"""The debugger equivalant of ?obj"""

namespaces = [('Locals', self.curframe.f_locals),

('Globals', self.curframe.f_globals)]

self.shell.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)

def checkline(self, filename, lineno):

"""Check whether specified line seems to be executable.

#######################################################################

# XXX Hack! Use python-2.5 compatible code for this call, because with

# all of our changes, we've drifted from the pdb api in 2.6. For now,

# changing:

#

#line = linecache.getline(filename, lineno, self.curframe.f_globals)

# to:

#

line = linecache.getline(filename, lineno)

#

# does the trick. But in reality, we need to fix this by reconciling

# our updates with the new Pdb APIs in Python 2.6.

#

# End hack. The rest of this method is copied verbatim from 2.6 pdb.py

#######################################################################

if not line:

print >>self.stdout, 'End of file'

return 0

line = line.strip()

# Don't allow setting breakpoint at a blank line

if (not line or (line[0] == '#') or

(line[:3] == '"""') or line[:3] == "'''"):

print >>self.stdout, '*** Blank or comment'

return 0