if not isinstance(args, tuple):

# args is not a tuple. This may be because we have become bound to a

# class, which has offset our arguments by one.

if isinstance(kwargs, tuple):

func, args = args, kwargs

kwargs = extra_args[0] if len(extra_args) > 0 else {}

def __init__(self, repr_value='', len_value=None):

self.repr_value = repr_value

self.len_value = len_value

def __repr__(self):

return self.repr_value

def __len__(self):

__slots__ = [

'breakpoint_id', 'filename', 'lineno', 'condition_kind', 'condition',

'pass_count_kind', 'pass_count', 'is_bound', 'last_condition_value',

'hit_count'

]

# For "when changed" breakpoints, this is used as the initial value of last_condition_value,

# such that it is guaranteed to not compare equal to any other value that it will get later.

_DUMMY_LAST_VALUE = object()

def __init__(self, breakpoint_id, filename, lineno, condition_kind, condition, pass_count_kind, pass_count):

self.breakpoint_id = breakpoint_id

self.filename = filename

self.lineno = lineno

self.condition_kind = condition_kind

self.condition = condition

self.pass_count_kind = pass_count_kind

self.pass_count = pass_count

self.is_bound = False

self.last_condition_value = BreakpointInfo._DUMMY_LAST_VALUE

self.hit_count = 0

@staticmethod

def find_by_id(breakpoint_id):

for line, bp_dict in BREAKPOINTS.items():

for (filename, bp_id), bp in bp_dict.items():

if bp_id == breakpoint_id:

return bp

"""context manager for send lock. Handles both acquiring/releasing the

def __enter__(self):

# mark that we're about to do socket I/O so we won't deliver

# debug events when we're debugging the standard library

cur_thread = get_thread_from_id(thread.get_ident())

if cur_thread is not None:

cur_thread.is_sending = True

send_lock.acquire()

def __exit__(self, exc_type, exc_value, tb):

send_lock.release()

# start sending debug events again

cur_thread = get_thread_from_id(thread.get_ident())

if cur_thread is not None:

cur_thread.is_sending = False

if exc_type is not None:

detach_threads()

detach_process()

# swallow the exception, we're no longer debugging

types.FunctionType,

types.MethodType,

types.BuiltinFunctionType,

type("".__repr__), # method-wrapper

def is_repr_round_tripping(x):

# Do exact type checks here - subclasses can override __repr__.

if type(x) in TYPES_WITH_ROUND_TRIPPING_REPR:

return True

elif type(x) in COLLECTION_TYPES_WITH_ROUND_TRIPPING_REPR:

# All standard sequence types are round-trippable if their elements are.

return all((is_repr_round_tripping(item) for item in x))

else:

return False

if is_repr_round_tripping(x):

return x

else:

THREADS_LOCK.acquire()

try:

return THREADS.get(id)

finally:

parent, name = path.split(path.abspath(filename))

if parent in KNOWN_DIRECTORIES:

return False

elif parent in KNOWN_ZIPS:

return True

elif path.isdir(parent):

KNOWN_DIRECTORIES.add(parent)

return False

else:

KNOWN_ZIPS.add(parent)

try:

return frame.f_builtins.get(bits)

except:

# http://ironpython.codeplex.com/workitem/30908

builtins = frame.f_globals['__builtins__']

if not isinstance(builtins, dict):

builtins = builtins.__dict__

bits = name.split('.')

obj = frame.f_locals.get(bits[0]) or frame.f_globals.get(bits[0]) or lookup_builtin(bits[0], frame)

bits.pop(0)

while bits and obj is not None and type(obj) is types.ModuleType:

obj = getattr(obj, bits.pop(0), None)

if exc_type.__module__ == _EXCEPTIONS_MODULE:

return exc_type.__name__

else:

BUILT_IN_HANDLERS = {

path.normcase('<frozen importlib._bootstrap>'): ((None, None, '*'),),

path.normcase('build\\bdist.win32\\egg\\pkg_resources.py'): ((None, None, '*'),),

path.normcase('build\\bdist.win-amd64\\egg\\pkg_resources.py'): ((None, None, '*'),),

}

def __init__(self):

self.default_mode = BREAK_MODE_UNHANDLED

self.break_on = { }

self.handler_cache = dict(self.BUILT_IN_HANDLERS)

self.handler_lock = thread.allocate_lock()

self.add_exception('exceptions.IndexError', BREAK_MODE_NEVER)

self.add_exception('builtins.IndexError', BREAK_MODE_NEVER)

self.add_exception('exceptions.KeyError', BREAK_MODE_NEVER)

self.add_exception('builtins.KeyError', BREAK_MODE_NEVER)

self.add_exception('exceptions.AttributeError', BREAK_MODE_NEVER)

self.add_exception('builtins.AttributeError', BREAK_MODE_NEVER)

self.add_exception('exceptions.StopIteration', BREAK_MODE_NEVER)

self.add_exception('builtins.StopIteration', BREAK_MODE_NEVER)

self.add_exception('exceptions.GeneratorExit', BREAK_MODE_NEVER)

self.add_exception('builtins.GeneratorExit', BREAK_MODE_NEVER)

def clear(self):

self.default_mode = BREAK_MODE_UNHANDLED

self.break_on.clear()

self.handler_cache = dict(self.BUILT_IN_HANDLERS)

def should_break(self, thread, ex_type, ex_value, trace):

probe_stack()

name = get_exception_name(ex_type)

mode = self.break_on.get(name, self.default_mode)

break_type = BREAK_TYPE_NONE

if mode & BREAK_MODE_ALWAYS:

if self.is_handled(thread, ex_type, ex_value, trace):

break_type = BREAK_TYPE_HANDLED

else:

break_type = BREAK_TYPE_UNHANDLED

elif (mode & BREAK_MODE_UNHANDLED) and not self.is_handled(thread, ex_type, ex_value, trace):

break_type = BREAK_TYPE_UNHANDLED

if break_type:

if issubclass(ex_type, SystemExit):

if not BREAK_ON_SYSTEMEXIT_ZERO:

if ((isinstance(ex_value, int) and not ex_value) or

(isinstance(ex_value, SystemExit) and not ex_value.code)):

break_type = BREAK_TYPE_NONE

return break_type

def is_handled(self, thread, ex_type, ex_value, trace):

if trace is None:

# get out if we didn't get a traceback

return False

if trace.tb_next is not None:

if should_send_frame(trace.tb_next.tb_frame) and should_debug_code(trace.tb_next.tb_frame.f_code):

# don't break if this is not the top of the traceback,

# unless the previous frame was not debuggable

return True

cur_frame = trace.tb_frame

while should_send_frame(cur_frame) and cur_frame.f_code is not None and cur_frame.f_code.co_filename is not None:

filename = path.normcase(cur_frame.f_code.co_filename)

if is_file_in_zip(filename):

# File is in a zip, so assume it handles exceptions

return True

if not is_same_py_file(filename, __file__):

handlers = self.handler_cache.get(filename)

if handlers is None:

# req handlers for this file from the debug engine

self.handler_lock.acquire()

with _SendLockCtx:

write_bytes(conn, REQH)

write_string(conn, filename)

# wait for the handler data to be received

self.handler_lock.acquire()

self.handler_lock.release()

handlers = self.handler_cache.get(filename)

if handlers is None:

# no code available, so assume unhandled

return False

line = cur_frame.f_lineno

for line_start, line_end, expressions in handlers:

if line_start is None or line_start <= line < line_end:

if '*' in expressions:

return True

for text in expressions:

try:

res = lookup_local(cur_frame, text)

if res is not None and issubclass(ex_type, res):

return True

except:

pass

cur_frame = cur_frame.f_back

return False

def add_exception(self, name, mode=BREAK_MODE_UNHANDLED):

if name.startswith(_EXCEPTIONS_MODULE + '.'):

name = name[len(_EXCEPTIONS_MODULE) + 1:]

"""helper to make sure we have enough stack space to proceed w/o corrupting

if depth == 0:

return

if not code or not code.co_filename:

return False

filename = path.normcase(code.co_filename)

if not DEBUG_STDLIB:

for prefix in PREFIXES:

if prefix != '' and filename.startswith(prefix):

return False

for dont_debug_file in DONT_DEBUG:

if is_same_py_file(filename, dont_debug_file):

return False

if is_file_in_zip(filename):

# file in inside an egg or zip, so we can't debug it

return False

vs_path_norm = path.normcase(vs_path)

local_path_norm = path.normcase(local_path)

if local_path_to_vs_path.get(local_path_norm) == vs_path_norm:

return True

# Walk the local filesystem from local_path up, matching agains win_path component by component,

# and stop when we no longer see an __init__.py. This should give a reasonably close approximation

# of matching the package name.

while True:

local_path, local_name = path.split(local_path)

vs_path, vs_name = ntpath.split(vs_path)

# Match the last component in the path. If one or both components are unavailable, then

# we have reached the root on the corresponding path without successfully matching.

if not local_name or not vs_name or path.normcase(local_name) != path.normcase(vs_name):

return False

# If we have an __init__.py, this module was inside the package, and we still need to match

# thatpackage, so walk up one level and keep matching. Otherwise, we've walked as far as we

# needed to, and matched all names on our way, so this is a match.

if not path.exists(path.join(local_path, '__init__.py')):

break

local_path_to_vs_path[local_path_norm] = vs_path_norm

THREADS_LOCK.acquire()

all_threads = list(THREADS.values())

THREADS_LOCK.release()

for cur_thread in all_threads:

if cur_thread is blocking_thread:

continue

cur_thread._block_starting_lock.acquire()

if not check_is_blocked or not cur_thread._is_blocked:

# release the lock, we're going to run user code to evaluate the frames

cur_thread._block_starting_lock.release()

frames = cur_thread.get_frame_list()

# re-acquire the lock and make sure we're still not blocked. If so send

# the frame list.

cur_thread._block_starting_lock.acquire()

if not check_is_blocked or not cur_thread._is_blocked:

cur_thread.send_frame_list(frames)

def __init__(self, filename):

self._line_locations = None

self.filename = filename

self.breakpoints = {}

def add_breakpoint(self, lineno, brkpt_id):

self.breakpoints[lineno] = brkpt_id

def remove_breakpoint(self, lineno):

del self.breakpoints[lineno]

@property

def line_locations(self):

if self._line_locations is None:

# we need to calculate our line number offset information

try:

contents = open(self.filename, 'rb')

except:

# file not available, locked, etc...

pass

else:

with contents:

line_info = []

file_len = 0

for line in contents:

if not line_info and line.startswith(BOM_UTF8):

line = line[3:] # Strip the BOM, Django seems to ignore this...

file_len += len(line)

line_info.append(file_len)

contents.close()

self._line_locations = line_info

return self._line_locations

def get_line_range(self, start, end):

line_locs = self.line_locations

if line_locs is not None:

low_line = bisect.bisect_right(line_locs, start)

hi_line = bisect.bisect_right(line_locs, end)

return low_line, hi_line

return (None, None)

def should_break(self, start, end):

low_line, hi_line = self.get_line_range(start, end)

if low_line is not None and hi_line is not None:

# low_line/hi_line is 0 based, self.breakpoints is 1 based

for i in xrange(low_line+1, hi_line+2):

bkpt_id = self.breakpoints.get(i)

if bkpt_id is not None:

return True, bkpt_id

if frame.f_code.co_name == 'render':

self_obj = frame.f_locals.get('self', None)

if self_obj is not None and type(self_obj).__name__ != 'TextNode':

source_obj = getattr(self_obj, 'source', None)

if source_obj is not None:

return source_obj

def __init__(self, real_frame):

self.real_frame = real_frame

self.f_lineno = real_frame.f_lineno + 1

def __getattr__(self, name):

def __init__(self, id = None):

if id is not None:

self.id = id

else:

self.id = thread.get_ident()

self._events = {'call' : self.handle_call,

'line' : self.handle_line,

'return' : self.handle_return,

'exception' : self.handle_exception,

'c_call' : self.handle_c_call,

'c_return' : self.handle_c_return,

'c_exception' : self.handle_c_exception,

}

self.cur_frame = None

self.stepping = STEPPING_NONE

self.unblock_work = None

self._block_lock = thread.allocate_lock()

self._block_lock.acquire()

self._block_starting_lock = thread.allocate_lock()

self._is_blocked = False

self._is_working = False

self.stopped_on_line = None

self.detach = False

self.trace_func = self.trace_func # replace self.trace_func w/ a bound method so we don't need to re-create these regularly

self.prev_trace_func = None

self.trace_func_stack = []

self.reported_process_loaded = False

self.django_stepping = None

self.is_sending = False

# stackless changes

if stackless is not None:

self._stackless_attach()

if sys.platform == 'cli':

self.frames = []

if sys.platform == 'cli':

# workaround an IronPython bug where we're sometimes missing the back frames

# http://ironpython.codeplex.com/workitem/31437

def push_frame(self, frame):

self.cur_frame = frame

self.frames.append(frame)

def pop_frame(self):

self.frames.pop()

self.cur_frame = self.frames[-1]

else:

def push_frame(self, frame):

self.cur_frame = frame

def pop_frame(self):

self.cur_frame = self.cur_frame.f_back

def _stackless_attach(self):

try:

stackless.tasklet.trace_function

except AttributeError:

# the tasklets need to be traced on a case by case basis

# sys.trace needs to be called within their calling context

def __call__(tsk, *args, **kwargs):

f = tsk.tempval

def new_f(old_f, args, kwargs):

sys.settrace(self.trace_func)

try:

if old_f is not None:

return old_f(*args, **kwargs)

finally:

sys.settrace(None)

tsk.tempval = new_f

stackless.tasklet.setup(tsk, f, args, kwargs)

return tsk

def settrace(tsk, tb):

if hasattr(tsk.frame, "f_trace"):

tsk.frame.f_trace = tb

sys.settrace(tb)

self.__oldstacklesscall__ = stackless.tasklet.__call__

stackless.tasklet.settrace = settrace

stackless.tasklet.__call__ = __call__

if sys.platform == 'cli':

self.frames = []

if sys.platform == 'cli':

# workaround an IronPython bug where we're sometimes missing the back frames

# http://ironpython.codeplex.com/workitem/31437

def push_frame(self, frame):

self.cur_frame = frame

self.frames.append(frame)

def pop_frame(self):

self.frames.pop()

self.cur_frame = self.frames[-1]

else:

def push_frame(self, frame):

self.cur_frame = frame

def pop_frame(self):

self.cur_frame = self.cur_frame.f_back

def context_dispatcher(self, old, new):

self.stepping = STEPPING_NONE

# for those tasklets that started before we started tracing

# we need to make sure that the trace is set by patching

# it in the context switch

if old and new:

if hasattr(new.frame, "f_trace") and not new.frame.f_trace:

sys.call_tracing(new.settrace,(self.trace_func,))

def _stackless_schedule_cb(self, prev, next):

current = stackless.getcurrent()

if not current:

return

current_tf = current.trace_function

try:

current.trace_function = None

self.stepping = STEPPING_NONE

# If the current frame has no trace function, we may need to get it

# from the previous frame, depending on how we ended up in the

# callback.

if current_tf is None:

f_back = current.frame.f_back

if f_back is not None:

current_tf = f_back.f_trace

if next is not None:

# Assign our trace function to the current stack

f = next.frame

if next is current:

f = f.f_back

while f:

if isinstance(f, types.FrameType):

f.f_trace = self.trace_func

f = f.f_back

next.trace_function = self.trace_func

finally:

current.trace_function = current_tf

def trace_func(self, frame, event, arg):

# If we're so far into process shutdown that sys is already gone, just stop tracing.

if sys is None:

return None

elif self.is_sending:

# https://pytools.codeplex.com/workitem/1864

# we're currently doing I/O w/ the socket, we don't want to deliver

# any breakpoints or async breaks because we'll deadlock. Continue

# to return the trace function so all of our frames remain

# balanced. A better way to deal with this might be to do

# sys.settrace(None) when we take the send lock, but that's much

# more difficult because our send context manager is used both

# inside and outside of the trace function, and so is used when

# tracing is enabled and disabled, and so it's very easy to get our

# current frame tracking to be thrown off...

return self.trace_func

try:

# if should_debug_code(frame.f_code) is not true during attach

# the current frame is None and a pop_frame will cause an exception and

# break the debugger

if self.cur_frame is None:

# happens during attach, we need frame for blocking

self.push_frame(frame)

if self.stepping == STEPPING_BREAK and should_debug_code(frame.f_code):

if self.detach:

if stackless is not None:

stackless.set_schedule_callback(None)

stackless.tasklet.__call__ = self.__oldstacklesscall__

sys.settrace(None)

return None

self.async_break()

return self._events[event](frame, arg)

except (StackOverflowException, KeyboardInterrupt):

# stack overflow, disable tracing

return self.trace_func

def handle_call(self, frame, arg):

self.push_frame(frame)

if DJANGO_BREAKPOINTS:

source_obj = get_django_frame_source(frame)

if source_obj is not None:

origin, (start, end) = source_obj

active_bps = DJANGO_BREAKPOINTS.get(origin.name.lower())

should_break = False

if active_bps is not None:

should_break, bkpt_id = active_bps.should_break(start, end)

if should_break:

probe_stack()

update_all_thread_stacks(self)

self.block(lambda: (report_breakpoint_hit(bkpt_id, self.id), mark_all_threads_for_break(skip_thread = self)))

if not should_break and self.django_stepping:

self.django_stepping = None

self.stepping = STEPPING_OVER

self.block_maybe_attach()

if frame.f_code.co_name == '<module>' and frame.f_code.co_filename not in ['<string>', '<stdin>']:

probe_stack()

code, module = new_module(frame)

if not DETACHED:

report_module_load(module)

# see if this module causes new break points to be bound

bound = set()

for pending_bp in PENDING_BREAKPOINTS:

if try_bind_break_point(code.co_filename, module, pending_bp):

bound.add(pending_bp)

PENDING_BREAKPOINTS.difference_update(bound)

stepping = self.stepping

if stepping is not STEPPING_NONE and should_debug_code(frame.f_code):

if stepping == STEPPING_INTO:

# block when we hit the 1st line, not when we're on the function def

self.stepping = STEPPING_OVER

# empty stopped_on_line so that we will break even if it is

# the same line

self.stopped_on_line = None

elif stepping >= STEPPING_OVER:

self.stepping += 1

elif stepping <= STEPPING_OUT:

self.stepping -= 1

if (sys.platform == 'cli' and

frame.f_code.co_name == '<module>' and

not IPY_SEEN_MODULES.TryGetValue(frame.f_code)[0]):

IPY_SEEN_MODULES.Add(frame.f_code, None)

# work around IronPython bug - http://ironpython.codeplex.com/workitem/30127

self.handle_line(frame, arg)

# forward call to previous trace function, if any, saving old trace func for when we return

old_trace_func = self.prev_trace_func

if old_trace_func is not None:

self.trace_func_stack.append(old_trace_func)

self.prev_trace_func = None # clear first incase old_trace_func stack overflows

self.prev_trace_func = old_trace_func(frame, 'call', arg)

return self.trace_func

def should_block_on_frame(self, frame):

if not should_debug_code(frame.f_code):

return False

# It is still possible that we're somewhere in standard library code, but that code was invoked by our

# internal debugger machinery (e.g. socket.sendall or text encoding while tee'ing print output to VS).

# We don't want to block on any of that, either, so walk the stack and see if we hit debugger frames

# at some point below the non-debugger ones.

while frame is not None:

# There is usually going to be a debugger frame at the very bottom of the stack - the one that

# invoked user code on this thread when starting debugging. If we reached that, then everything

# above is user code, so we know that we do want to block here.

if frame.f_code in DEBUG_ENTRYPOINTS:

break

# Otherwise, check if it's some other debugger code.

filename = path.normcase(frame.f_code.co_filename)

is_debugger_frame = False

for debugger_file in DONT_DEBUG:

if is_same_py_file(filename, debugger_file):

# If it is, then the frames above it on the stack that we have just walked through

# were for debugger internal purposes, and we do not want to block here.

return False

frame = frame.f_back

return True

def handle_line(self, frame, arg):

if not DETACHED:

# resolve whether step_complete and/or handling_breakpoints

step_complete = False

handle_breakpoints = True

stepping = self.stepping

if stepping is not STEPPING_NONE: # check for the common case of no stepping first...

if ((stepping == STEPPING_OVER or stepping == STEPPING_INTO) and frame.f_lineno != self.stopped_on_line):

if self.should_block_on_frame(frame): # don't step complete in our own debugger / non-user code

step_complete = True

elif stepping == STEPPING_LAUNCH_BREAK or stepping == STEPPING_ATTACH_BREAK:

# If launching rather than attaching, don't break into initial Python code needed to set things up

if stepping == STEPPING_LAUNCH_BREAK and (not MODULES or not self.should_block_on_frame(frame)):

handle_breakpoints = False

else:

step_complete = True

# handle breakpoints

hit_bp_id = None

if BREAKPOINTS and handle_breakpoints:

bp = BREAKPOINTS.get(frame.f_lineno)

if bp is not None:

for (filename, bp_id), bp in bp.items():

if filename != frame.f_code.co_filename:

# When the breakpoint is bound, the filename is updated to match co_filename of

# the module to which it was bound, so only exact matches are considered hits.

if bp.is_bound:

continue

# Otherwise, use relaxed path check that tries to handle differences between

# local and remote filesystems for remote scenarios:

if not breakpoint_path_match(filename, frame.f_code.co_filename):

continue

# If we got here, filename and line number both match.

# Check condition to see if we actually hit this breakpoint.

if bp.condition_kind != BREAKPOINT_CONDITION_ALWAYS:

try:

res = eval(bp.condition, frame.f_globals, frame.f_locals)