def testFrameSummaryEquality(self):
frames1 = tf_stack.extract_stack()
frames2 = tf_stack.extract_stack()
self.assertNotEqual(frames1[0], frames1[1])
self.assertEqual(frames1[0], frames1[0])
self.assertEqual(frames1[0], frames2[0])
def testFrameSummaryEquality(self):
frame0, frame1 = tf_stack.extract_stack(limit=2)
self.assertNotEqual(frame0, frame1)
self.assertEqual(frame0, frame0)
another_frame0, _ = tf_stack.extract_stack(limit=2)
self.assertEqual(frame0, another_frame0)
def testFrameSummaryEqualityAndHash(self):
# Both defined on the same line to produce identical stacks.
frame1, frame2 = tf_stack.extract_stack(), tf_stack.extract_stack()
self.assertEqual(len(frame1), len(frame2))
for f1, f2 in zip(frame1, frame2):
self.assertEqual(f1, f2)
self.assertEqual(hash(f1), hash(f1))
self.assertEqual(hash(f1), hash(f2))
self.assertEqual(frame1, frame2)
self.assertEqual(hash(tuple(frame1)), hash(tuple(frame2)))
def register(self, candidate, name=None):
"""Registers a Python object "candidate" for the given "name".
Args:
candidate: The candidate object to add to the registry.
name: An optional string specifying the registry key for the candidate.
If None, candidate.__name__ will be used.
Raises:
KeyError: If same name is used twice.
"""
if not name:
name = candidate.__name__
if name in self._registry:
(filename, line_number, function_name, _) = (
self._registry[name][_LOCATION_TAG])
raise KeyError("Registering two %s with name '%s'! "
"(Previous registration was in %s %s:%d)" %
(self._name, name, function_name, filename, line_number))
logging.vlog(1, "Registering %s (%s) in %s.", name, candidate, self._name)
# stack trace is [this_function, Register(), user_function,...]
# so the user function is #2.
stack = tf_stack.extract_stack()
stack_index = min(2, len(stack)-1)
if stack_index >= 0:
user_function = stack[stack_index]
location_tag = tf_stack.convert_stack([user_function])[0]
else:
location_tag = "UNKNOWN"
self._registry[name] = {_TYPE_TAG: candidate, _LOCATION_TAG: location_tag}
def _process_stack_frames(self):
"""Process stack frames.
Send the content of source-files, on a best-effort basis.
Returns:
A list of stack frame IDs.
"""
stack_frames = tf_stack.extract_stack()
stack_frame_ids = []
writer = None
for file_path, lineno, func, _ in stack_frames:
if (file_path, lineno, func) in self._stack_frame_to_id:
stack_frame_ids.append(self._stack_frame_to_id[(file_path,
lineno, func)])
continue
with self._stack_frame_to_id_lock:
if (file_path, lineno, func) not in self._stack_frame_to_id:
stack_frame_id = _get_id()
self._stack_frame_to_id[(file_path, lineno,
func)] = stack_frame_id
file_index = self._write_source_file_content(file_path)
file_line_col = graph_debug_info_pb2.GraphDebugInfo.FileLineCol(
file_index=file_index, line=lineno, func=func)
stack_frame_with_id = debug_event_pb2.StackFrameWithId(
id=stack_frame_id, file_line_col=file_line_col)
writer = self.get_writer()
writer.WriteStackFrameWithId(stack_frame_with_id)
stack_frame_ids.append(self._stack_frame_to_id[(file_path,
lineno, func)])
code_location = debug_event_pb2.CodeLocation(
host_name=self._hostname, stack_frame_ids=stack_frame_ids)
return code_location
def register(self, candidate, name=None):
"""Registers a Python object "candidate" for the given "name".
Args:
candidate: The candidate object to add to the registry.
name: An optional string specifying the registry key for the candidate.
If None, candidate.__name__ will be used.
Raises:
KeyError: If same name is used twice.
"""
if not name:
name = candidate.__name__
if name in self._registry:
frame = self._registry[name][_LOCATION_TAG]
raise KeyError(
"Registering two %s with name '%s'! "
"(Previous registration was in %s %s:%d)" %
(self._name, name, frame.name, frame.filename, frame.lineno))
logging.vlog(1, "Registering %s (%s) in %s.", name, candidate,
self._name)
# stack trace is [this_function, Register(), user_function,...]
# so the user function is #2.
stack = tf_stack.extract_stack(limit=3)
stack_index = min(2, len(stack) - 1)
if stack_index >= 0:
location_tag = stack[stack_index]
else:
location_tag = ("UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN",
"UNKNOWN")
self._registry[name] = {
_TYPE_TAG: candidate,
_LOCATION_TAG: location_tag
}
def register(self, candidate, name=None):
"""Registers a Python object "candidate" for the given "name".
Args:
candidate: The candidate object to add to the registry.
name: An optional string specifying the registry key for the candidate.
If None, candidate.__name__ will be used.
Raises:
KeyError: If same name is used twice.
"""
if not name:
name = candidate.__name__
if name in self._registry:
(filename, line_number, function_name,
_) = (self._registry[name][_LOCATION_TAG])
raise KeyError(
"Registering two %s with name '%s'! "
"(Previous registration was in %s %s:%d)" %
(self._name, name, function_name, filename, line_number))
logging.vlog(1, "Registering %s (%s) in %s.", name, candidate,
self._name)
# stack trace is [this_function, Register(), user_function,...]
# so the user function is #2.
stack = tf_stack.extract_stack()
user_function = stack[2]
location_tag = tf_stack.convert_stack([user_function])[0]
self._registry[name] = {
_TYPE_TAG: candidate,
_LOCATION_TAG: location_tag
}
def _call_location():
# We want to get stack frame 3 frames up from current frame,
# i.e. above __getattr__, _tfmw_add_deprecation_warning,
# and _call_location calls.
stack = tf_stack.extract_stack(limit=4)
if not stack: # should never happen as we're in a function
return 'UNKNOWN'
frame = stack[0]
return '{}:{}'.format(frame.filename, frame.lineno)
def _call_location(outer=False):
"""Returns call location given level up from current call."""
stack = tf_stack.extract_stack(limit=4)
length = len(stack)
if length == 0: # should never happen as we're in a function
return 'UNKNOWN'
index = length - 4 if outer else length - 3
if index < 0:
index = 0
frame = stack[index]
return '{}:{}'.format(frame.filename, frame.lineno)
def _call_location(outer=False):
"""Returns call location given level up from current call."""
stack = tf_stack.extract_stack()
length = len(stack)
if length == 0: # should never happen as we're in a function
return 'UNKNOWN'
index = length-4 if outer else length-3
if index < 0:
index = 0
frame = stack[index]
return '{filename}:{lineno}'.format(filename=frame[0], lineno=frame[1])
def make_decorator(target,
decorator_func,
decorator_name=None,
decorator_doc='',
decorator_argspec=None):
"""Make a decorator from a wrapper and a target.
Args:
target: The final callable to be wrapped.
decorator_func: The wrapper function.
decorator_name: The name of the decorator. If `None`, the name of the
function calling make_decorator.
decorator_doc: Documentation specific to this application of
`decorator_func` to `target`.
decorator_argspec: The new callable signature of this decorator.
Returns:
The `decorator_func` argument with new metadata attached.
"""
if decorator_name is None:
frame = tf_stack.extract_stack(limit=2)[0]
decorator_name = frame[2] # Caller's name
decorator = TFDecorator(decorator_name, target, decorator_doc,
decorator_argspec)
setattr(decorator_func, '_tf_decorator', decorator)
# Objects that are callables (e.g., a functools.partial object) may not have
# the following attributes.
if hasattr(target, '__name__'):
decorator_func.__name__ = target.__name__
if hasattr(target, '__qualname__'):
decorator_func.__qualname__ = target.__qualname__
if hasattr(target, '__module__'):
decorator_func.__module__ = target.__module__
if hasattr(target, '__dict__'):
# Copy dict entries from target which are not overridden by decorator_func.
for name in target.__dict__:
if name not in decorator_func.__dict__:
decorator_func.__dict__[name] = target.__dict__[name]
if hasattr(target, '__doc__'):
decorator_func.__doc__ = decorator.__doc__
decorator_func.__wrapped__ = target
# Keeping a second handle to `target` allows callers to detect whether the
# decorator was modified using `rewrap`.
decorator_func.__original_wrapped__ = target
return decorator_func
def make_decorator(target,
decorator_func,
decorator_name=None,
decorator_doc='',
decorator_argspec=None):
"""Make a decorator from a wrapper and a target.
Args:
target: The final callable to be wrapped.
decorator_func: The wrapper function.
decorator_name: The name of the decorator. If `None`, the name of the
function calling make_decorator.
decorator_doc: Documentation specific to this application of
`decorator_func` to `target`.
decorator_argspec: The new callable signature of this decorator.
Returns:
The `decorator_func` argument with new metadata attached.
"""
if decorator_name is None:
frame = tf_stack.extract_stack(limit=2)[0]
decorator_name = frame[2] # Caller's name
decorator = TFDecorator(decorator_name, target, decorator_doc,
decorator_argspec)
setattr(decorator_func, '_tf_decorator', decorator)
# Objects that are callables (e.g., a functools.partial object) may not have
# the following attributes.
if hasattr(target, '__name__'):
decorator_func.__name__ = target.__name__
if hasattr(target, '__module__'):
decorator_func.__module__ = target.__module__
if hasattr(target, '__dict__'):
# Copy dict entries from target which are not overridden by decorator_func.
for name in target.__dict__:
if name not in decorator_func.__dict__:
decorator_func.__dict__[name] = target.__dict__[name]
if hasattr(target, '__doc__'):
decorator_func.__doc__ = decorator.__doc__
decorator_func.__wrapped__ = target
# Keeping a second handle to `target` allows callers to detect whether the
# decorator was modified using `rewrap`.
decorator_func.__original_wrapped__ = target
return decorator_func
def set_filename_and_line_from_caller(self, offset=0):
"""Set filename and line using the caller's stack frame.
If the requested stack information is not available, a heuristic may
be applied and self.HEURISTIC USED will be returned. If the heuristic
fails then no change will be made to the filename and lineno members
(None by default) and self.FAILURE will be returned.
Args:
offset: Integer. If 0, the caller's stack frame is used. If 1,
the caller's caller's stack frame is used. Larger values are
permissible but if out-of-range (larger than the number of stack
frames available) the outermost stack frame will be used.
Returns:
TraceableObject.SUCCESS if appropriate stack information was found,
TraceableObject.HEURISTIC_USED if the offset was larger than the stack,
and TraceableObject.FAILURE if the stack was empty.
"""
# Offset is defined in "Args" as relative to the caller. We are one frame
# beyond the caller.
local_offset = offset + 1
frame_records = tf_stack.extract_stack(
limit=local_offset + 1)
if not frame_records:
return self.FAILURE
if len(frame_records) > local_offset:
frame = frame_records[len(frame_records) - (local_offset + 1)]
self.filename = frame.filename
self.lineno = frame.lineno
return self.SUCCESS
else:
# If the offset is too large then we use the largest offset possible,
# meaning we use the outermost stack frame at index 0.
frame = frame_records[0]
self.filename = frame.filename
self.lineno = frame.lineno
return self.HEURISTIC_USED
def set_filename_and_line_from_caller(self, offset=0):
"""Set filename and line using the caller's stack frame.
If the requested stack information is not available, a heuristic may
be applied and self.HEURISTIC USED will be returned. If the heuristic
fails then no change will be made to the filename and lineno members
(None by default) and self.FAILURE will be returned.
Args:
offset: Integer. If 0, the caller's stack frame is used. If 1,
the caller's caller's stack frame is used. Larger values are
permissible but if out-of-range (larger than the number of stack
frames available) the outermost stack frame will be used.
Returns:
TraceableObject.SUCCESS if appropriate stack information was found,
TraceableObject.HEURISTIC_USED if the offset was larger than the stack,
and TraceableObject.FAILURE if the stack was empty.
"""
# Offset is defined in "Args" as relative to the caller. We are one frame
# beyond the caller.
local_offset = offset + 1
frame_records = tf_stack.extract_stack()
if not frame_records:
return self.FAILURE
if len(frame_records) >= local_offset:
# Negative indexing is one-indexed instead of zero-indexed.
negative_offset = -(local_offset + 1)
self.filename, self.lineno = frame_records[negative_offset][:2]
return self.SUCCESS
else:
# If the offset is too large then we use the largest offset possible,
# meaning we use the outermost stack frame at index 0.
self.filename, self.lineno = frame_records[0][:2]
return self.HEURISTIC_USED
def func(n):
if n == 0:
return tf_stack.extract_stack() # COMMENT
else:
return func(n - 1)
def testFormatStackSelfConsistency(self):
# Both defined on the same line to produce identical stacks.
stacks = tf_stack.extract_stack(), traceback.extract_stack()
self.assertEqual(traceback.format_list(stacks[0]),
traceback.format_list(stacks[1]))
def extract_stack(limit=None): # Both defined on the same line to produce identical stacks. return tf_stack.extract_stack(limit), traceback.extract_stack(limit)
def func():
trace = tf_stack.extract_stack() # COMMENT
frames = list(trace.get_user_frames())
return frames
def testLimit(self):
self.assertEmpty(tf_stack.extract_stack(limit=0))
self.assertLen(tf_stack.extract_stack(limit=1), 1)
self.assertEqual(
len(tf_stack.extract_stack(limit=-1)),
len(tf_stack.extract_stack()))
def _call_location(outer=False):
"""Returns call location given level up from current call."""
stack = tf_stack.extract_stack()
frame = stack[-4 if outer else -3]
return '{filename}:{lineno}'.format(filename=frame[0], lineno=frame[1])
def extract_stack(limit=None):
# Both defined on the same line to produce identical stacks.
return tf_stack.extract_stack(limit), traceback.extract_stack(limit) # pylint: disable=too-many-function-args
def testLastUserFrame(self): trace = tf_stack.extract_stack() # COMMENT frame = trace.last_user_frame() self.assertRegex(frame.line, "# COMMENT")
def _call_location(outer=False):
"""Returns call location given level up from current call."""
stack = tf_stack.extract_stack()
frame = stack[-4 if outer else -3]
return '{filename}:{lineno}'.format(filename=frame[0], lineno=frame[1])
def extract_stack(limit=None):
convert = tf_stack.convert_stack
# Both defined on the same line to produce identical stacks.
return convert(
tf_stack.extract_stack(limit)), traceback.extract_stack(limit)
