'format_exception_only', 'format_list', 'format_stack',

'format_tb', 'print_exc', 'format_exc', 'print_exception',

'print_last', 'print_stack', 'print_tb', 'clear_frames',

'FrameSummary', 'StackSummary', 'TracebackException',

"""Print the list of tuples as returned by extract_tb() or

if file is None:

file = sys.stderr

for item in StackSummary.from_list(extracted_list).format():

"""Format a list of tuples or FrameSummary objects for printing.

"""Print up to 'limit' stack trace entries from the traceback 'tb'.

"""

return StackSummary._extract_from_extended_frame_gen(

if (value is _sentinel) != (tb is _sentinel):

raise ValueError("Both or neither of value and tb must be given")

if value is tb is _sentinel:

if exc is not None:

if isinstance(exc, BaseException):

return exc, exc.__traceback__

raise TypeError(f'Exception expected for value, '

f'{type(exc).__name__} found')

else:

return None, None

file=None, chain=True):

"""Print exception up to 'limit' stack trace entries from 'tb' to 'file'.

value, tb = _parse_value_tb(exc, value, tb)

te = TracebackException(type(value), value, tb, limit=limit, compact=True)

chain=True):

"""Format a stack trace and the exception information.

value, tb = _parse_value_tb(exc, value, tb)

te = TracebackException(type(value), value, tb, limit=limit, compact=True)

"""Format the exception part of a traceback.

if value is _sentinel:

value = exc

te = TracebackException(type(value), value, None, compact=True)

valuestr = _safe_string(value, 'exception')

if value is None or not valuestr:

line = "%s\n" % etype

else:

line = "%s: %s\n" % (etype, valuestr)

try:

return func(value)

except:

"""This is a shorthand for 'print_exception(sys.last_type,

if not hasattr(sys, "last_type"):

raise ValueError("no last exception")

print_exception(sys.last_type, sys.last_value, sys.last_traceback,

"""Print a stack trace from its invocation point.

if f is None:

f = sys._getframe().f_back

"""Shorthand for 'format_list(extract_stack(f, limit))'."""

if f is None:

f = sys._getframe().f_back

"""Extract the raw traceback from the current stack frame.

if f is None:

f = sys._getframe().f_back

stack = StackSummary.extract(walk_stack(f), limit=limit)

stack.reverse()

"Clear all references to local variables in the frames of a traceback."

while tb is not None:

try:

tb.tb_frame.clear()

except RuntimeError:

# Ignore the exception raised if the frame is still executing.

pass

"""Information about a single frame from a traceback.

__slots__ = ('filename', 'lineno', 'end_lineno', 'colno', 'end_colno',

'name', '_line', 'locals')

def __init__(self, filename, lineno, name, *, lookup_line=True,

locals=None, line=None,

end_lineno=None, colno=None, end_colno=None):

"""Construct a FrameSummary.

self.filename = filename

self.lineno = lineno

self.name = name

self._line = line

if lookup_line:

self.line

self.locals = {k: repr(v) for k, v in locals.items()} if locals else None

self.end_lineno = end_lineno

self.colno = colno

self.end_colno = end_colno

def __eq__(self, other):

if isinstance(other, FrameSummary):

return (self.filename == other.filename and

self.lineno == other.lineno and

self.name == other.name and

self.locals == other.locals)

if isinstance(other, tuple):

return (self.filename, self.lineno, self.name, self.line) == other

return NotImplemented

def __getitem__(self, pos):

return (self.filename, self.lineno, self.name, self.line)[pos]

def __iter__(self):

return iter([self.filename, self.lineno, self.name, self.line])

def __repr__(self):

return "<FrameSummary file {filename}, line {lineno} in {name}>".format(

filename=self.filename, lineno=self.lineno, name=self.name)

def __len__(self):

return 4

@property

def _original_line(self):

# Returns the line as-is from the source, without modifying whitespace.

self.line

return self._line

@property

def line(self):

if self._line is None:

if self.lineno is None:

return None

self._line = linecache.getline(self.filename, self.lineno)

"""Walk a stack yielding the frame and line number for each frame.

if f is None:

f = sys._getframe().f_back.f_back.f_back.f_back

while f is not None:

yield f, f.f_lineno

"""Walk a traceback yielding the frame and line number for each frame.

while tb is not None:

yield tb.tb_frame, tb.tb_lineno

# Internal version of walk_tb that yields full code positions including

# end line and column information.

while tb is not None:

positions = _get_code_position(tb.tb_frame.f_code, tb.tb_lasti)

# Yield tb_lineno when co_positions does not have a line number to

# maintain behavior with walk_tb.

if positions[0] is None:

yield tb.tb_frame, (tb.tb_lineno, ) + positions[1:]

else:

yield tb.tb_frame, positions

if instruction_index < 0:

return (None, None, None, None)

positions_gen = code.co_positions()

"""A list of FrameSummary objects, representing a stack of frames."""

@classmethod

def extract(klass, frame_gen, *, limit=None, lookup_lines=True,

capture_locals=False):

"""Create a StackSummary from a traceback or stack object.

def extended_frame_gen():

for f, lineno in frame_gen:

yield f, (lineno, None, None, None)

return klass._extract_from_extended_frame_gen(

extended_frame_gen(), limit=limit, lookup_lines=lookup_lines,

capture_locals=capture_locals)

@classmethod

def _extract_from_extended_frame_gen(klass, frame_gen, *, limit=None,

lookup_lines=True, capture_locals=False):

# Same as extract but operates on a frame generator that yields

# (frame, (lineno, end_lineno, colno, end_colno)) in the stack.

# Only lineno is required, the remaining fields can be None if the

# information is not available.

if limit is None:

limit = getattr(sys, 'tracebacklimit', None)

if limit is not None and limit < 0:

limit = 0

if limit is not None:

if limit >= 0:

frame_gen = itertools.islice(frame_gen, limit)

else:

frame_gen = collections.deque(frame_gen, maxlen=-limit)

result = klass()

fnames = set()

for f, (lineno, end_lineno, colno, end_colno) in frame_gen:

co = f.f_code

filename = co.co_filename

name = co.co_name

fnames.add(filename)

linecache.lazycache(filename, f.f_globals)

# Must defer line lookups until we have called checkcache.

if capture_locals:

f_locals = f.f_locals

else:

f_locals = None

result.append(FrameSummary(

filename, lineno, name, lookup_line=False, locals=f_locals,

end_lineno=end_lineno, colno=colno, end_colno=end_colno))

for filename in fnames:

linecache.checkcache(filename)

# If immediate lookup was desired, trigger lookups now.

if lookup_lines:

for f in result:

f.line

return result

@classmethod

def from_list(klass, a_list):

"""

# While doing a fast-path check for isinstance(a_list, StackSummary) is

# appealing, idlelib.run.cleanup_traceback and other similar code may

# break this by making arbitrary frames plain tuples, so we need to

# check on a frame by frame basis.

result = StackSummary()

for frame in a_list:

if isinstance(frame, FrameSummary):

result.append(frame)

else:

filename, lineno, name, line = frame

result.append(FrameSummary(filename, lineno, name, line=line))

return result

def format_frame_summary(self, frame_summary):

"""Format the lines for a single FrameSummary.

row = []

row.append(' File "{}", line {}, in {}\n'.format(

frame_summary.filename, frame_summary.lineno, frame_summary.name))

if frame_summary.line:

stripped_line = frame_summary.line.strip()

row.append(' {}\n'.format(stripped_line))

line = frame_summary._original_line

orig_line_len = len(line)

frame_line_len = len(frame_summary.line.lstrip())

stripped_characters = orig_line_len - frame_line_len

if (

frame_summary.colno is not None

and frame_summary.end_colno is not None

):

start_offset = _byte_offset_to_character_offset(

line, frame_summary.colno)

end_offset = _byte_offset_to_character_offset(

line, frame_summary.end_colno)

code_segment = line[start_offset:end_offset]

anchors = None

if frame_summary.lineno == frame_summary.end_lineno:

with suppress(Exception):

anchors = _extract_caret_anchors_from_line_segment(code_segment)

else:

# Don't count the newline since the anchors only need to

# go up until the last character of the line.

end_offset = len(line.rstrip())

# show indicators if primary char doesn't span the frame line

if end_offset - start_offset < len(stripped_line) or (

anchors and anchors.right_start_offset - anchors.left_end_offset > 0):

# When showing this on a terminal, some of the non-ASCII characters

# might be rendered as double-width characters, so we need to take

# that into account when calculating the length of the line.

dp_start_offset = _display_width(line, start_offset) + 1

dp_end_offset = _display_width(line, end_offset) + 1

row.append(' ')

row.append(' ' * (dp_start_offset - stripped_characters))

if anchors:

dp_left_end_offset = _display_width(code_segment, anchors.left_end_offset)

dp_right_start_offset = _display_width(code_segment, anchors.right_start_offset)

row.append(anchors.primary_char * dp_left_end_offset)

row.append(anchors.secondary_char * (dp_right_start_offset - dp_left_end_offset))

row.append(anchors.primary_char * (dp_end_offset - dp_start_offset - dp_right_start_offset))

else:

row.append('^' * (dp_end_offset - dp_start_offset))

row.append('\n')

if frame_summary.locals:

for name, value in sorted(frame_summary.locals.items()):

row.append(' {name} = {value}\n'.format(name=name, value=value))

return ''.join(row)

def format(self):

"""Format the stack ready for printing.

result = []

last_file = None

last_line = None

last_name = None

count = 0

for frame_summary in self:

formatted_frame = self.format_frame_summary(frame_summary)

if formatted_frame is None:

continue

if (last_file is None or last_file != frame_summary.filename or

last_line is None or last_line != frame_summary.lineno or

last_name is None or last_name != frame_summary.name):

if count > _RECURSIVE_CUTOFF:

count -= _RECURSIVE_CUTOFF

result.append(

f' [Previous line repeated {count} more '

f'time{"s" if count > 1 else ""}]\n'

)

last_file = frame_summary.filename

last_line = frame_summary.lineno

last_name = frame_summary.name

count = 0

count += 1

if count > _RECURSIVE_CUTOFF:

continue

result.append(formatted_frame)

if count > _RECURSIVE_CUTOFF:

count -= _RECURSIVE_CUTOFF

result.append(

f' [Previous line repeated {count} more '

f'time{"s" if count > 1 else ""}]\n'

)

"_Anchors",

[

"left_end_offset",

"right_start_offset",

"primary_char",

"secondary_char",

],

defaults=["~", "^"]

import ast

try:

tree = ast.parse(segment)

except SyntaxError:

return None

if len(tree.body) != 1:

return None

normalize = lambda offset: _byte_offset_to_character_offset(segment, offset)

statement = tree.body[0]

match statement:

case ast.Expr(expr):

match expr:

case ast.BinOp():

operator_start = normalize(expr.left.end_col_offset)

operator_end = normalize(expr.right.col_offset)

operator_str = segment[operator_start:operator_end]

operator_offset = len(operator_str) - len(operator_str.lstrip())

left_anchor = expr.left.end_col_offset + operator_offset

right_anchor = left_anchor + 1

if (

operator_offset + 1 < len(operator_str)

and not operator_str[operator_offset + 1].isspace()

):

right_anchor += 1

while left_anchor < len(segment) and ((ch := segment[left_anchor]).isspace() or ch in ")#"):

left_anchor += 1

right_anchor += 1

return _Anchors(normalize(left_anchor), normalize(right_anchor))

case ast.Subscript():

left_anchor = normalize(expr.value.end_col_offset)

right_anchor = normalize(expr.slice.end_col_offset + 1)

while left_anchor < len(segment) and ((ch := segment[left_anchor]).isspace() or ch != "["):

left_anchor += 1

while right_anchor < len(segment) and ((ch := segment[right_anchor]).isspace() or ch != "]"):

right_anchor += 1

if right_anchor < len(segment):

right_anchor += 1

return _Anchors(left_anchor, right_anchor)

"""Calculate the extra amount of width space the given source

# Fast track for ASCII-only strings

if line.isascii():

return offset

import unicodedata

return sum(

2 if unicodedata.east_asian_width(char) in _WIDE_CHAR_SPECIFIERS else 1

for char in line[:offset]

def __init__(self):

self.seen = set()

self.exception_group_depth = 0

self.need_close = False

def indent(self):

return ' ' * (2 * self.exception_group_depth)

def emit(self, text_gen, margin_char=None):

if margin_char is None:

margin_char = '|'

indent_str = self.indent()

if self.exception_group_depth:

indent_str += margin_char + ' '

if isinstance(text_gen, str):

yield textwrap.indent(text_gen, indent_str, lambda line: True)

else:

for text in text_gen:

"""An exception ready for rendering.

def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,

lookup_lines=True, capture_locals=False, compact=False,

max_group_width=15, max_group_depth=10, _seen=None):

# NB: we need to accept exc_traceback, exc_value, exc_traceback to

# permit backwards compat with the existing API, otherwise we

# need stub thunk objects just to glue it together.

# Handle loops in __cause__ or __context__.

is_recursive_call = _seen is not None

if _seen is None:

_seen = set()

_seen.add(id(exc_value))

self.max_group_width = max_group_width

self.max_group_depth = max_group_depth

self.stack = StackSummary._extract_from_extended_frame_gen(

_walk_tb_with_full_positions(exc_traceback),

limit=limit, lookup_lines=lookup_lines,

capture_locals=capture_locals)

self.exc_type = exc_type

# Capture now to permit freeing resources: only complication is in the

# unofficial API _format_final_exc_line

self._str = _safe_string(exc_value, 'exception')

try:

self.__notes__ = getattr(exc_value, '__notes__', None)

except Exception as e:

self.__notes__ = [

f'Ignored error getting __notes__: {_safe_string(e, "__notes__", repr)}']

if exc_type and issubclass(exc_type, SyntaxError):

# Handle SyntaxError's specially

self.filename = exc_value.filename

lno = exc_value.lineno

self.lineno = str(lno) if lno is not None else None

end_lno = exc_value.end_lineno

self.end_lineno = str(end_lno) if end_lno is not None else None

self.text = exc_value.text

self.offset = exc_value.offset

self.end_offset = exc_value.end_offset

self.msg = exc_value.msg

if lookup_lines:

self._load_lines()

self.__suppress_context__ = \

exc_value.__suppress_context__ if exc_value is not None else False

# Convert __cause__ and __context__ to `TracebackExceptions`s, use a

# queue to avoid recursion (only the top-level call gets _seen == None)

if not is_recursive_call:

queue = [(self, exc_value)]

while queue:

te, e = queue.pop()

if (e and e.__cause__ is not None

and id(e.__cause__) not in _seen):

cause = TracebackException(

type(e.__cause__),

e.__cause__,

e.__cause__.__traceback__,

limit=limit,

lookup_lines=lookup_lines,

capture_locals=capture_locals,

max_group_width=max_group_width,

max_group_depth=max_group_depth,

_seen=_seen)

else:

cause = None

if compact:

need_context = (cause is None and

e is not None and

not e.__suppress_context__)

else:

need_context = True

if (e and e.__context__ is not None

and need_context and id(e.__context__) not in _seen):

context = TracebackException(

type(e.__context__),

e.__context__,

e.__context__.__traceback__,

limit=limit,

lookup_lines=lookup_lines,

capture_locals=capture_locals,

max_group_width=max_group_width,

max_group_depth=max_group_depth,

_seen=_seen)

else:

context = None

if e and isinstance(e, BaseExceptionGroup):

exceptions = []

for exc in e.exceptions:

texc = TracebackException(

type(exc),

exc,

exc.__traceback__,

limit=limit,

lookup_lines=lookup_lines,

capture_locals=capture_locals,

max_group_width=max_group_width,

max_group_depth=max_group_depth,

_seen=_seen)

exceptions.append(texc)

else:

exceptions = None

te.__cause__ = cause

te.__context__ = context

te.exceptions = exceptions

if cause:

queue.append((te.__cause__, e.__cause__))

if context:

queue.append((te.__context__, e.__context__))

if exceptions:

queue.extend(zip(te.exceptions, e.exceptions))

@classmethod

def from_exception(cls, exc, *args, **kwargs):

"""Create a TracebackException from an exception."""

return cls(type(exc), exc, exc.__traceback__, *args, **kwargs)

def _load_lines(self):

"""Private API. force all lines in the stack to be loaded."""

for frame in self.stack:

frame.line

def __eq__(self, other):

if isinstance(other, TracebackException):

return self.__dict__ == other.__dict__

return NotImplemented

def __str__(self):

return self._str

def format_exception_only(self):

"""Format the exception part of the traceback.

if self.exc_type is None:

yield _format_final_exc_line(None, self._str)

return

stype = self.exc_type.__qualname__

smod = self.exc_type.__module__

if smod not in ("__main__", "builtins"):

if not isinstance(smod, str):

smod = "<unknown>"

stype = smod + '.' + stype

if not issubclass(self.exc_type, SyntaxError):

yield _format_final_exc_line(stype, self._str)

else:

yield from self._format_syntax_error(stype)

if isinstance(self.__notes__, collections.abc.Sequence):

for note in self.__notes__:

note = _safe_string(note, 'note')

yield from [l + '\n' for l in note.split('\n')]

elif self.__notes__ is not None:

yield _safe_string(self.__notes__, '__notes__', func=repr)

def _format_syntax_error(self, stype):

"""Format SyntaxError exceptions (internal helper)."""

# Show exactly where the problem was found.

filename_suffix = ''

if self.lineno is not None:

yield ' File "{}", line {}\n'.format(

self.filename or "<string>", self.lineno)

elif self.filename is not None:

filename_suffix = ' ({})'.format(self.filename)

text = self.text

if text is not None:

# text = " foo\n"

# rtext = " foo"

# ltext = "foo"

rtext = text.rstrip('\n')

ltext = rtext.lstrip(' \n\f')

spaces = len(rtext) - len(ltext)

yield ' {}\n'.format(ltext)

if self.offset is not None:

offset = self.offset

end_offset = self.end_offset if self.end_offset not in {None, 0} else offset

if offset == end_offset or end_offset == -1:

end_offset = offset + 1

# Convert 1-based column offset to 0-based index into stripped text

colno = offset - 1 - spaces

end_colno = end_offset - 1 - spaces

if colno >= 0:

# non-space whitespace (likes tabs) must be kept for alignment

caretspace = ((c if c.isspace() else ' ') for c in ltext[:colno])

yield ' {}{}'.format("".join(caretspace), ('^' * (end_colno - colno) + "\n"))

msg = self.msg or "<no detail available>"

yield "{}: {}{}\n".format(stype, msg, filename_suffix)

def format(self, *, chain=True, _ctx=None):

"""Format the exception.

if _ctx is None:

_ctx = _ExceptionPrintContext()

output = []

exc = self

if chain:

while exc:

if exc.__cause__ is not None:

chained_msg = _cause_message

chained_exc = exc.__cause__

elif (exc.__context__ is not None and

not exc.__suppress_context__):

chained_msg = _context_message

chained_exc = exc.__context__

else:

chained_msg = None

chained_exc = None

output.append((chained_msg, exc))

exc = chained_exc

else:

output.append((None, exc))

for msg, exc in reversed(output):

if msg is not None:

yield from _ctx.emit(msg)

if exc.exceptions is None:

if exc.stack:

yield from _ctx.emit('Traceback (most recent call last):\n')

yield from _ctx.emit(exc.stack.format())

yield from _ctx.emit(exc.format_exception_only())

elif _ctx.exception_group_depth > self.max_group_depth:

# exception group, but depth exceeds limit

yield from _ctx.emit(

f"... (max_group_depth is {self.max_group_depth})\n")

else:

# format exception group

is_toplevel = (_ctx.exception_group_depth == 0)

if is_toplevel:

_ctx.exception_group_depth += 1

if exc.stack:

yield from _ctx.emit(

'Exception Group Traceback (most recent call last):\n',

margin_char = '+' if is_toplevel else None)

yield from _ctx.emit(exc.stack.format())

yield from _ctx.emit(exc.format_exception_only())

num_excs = len(exc.exceptions)

if num_excs <= self.max_group_width:

n = num_excs

else:

n = self.max_group_width + 1

_ctx.need_close = False

for i in range(n):

last_exc = (i == n-1)

if last_exc:

# The closing frame may be added by a recursive call

_ctx.need_close = True

if self.max_group_width is not None:

truncated = (i >= self.max_group_width)

else:

truncated = False

title = f'{i+1}' if not truncated else '...'

yield (_ctx.indent() +

('+-' if i==0 else ' ') +

f'+---------------- {title} ----------------\n')

_ctx.exception_group_depth += 1

if not truncated:

yield from exc.exceptions[i].format(chain=chain, _ctx=_ctx)

else: