from inspect import CO_GENERATOR, CO_COROUTINE, CO_ASYNC_GENERATOR
__all__ = ["BdbQuit", "Bdb", "Breakpoint"]
GENERATOR_AND_COROUTINE_FLAGS = CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR
class BdbQuit(Exception):
"""Exception to give up completely."""
"""Generic Python debugger base class.
This class takes care of details of the trace facility;
a derived class should implement user interaction.
The standard debugger class (pdb.Pdb) is an example.
The optional skip argument must be an iterable of glob-style
module name patterns. The debugger will not step into frames
that originate in a module that matches one of these patterns.
Whether a frame is considered to originate in a certain module
is determined by the __name__ in the frame globals.
def __init__(self, skip=None):
self.skip = set(skip) if skip else None
self.frame_returning = None
def canonic(self, filename):
"""Return canonical form of filename.
For real filenames, the canonical form is a case-normalized (on
case insensitive filesystems) absolute path. 'Filenames' with
angle brackets, such as "<stdin>", generated in interactive
mode, are returned unchanged.
if filename == "<" + filename[1:-1] + ">":
canonic = self.fncache.get(filename)
canonic = os.path.abspath(filename)
canonic = os.path.normcase(canonic)
self.fncache[filename] = canonic
"""Set values of attributes as ready to start debugging."""
self._set_stopinfo(None, None)
def trace_dispatch(self, frame, event, arg):
"""Dispatch a trace function for debugged frames based on the event.
This function is installed as the trace function for debugged
frames. Its return value is the new trace function, which is
usually itself. The default implementation decides how to
dispatch a frame, depending on the type of event (passed in as a
string) that is about to be executed.
The event can be one of the following:
line: A new line of code is going to be executed.
call: A function is about to be called or another code block
return: A function or other code block is about to return.
exception: An exception has occurred.
c_call: A C function is about to be called.
c_return: A C function has returned.
c_exception: A C function has raised an exception.
For the Python events, specialized functions (see the dispatch_*()
methods) are called. For the C events, no action is taken.
The arg parameter depends on the previous event.
return self.dispatch_line(frame)
return self.dispatch_call(frame, arg)
return self.dispatch_return(frame, arg)
return self.dispatch_exception(frame, arg)
return self.trace_dispatch
if event == 'c_exception':
return self.trace_dispatch
return self.trace_dispatch
print('bdb.Bdb.dispatch: unknown debugging event:', repr(event))
return self.trace_dispatch
def dispatch_line(self, frame):
"""Invoke user function and return trace function for line event.
If the debugger stops on the current line, invoke
self.user_line(). Raise BdbQuit if self.quitting is set.
Return self.trace_dispatch to continue tracing in this scope.
if self.stop_here(frame) or self.break_here(frame):
if self.quitting: raise BdbQuit
return self.trace_dispatch
def dispatch_call(self, frame, arg):
"""Invoke user function and return trace function for call event.
If the debugger stops on this function call, invoke
self.user_call(). Raise BbdQuit if self.quitting is set.
Return self.trace_dispatch to continue tracing in this scope.
# XXX 'arg' is no longer used
if self.botframe is None:
# First call of dispatch since reset()
self.botframe = frame.f_back # (CT) Note that this may also be None!
return self.trace_dispatch
if not (self.stop_here(frame) or self.break_anywhere(frame)):
# No need to trace this function
# Ignore call events in generator except when stepping.
if self.stopframe and frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS:
return self.trace_dispatch
self.user_call(frame, arg)
if self.quitting: raise BdbQuit
return self.trace_dispatch
def dispatch_return(self, frame, arg):
"""Invoke user function and return trace function for return event.
If the debugger stops on this function return, invoke
self.user_return(). Raise BdbQuit if self.quitting is set.
Return self.trace_dispatch to continue tracing in this scope.
if self.stop_here(frame) or frame == self.returnframe:
# Ignore return events in generator except when stepping.
if self.stopframe and frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS:
return self.trace_dispatch
self.frame_returning = frame
self.user_return(frame, arg)
self.frame_returning = None
if self.quitting: raise BdbQuit
# The user issued a 'next' or 'until' command.
if self.stopframe is frame and self.stoplineno != -1:
self._set_stopinfo(None, None)
return self.trace_dispatch
def dispatch_exception(self, frame, arg):
"""Invoke user function and return trace function for exception event.
If the debugger stops on this exception, invoke
self.user_exception(). Raise BdbQuit if self.quitting is set.
Return self.trace_dispatch to continue tracing in this scope.
if self.stop_here(frame):
# When stepping with next/until/return in a generator frame, skip
# the internal StopIteration exception (with no traceback)
# triggered by a subiterator run with the 'yield from' statement.
if not (frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS
and arg[0] is StopIteration and arg[2] is None):
self.user_exception(frame, arg)
if self.quitting: raise BdbQuit
# Stop at the StopIteration or GeneratorExit exception when the user
# has set stopframe in a generator by issuing a return command, or a
# next/until command at the last statement in the generator before the
elif (self.stopframe and frame is not self.stopframe
and self.stopframe.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS
and arg[0] in (StopIteration, GeneratorExit)):
self.user_exception(frame, arg)
if self.quitting: raise BdbQuit
return self.trace_dispatch
# Normally derived classes don't override the following
# methods, but they may if they want to redefine the
# definition of stopping and breakpoints.
def is_skipped_module(self, module_name):
"Return True if module_name matches any skip pattern."
if module_name is None: # some modules do not have names
for pattern in self.skip:
if fnmatch.fnmatch(module_name, pattern):
def stop_here(self, frame):
"Return True if frame is below the starting frame in the stack."
# (CT) stopframe may now also be None, see dispatch_call.
# (CT) the former test for None is therefore removed from here.
self.is_skipped_module(frame.f_globals.get('__name__')):
if frame is self.stopframe:
if self.stoplineno == -1:
return frame.f_lineno >= self.stoplineno
def break_here(self, frame):
"""Return True if there is an effective breakpoint for this line.
Check for line or function breakpoint and if in effect.
Delete temporary breakpoints if effective() says to.
filename = self.canonic(frame.f_code.co_filename)
if filename not in self.breaks:
if lineno not in self.breaks[filename]:
# The line itself has no breakpoint, but maybe the line is the
# first line of a function with breakpoint set by function name.
lineno = frame.f_code.co_firstlineno
if lineno not in self.breaks[filename]:
# flag says ok to delete temp. bp
(bp, flag) = effective(filename, lineno, frame)
self.currentbp = bp.number
if (flag and bp.temporary):
self.do_clear(str(bp.number))
"""Remove temporary breakpoint.
Must implement in derived classes or get NotImplementedError.
raise NotImplementedError("subclass of bdb must implement do_clear()")
def break_anywhere(self, frame):
"""Return True if there is any breakpoint for frame's filename.
return self.canonic(frame.f_code.co_filename) in self.breaks
# Derived classes should override the user_* methods
def user_call(self, frame, argument_list):
"""Called if we might stop in a function."""
def user_line(self, frame):
"""Called when we stop or break at a line."""
def user_return(self, frame, return_value):
"""Called when a return trap is set here."""
def user_exception(self, frame, exc_info):
"""Called when we stop on an exception."""
def _set_stopinfo(self, stopframe, returnframe, stoplineno=0):
"""Set the attributes for stopping.
If stoplineno is greater than or equal to 0, then stop at line
greater than or equal to the stopline. If stoplineno is -1, then
self.stopframe = stopframe
self.returnframe = returnframe
# stoplineno >= 0 means: stop at line >= the stoplineno
# stoplineno -1 means: don't stop at all
self.stoplineno = stoplineno
# Derived classes and clients can call the following methods
# to affect the stepping state.
def set_until(self, frame, lineno=None):
"""Stop when the line with the lineno greater than the current one is
reached or when returning from current frame."""
# the name "until" is borrowed from gdb
lineno = frame.f_lineno + 1
self._set_stopinfo(frame, frame, lineno)
"""Stop after one line of code."""
# Issue #13183: pdb skips frames after hitting a breakpoint and running
# Restore the trace function in the caller (that may not have been set
# for performance reasons) when returning from the current frame.
caller_frame = self.frame_returning.f_back
if caller_frame and not caller_frame.f_trace:
caller_frame.f_trace = self.trace_dispatch
self._set_stopinfo(None, None)
def set_next(self, frame):
"""Stop on the next line in or below the given frame."""
self._set_stopinfo(frame, None)
def set_return(self, frame):
"""Stop when returning from the given frame."""
if frame.f_code.co_flags & GENERATOR_AND_COROUTINE_FLAGS:
self._set_stopinfo(frame, None, -1)
self._set_stopinfo(frame.f_back, frame)
def set_trace(self, frame=None):
"""Start debugging from frame.
If frame is not specified, debugging starts from caller's frame.
frame = sys._getframe().f_back
frame.f_trace = self.trace_dispatch
sys.settrace(self.trace_dispatch)
"""Stop only at breakpoints or when finished.
If there are no breakpoints, set the system trace function to None.
# Don't stop except at breakpoints or when finished
self._set_stopinfo(self.botframe, None, -1)
# no breakpoints; run without debugger overhead
frame = sys._getframe().f_back
while frame and frame is not self.botframe:
"""Set quitting attribute to True.
Raises BdbQuit exception in the next call to a dispatch_*() method.
self.stopframe = self.botframe
# Derived classes and clients can call the following methods
# to manipulate breakpoints. These methods return an
# error message if something went wrong, None if all is well.
# Set_break prints out the breakpoint line and file:lineno.
# Call self.get_*break*() to see the breakpoints or better
# for bp in Breakpoint.bpbynumber: if bp: bp.bpprint().
def set_break(self, filename, lineno, temporary=False, cond=None,
"""Set a new breakpoint for filename:lineno.
If lineno doesn't exist for the filename, return an error message.
The filename should be in canonical form.
filename = self.canonic(filename)
import linecache # Import as late as possible
line = linecache.getline(filename, lineno)
return 'Line %s:%d does not exist' % (filename, lineno)
list = self.breaks.setdefault(filename, [])
bp = Breakpoint(filename, lineno, temporary, cond, funcname)
def _prune_breaks(self, filename, lineno):
"""Prune breakpoints for filename:lineno.
A list of breakpoints is maintained in the Bdb instance and in
the Breakpoint class. If a breakpoint in the Bdb instance no
longer exists in the Breakpoint class, then it's removed from the
if (filename, lineno) not in Breakpoint.bplist:
self.breaks[filename].remove(lineno)
if not self.breaks[filename]:
del self.breaks[filename]
def clear_break(self, filename, lineno):
"""Delete breakpoints for filename:lineno.
If no breakpoints were set, return an error message.
filename = self.canonic(filename)
if filename not in self.breaks:
return 'There are no breakpoints in %s' % filename
if lineno not in self.breaks[filename]:
return 'There is no breakpoint at %s:%d' % (filename, lineno)
# If there's only one bp in the list for that file,line
# pair, then remove the breaks entry
for bp in Breakpoint.bplist[filename, lineno][:]:
self._prune_breaks(filename, lineno)
def clear_bpbynumber(self, arg):
"""Delete a breakpoint by its index in Breakpoint.bpbynumber.
If arg is invalid, return an error message.
bp = self.get_bpbynumber(arg)
except ValueError as err:
self._prune_breaks(bp.file, bp.line)
def clear_all_file_breaks(self, filename):
"""Delete all breakpoints in filename.
If none were set, return an error message.
filename = self.canonic(filename)
if filename not in self.breaks:
return 'There are no breakpoints in %s' % filename
for line in self.breaks[filename]:
blist = Breakpoint.bplist[filename, line]
del self.breaks[filename]
def clear_all_breaks(self):
"""Delete all existing breakpoints.
If none were set, return an error message.
return 'There are no breakpoints'
for bp in Breakpoint.bpbynumber:
def get_bpbynumber(self, arg):
"""Return a breakpoint by its index in Breakpoint.bybpnumber.
For invalid arg values or if the breakpoint doesn't exist,
raise ValueError('Breakpoint number expected')
raise ValueError('Non-numeric breakpoint number %s' % arg) from None
bp = Breakpoint.bpbynumber[number]
raise ValueError('Breakpoint number %d out of range' % number) from None
raise ValueError('Breakpoint %d already deleted' % number)
def get_break(self, filename, lineno):
"""Return True if there is a breakpoint for filename:lineno."""
filename = self.canonic(filename)
return filename in self.breaks and \
lineno in self.breaks[filename]
def get_breaks(self, filename, lineno):
"""Return all breakpoints for filename:lineno.
If no breakpoints are set, return an empty list.
filename = self.canonic(filename)
return filename in self.breaks and \
lineno in self.breaks[filename] and \
Breakpoint.bplist[filename, lineno] or []
def get_file_breaks(self, filename):
"""Return all lines with breakpoints for filename.
If no breakpoints are set, return an empty list.
filename = self.canonic(filename)
if filename in self.breaks:
return self.breaks[filename]
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
