# ---------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# ---------------------------------------------------------
# pylint: disable=protected-access
"""A file for custom traceback for removing file path from the trace for compliance need."""
import os
import sys
import traceback
import types
from typing import Any, Generator, List, Optional, Type
class _CustomStackSummary(traceback.StackSummary):
"""Subclass of StackSummary."""
def format(self) -> List[str]:
"""Format the stack ready for printing.
:return: A list of strings ready for printing.
* Each string in the resulting list corresponds to a single frame from the stack.
* Each string ends in a newline; the strings may contain internal newlines as well, for those items with
source text lines.
:rtype: List[str]
"""
result = []
for frame in self:
row = [' File "{}", line {}, in {}\n'.format(os.path.basename(frame.filename), frame.lineno, frame.name)]
if frame.line:
row.append(" {}\n".format(frame.line.strip()))
if frame.locals:
for name, value in sorted(frame.locals.items()):
row.append(" {name} = {value}\n".format(name=name, value=value))
result.append("".join(row))
return result
# pylint: disable=too-many-instance-attributes
class _CustomTracebackException(traceback.TracebackException):
# pylint: disable=super-init-not-called
def __init__(
self, exc_type, exc_value, exc_traceback, *, limit=None, lookup_lines=True, capture_locals=False, _seen=None
):
if _seen is None:
_seen = set()
_seen.add(exc_value)
# Gracefully handle (the way Python 2.4 and earlier did) the case of
# being called with no type or value (None, None, None).
if exc_value and exc_value.__cause__ is not None and exc_value.__cause__ not in _seen:
cause = _CustomTracebackException(
type(exc_value.__cause__),
exc_value.__cause__,
exc_value.__cause__.__traceback__,
limit=limit,
lookup_lines=False,
capture_locals=capture_locals,
_seen=_seen,
)
else:
cause = None
if exc_value and exc_value.__context__ is not None and exc_value.__context__ not in _seen:
context = _CustomTracebackException(
type(exc_value.__context__),
exc_value.__context__,
exc_value.__context__.__traceback__,
limit=limit,
lookup_lines=False,
capture_locals=capture_locals,
_seen=_seen,
)
else:
context = None
self.exc_traceback = exc_traceback
self.__cause__ = cause
self.__context__ = context
self.__suppress_context__ = exc_value.__suppress_context__ if exc_value else False
# TODO: locals.
self.stack = _CustomStackSummary.extract(
traceback.walk_tb(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 = traceback._some_str(exc_value)
if exc_type and issubclass(exc_type, SyntaxError):
# Handle SyntaxError's specially
self.filename = exc_value.filename
self.lineno = str(exc_value.lineno)
self.text = exc_value.text
self.offset = exc_value.offset
self.msg = exc_value.msg
if lookup_lines:
self._load_lines()
def format_exception_only(self) -> Generator:
"""Format the exception part of the traceback.
:return: An iterable of strings, each ending in a newline. Normally, the generator emits a single
string; however, for SyntaxError exceptions, it emits several lines that (when printed) display
detailed information about where the syntax error occurred. The message indicating which exception occurred
is always the last string in the output.
:rtype: Iterable[str]
"""
if self.exc_type is None:
yield traceback._format_final_exc_line(None, self._str)
return
stype = self.exc_type.__qualname__
smod = self.exc_type.__module__
if smod not in ("__main__", "builtins"):
stype = smod + "." + stype
if not issubclass(self.exc_type, SyntaxError):
yield traceback._format_final_exc_line(stype, self._str) # type: ignore[attr-defined]
return
# It was a syntax error; show exactly where the problem was found.
filename = os.path.basename(self.filename) or "<string>"
lineno = str(self.lineno) or "?"
yield ' File "{}", line {}\n'.format(filename, lineno)
badline = self.text
offset = self.offset
if badline is not None:
yield " {}\n".format(badline.strip())
if offset is not None:
caretspace: Any = badline.rstrip("\n")
offset = min(len(caretspace), offset) - 1
caretspace = caretspace[:offset].lstrip()
# non-space whitespace (likes tabs) must be kept for alignment
caretspace = ((c.isspace() and c or " ") for c in caretspace)
yield " {}^\n".format("".join(caretspace))
msg = self.msg or "<no detail available>"
yield "{}: {}\n".format(stype, msg)
def format_exc(limit: Optional[int] = None, chain: bool = True) -> str:
"""Like print_exc() but return a string.
:param limit: None to include all frames or the number of frames to include.
:type limit: Optional[int]
:param chain: Whether to format __cause__ and __context__. Defaults to True
:type chain: bool
:return: The formatted exception string
:rtype: str
"""
return "".join(format_exception(*sys.exc_info(), limit=limit, chain=chain)) # type: ignore[misc]
def format_exception( # pylint: disable=unused-argument
etype: Type[BaseException],
value: BaseException,
tb: types.TracebackType,
limit: Optional[int] = None,
chain: bool = True,
) -> List[str]:
"""Format a stack trace and the exception information.
The arguments have the same meaning as the corresponding arguments to print_exception().
:param etype: The type of the exception
:type etype: Type[BaseException]
:param value: The exception
:type value: BaseException
:param tb: The exception traceback
:type tb: types.TracebackType
:param limit: None to include all frames or the number of frames to include.
:type limit: Optional[int]
:param chain: Whether to format __cause__ and __context__. Defaults to True
:type chain: bool
:return: A list of strings, each ending in a newline and some containing internal newlines.
When these lines are concatenated and printed, exactly the same text is printed as does print_exception().
:rtype: List[str]
"""
# format_exception has ignored etype for some time, and code such as cgitb
# passes in bogus values as a result. For compatibility with such code we
# ignore it here (rather than in the new TracebackException API).
return list(_CustomTracebackException(type(value), value, tb, limit=limit).format(chain=chain))
