--- /dev/null
+import io
+import os
+import sys
+
+COLORIZE = True
+
+
+class ANSIColors:
+ BOLD_GREEN = "\x1b[1;32m"
+ BOLD_MAGENTA = "\x1b[1;35m"
+ BOLD_RED = "\x1b[1;31m"
+ GREEN = "\x1b[32m"
+ GREY = "\x1b[90m"
+ MAGENTA = "\x1b[35m"
+ RED = "\x1b[31m"
+ RESET = "\x1b[0m"
+ YELLOW = "\x1b[33m"
+
+
+NoColors = ANSIColors()
+
+for attr in dir(NoColors):
+ if not attr.startswith("__"):
+ setattr(NoColors, attr, "")
+
+
+def get_colors(colorize: bool = False) -> ANSIColors:
+ if colorize or can_colorize():
+ return ANSIColors()
+ else:
+ return NoColors
+
+
+def can_colorize() -> bool:
+ if sys.platform == "win32":
+ try:
+ import nt
+
+ if not nt._supports_virtual_terminal():
+ return False
+ except (ImportError, AttributeError):
+ return False
+ if not sys.flags.ignore_environment:
+ if os.environ.get("PYTHON_COLORS") == "0":
+ return False
+ if os.environ.get("PYTHON_COLORS") == "1":
+ return True
+ if "NO_COLOR" in os.environ:
+ return False
+ if not COLORIZE:
+ return False
+ if not sys.flags.ignore_environment:
+ if "FORCE_COLOR" in os.environ:
+ return True
+ if os.environ.get("TERM") == "dumb":
+ return False
+
+ if not hasattr(sys.stderr, "fileno"):
+ return False
+
+ try:
+ return os.isatty(sys.stderr.fileno())
+ except io.UnsupportedOperation:
+ return sys.stderr.isatty()
import unittest
from io import StringIO, IncrementalNewlineDecoder
from collections import namedtuple
-from traceback import _ANSIColors, _can_colorize
+import _colorize # Used in doctests
+from _colorize import ANSIColors, can_colorize
class TestResults(namedtuple('TestResults', 'failed attempted')):
The `run` method is used to process a single DocTest case. It
returns a TestResults instance.
- >>> save_colorize = traceback._COLORIZE
- >>> traceback._COLORIZE = False
+ >>> save_colorize = _colorize.COLORIZE
+ >>> _colorize.COLORIZE = False
>>> tests = DocTestFinder().find(_TestClass)
>>> runner = DocTestRunner(verbose=False)
overriding the methods `report_start`, `report_success`,
`report_unexpected_exception`, and `report_failure`.
- >>> traceback._COLORIZE = save_colorize
+ >>> _colorize.COLORIZE = save_colorize
"""
# This divider string is used to separate failure messages, and to
# separate sections of the summary.
def _failure_header(self, test, example):
red, reset = (
- (_ANSIColors.RED, _ANSIColors.RESET) if _can_colorize() else ("", "")
+ (ANSIColors.RED, ANSIColors.RESET) if can_colorize() else ("", "")
)
out = [f"{red}{self.DIVIDER}{reset}"]
if test.filename:
# Make sure sys.displayhook just prints the value to stdout
save_displayhook = sys.displayhook
sys.displayhook = sys.__displayhook__
- saved_can_colorize = traceback._can_colorize
- traceback._can_colorize = lambda: False
+ saved_can_colorize = _colorize.can_colorize
+ _colorize.can_colorize = lambda: False
color_variables = {"PYTHON_COLORS": None, "FORCE_COLOR": None}
for key in color_variables:
color_variables[key] = os.environ.pop(key, None)
sys.settrace(save_trace)
linecache.getlines = self.save_linecache_getlines
sys.displayhook = save_displayhook
- traceback._can_colorize = saved_can_colorize
+ _colorize.can_colorize = saved_can_colorize
for key, value in color_variables.items():
if value is not None:
os.environ[key] = value
else:
failed.append((name, (failures, tries, skips)))
- if _can_colorize():
- bold_green = _ANSIColors.BOLD_GREEN
- bold_red = _ANSIColors.BOLD_RED
- green = _ANSIColors.GREEN
- red = _ANSIColors.RED
- reset = _ANSIColors.RESET
- yellow = _ANSIColors.YELLOW
- else:
- bold_green = ""
- bold_red = ""
- green = ""
- red = ""
- reset = ""
- yellow = ""
+ ansi = _colorize.get_colors()
+ bold_green = ansi.BOLD_GREEN
+ bold_red = ansi.BOLD_RED
+ green = ansi.GREEN
+ red = ansi.RED
+ reset = ansi.RESET
+ yellow = ansi.YELLOW
if verbose:
if notests:
}
return ignored
+
def force_not_colorized(func):
"""Force the terminal not to be colorized."""
@functools.wraps(func)
def wrapper(*args, **kwargs):
- import traceback
- original_fn = traceback._can_colorize
+ import _colorize
+ original_fn = _colorize.can_colorize
variables = {"PYTHON_COLORS": None, "FORCE_COLOR": None}
try:
for key in variables:
variables[key] = os.environ.pop(key, None)
- traceback._can_colorize = lambda: False
+ _colorize.can_colorize = lambda: False
return func(*args, **kwargs)
finally:
- traceback._can_colorize = original_fn
+ _colorize.can_colorize = original_fn
for key, value in variables.items():
if value is not None:
os.environ[key] = value
--- /dev/null
+import contextlib
+import sys
+import unittest
+import unittest.mock
+import _colorize
+from test.support import force_not_colorized
+
+ORIGINAL_CAN_COLORIZE = _colorize.can_colorize
+
+
+def setUpModule():
+ _colorize.can_colorize = lambda: False
+
+
+def tearDownModule():
+ _colorize.can_colorize = ORIGINAL_CAN_COLORIZE
+
+
+class TestColorizeFunction(unittest.TestCase):
+ @force_not_colorized
+ def test_colorized_detection_checks_for_environment_variables(self):
+ if sys.platform == "win32":
+ virtual_patching = unittest.mock.patch("nt._supports_virtual_terminal",
+ return_value=True)
+ else:
+ virtual_patching = contextlib.nullcontext()
+ with virtual_patching:
+
+ flags = unittest.mock.MagicMock(ignore_environment=False)
+ with (unittest.mock.patch("os.isatty") as isatty_mock,
+ unittest.mock.patch("sys.flags", flags),
+ unittest.mock.patch("_colorize.can_colorize", ORIGINAL_CAN_COLORIZE)):
+ isatty_mock.return_value = True
+ with unittest.mock.patch("os.environ", {'TERM': 'dumb'}):
+ self.assertEqual(_colorize.can_colorize(), False)
+ with unittest.mock.patch("os.environ", {'PYTHON_COLORS': '1'}):
+ self.assertEqual(_colorize.can_colorize(), True)
+ with unittest.mock.patch("os.environ", {'PYTHON_COLORS': '0'}):
+ self.assertEqual(_colorize.can_colorize(), False)
+ with unittest.mock.patch("os.environ", {'NO_COLOR': '1'}):
+ self.assertEqual(_colorize.can_colorize(), False)
+ with unittest.mock.patch("os.environ",
+ {'NO_COLOR': '1', "PYTHON_COLORS": '1'}):
+ self.assertEqual(_colorize.can_colorize(), True)
+ with unittest.mock.patch("os.environ", {'FORCE_COLOR': '1'}):
+ self.assertEqual(_colorize.can_colorize(), True)
+ with unittest.mock.patch("os.environ",
+ {'FORCE_COLOR': '1', 'NO_COLOR': '1'}):
+ self.assertEqual(_colorize.can_colorize(), False)
+ with unittest.mock.patch("os.environ",
+ {'FORCE_COLOR': '1', "PYTHON_COLORS": '0'}):
+ self.assertEqual(_colorize.can_colorize(), False)
+ isatty_mock.return_value = False
+ with unittest.mock.patch("os.environ", {}):
+ self.assertEqual(_colorize.can_colorize(), False)
+
+
+if __name__ == "__main__":
+ unittest.main()
import tempfile
import types
import contextlib
-import traceback
+import _colorize
def doctest_skip_if(condition):
DocTestRunner is used to run DocTest test cases, and to accumulate
statistics. Here's a simple DocTest case we can use:
- >>> save_colorize = traceback._COLORIZE
- >>> traceback._COLORIZE = False
+ >>> save_colorize = _colorize.COLORIZE
+ >>> _colorize.COLORIZE = False
>>> def f(x):
... '''
ok
TestResults(failed=1, attempted=3)
- >>> traceback._COLORIZE = save_colorize
+ >>> _colorize.COLORIZE = save_colorize
"""
def verbose_flag(): r"""
The `verbose` flag makes the test runner generate more detailed
lines between the first line and the type/value may be omitted or
replaced with any other string:
- >>> save_colorize = traceback._COLORIZE
- >>> traceback._COLORIZE = False
+ >>> save_colorize = _colorize.COLORIZE
+ >>> _colorize.COLORIZE = False
>>> def f(x):
... '''
ZeroDivisionError: integer division or modulo by zero
TestResults(failed=1, attempted=1)
- >>> traceback._COLORIZE = save_colorize
+ >>> _colorize.COLORIZE = save_colorize
"""
def displayhook(): r"""
Test that changing sys.displayhook doesn't matter for doctest.
The DONT_ACCEPT_TRUE_FOR_1 flag disables matches between True/False
and 1/0:
- >>> save_colorize = traceback._COLORIZE
- >>> traceback._COLORIZE = False
+ >>> save_colorize = _colorize.COLORIZE
+ >>> _colorize.COLORIZE = False
>>> def f(x):
... '>>> True\n1\n'
Clean up.
>>> del doctest.OPTIONFLAGS_BY_NAME[unlikely]
- >>> traceback._COLORIZE = save_colorize
+ >>> _colorize.COLORIZE = save_colorize
"""
single example. To turn an option on for an example, follow that
example with a comment of the form ``# doctest: +OPTION``:
- >>> save_colorize = traceback._COLORIZE
- >>> traceback._COLORIZE = False
+ >>> save_colorize = _colorize.COLORIZE
+ >>> _colorize.COLORIZE = False
>>> def f(x): r'''
... >>> print(list(range(10))) # should fail: no ellipsis
Traceback (most recent call last):
ValueError: line 0 of the doctest for s has an option directive on a line with no example: '# doctest: +ELLIPSIS'
- >>> traceback._COLORIZE = save_colorize
+ >>> _colorize.COLORIZE = save_colorize
"""
def test_testsource(): r"""
with a version that restores stdout. This is necessary for you to
see debugger output.
- >>> save_colorize = traceback._COLORIZE
- >>> traceback._COLORIZE = False
+ >>> save_colorize = _colorize.COLORIZE
+ >>> _colorize.COLORIZE = False
>>> doc = '''
... >>> x = 42
9
TestResults(failed=1, attempted=3)
- >>> traceback._COLORIZE = save_colorize
+ >>> _colorize.COLORIZE = save_colorize
"""
def test_pdb_set_trace_nested():
We don't want color or `-v` in sys.argv for these tests.
- >>> save_colorize = traceback._COLORIZE
- >>> traceback._COLORIZE = False
+ >>> save_colorize = _colorize.COLORIZE
+ >>> _colorize.COLORIZE = False
>>> save_argv = sys.argv
>>> if '-v' in sys.argv:
TestResults(failed=0, attempted=2)
>>> doctest.master = None # Reset master.
>>> sys.argv = save_argv
- >>> traceback._COLORIZE = save_colorize
+ >>> _colorize.COLORIZE = save_colorize
"""
class TestImporter(importlib.abc.MetaPathFinder, importlib.abc.ResourceLoader):
def test_unicode(): """
Check doctest with a non-ascii filename:
- >>> save_colorize = traceback._COLORIZE
- >>> traceback._COLORIZE = False
+ >>> save_colorize = _colorize.COLORIZE
+ >>> _colorize.COLORIZE = False
>>> doc = '''
... >>> raise Exception('clé')
Exception: clé
TestResults(failed=1, attempted=1)
- >>> traceback._COLORIZE = save_colorize
+ >>> _colorize.COLORIZE = save_colorize
"""
def test_exception_with_note(note):
"""
- >>> save_colorize = traceback._COLORIZE
- >>> traceback._COLORIZE = False
+ >>> save_colorize = _colorize.COLORIZE
+ >>> _colorize.COLORIZE = False
>>> test_exception_with_note('Note')
Traceback (most recent call last):
note
TestResults(failed=1, attempted=...)
- >>> traceback._COLORIZE = save_colorize
+ >>> _colorize.COLORIZE = save_colorize
"""
exc = ValueError('Text')
exc.add_note(note)
def test_syntax_error_with_incorrect_expected_note():
"""
- >>> save_colorize = traceback._COLORIZE
- >>> traceback._COLORIZE = False
+ >>> save_colorize = _colorize.COLORIZE
+ >>> _colorize.COLORIZE = False
>>> def f(x):
... r'''
note2
TestResults(failed=1, attempted=...)
- >>> traceback._COLORIZE = save_colorize
+ >>> _colorize.COLORIZE = save_colorize
"""
import json
import textwrap
import traceback
-import contextlib
from functools import partial
from pathlib import Path
+import _colorize
MODULE_PREFIX = f'{__name__}.' if __name__ == '__main__' else ''
LEVENSHTEIN_DATA_FILE = Path(__file__).parent / 'levenshtein_examples.json'
-ORIGINAL_CAN_COLORIZE = traceback._can_colorize
-
-def setUpModule():
- traceback._can_colorize = lambda: False
-
-def tearDownModule():
- traceback._can_colorize = ORIGINAL_CAN_COLORIZE
class TracebackCases(unittest.TestCase):
# For now, a very minimal set of tests. I want to be sure that
# formatting of SyntaxErrors works based on changes for 2.1.
def setUp(self):
super().setUp()
- self.colorize = traceback._COLORIZE
- traceback._COLORIZE = False
+ self.colorize = _colorize.COLORIZE
+ _colorize.COLORIZE = False
def tearDown(self):
super().tearDown()
- traceback._COLORIZE = self.colorize
+ _colorize.COLORIZE = self.colorize
def get_exception_format(self, func, exc):
try:
e, capture_locals=True
)
lines = "".join(exc.format(colorize=True))
- red = traceback._ANSIColors.RED
- boldr = traceback._ANSIColors.BOLD_RED
- reset = traceback._ANSIColors.RESET
+ red = _colorize.ANSIColors.RED
+ boldr = _colorize.ANSIColors.BOLD_RED
+ reset = _colorize.ANSIColors.RESET
self.assertIn("y = " + red + "x['a']['b']" + reset + boldr + "['c']" + reset, lines)
self.assertIn("return " + red + "(lambda *args: foo(*args))" + reset + boldr + "(1,2,3,4)" + reset, lines)
self.assertIn("return (lambda *args: " + red + "foo" + reset + boldr + "(*args)" + reset + ")(1,2,3,4)", lines)
e, capture_locals=True
)
actual = "".join(exc.format(colorize=True))
- red = traceback._ANSIColors.RED
- magenta = traceback._ANSIColors.MAGENTA
- boldm = traceback._ANSIColors.BOLD_MAGENTA
- boldr = traceback._ANSIColors.BOLD_RED
- reset = traceback._ANSIColors.RESET
+ red = _colorize.ANSIColors.RED
+ magenta = _colorize.ANSIColors.MAGENTA
+ boldm = _colorize.ANSIColors.BOLD_MAGENTA
+ boldr = _colorize.ANSIColors.BOLD_RED
+ reset = _colorize.ANSIColors.RESET
expected = "".join([
f' File {magenta}"<string>"{reset}, line {magenta}1{reset}\n',
f' a {boldr}${reset} b\n',
self.fail("No exception thrown.")
except Exception as e:
with captured_output("stderr") as tbstderr:
- with unittest.mock.patch('traceback._can_colorize', return_value=True):
+ with unittest.mock.patch('_colorize.can_colorize', return_value=True):
exception_print(e)
actual = tbstderr.getvalue().splitlines()
- red = traceback._ANSIColors.RED
- boldr = traceback._ANSIColors.BOLD_RED
- magenta = traceback._ANSIColors.MAGENTA
- boldm = traceback._ANSIColors.BOLD_MAGENTA
- reset = traceback._ANSIColors.RESET
+ red = _colorize.ANSIColors.RED
+ boldr = _colorize.ANSIColors.BOLD_RED
+ magenta = _colorize.ANSIColors.MAGENTA
+ boldm = _colorize.ANSIColors.BOLD_MAGENTA
+ reset = _colorize.ANSIColors.RESET
lno_foo = foo.__code__.co_firstlineno
expected = ['Traceback (most recent call last):',
f' File {magenta}"{__file__}"{reset}, '
f'{boldm}ZeroDivisionError{reset}: {magenta}division by zero{reset}']
self.assertEqual(actual, expected)
- @force_not_colorized
- def test_colorized_detection_checks_for_environment_variables(self):
- if sys.platform == "win32":
- virtual_patching = unittest.mock.patch("nt._supports_virtual_terminal", return_value=True)
- else:
- virtual_patching = contextlib.nullcontext()
- with virtual_patching:
-
- flags = unittest.mock.MagicMock(ignore_environment=False)
- with (unittest.mock.patch("os.isatty") as isatty_mock,
- unittest.mock.patch("sys.flags", flags),
- unittest.mock.patch("traceback._can_colorize", ORIGINAL_CAN_COLORIZE)):
- isatty_mock.return_value = True
- with unittest.mock.patch("os.environ", {'TERM': 'dumb'}):
- self.assertEqual(traceback._can_colorize(), False)
- with unittest.mock.patch("os.environ", {'PYTHON_COLORS': '1'}):
- self.assertEqual(traceback._can_colorize(), True)
- with unittest.mock.patch("os.environ", {'PYTHON_COLORS': '0'}):
- self.assertEqual(traceback._can_colorize(), False)
- with unittest.mock.patch("os.environ", {'NO_COLOR': '1'}):
- self.assertEqual(traceback._can_colorize(), False)
- with unittest.mock.patch("os.environ", {'NO_COLOR': '1', "PYTHON_COLORS": '1'}):
- self.assertEqual(traceback._can_colorize(), True)
- with unittest.mock.patch("os.environ", {'FORCE_COLOR': '1'}):
- self.assertEqual(traceback._can_colorize(), True)
- with unittest.mock.patch("os.environ", {'FORCE_COLOR': '1', 'NO_COLOR': '1'}):
- self.assertEqual(traceback._can_colorize(), False)
- with unittest.mock.patch("os.environ", {'FORCE_COLOR': '1', "PYTHON_COLORS": '0'}):
- self.assertEqual(traceback._can_colorize(), False)
- isatty_mock.return_value = False
- with unittest.mock.patch("os.environ", {}):
- self.assertEqual(traceback._can_colorize(), False)
if __name__ == "__main__":
unittest.main()
"""Extract, format and print information about Python stack traces."""
-import os
-import io
import collections.abc
import itertools
import linecache
import textwrap
import warnings
from contextlib import suppress
+import _colorize
+from _colorize import ANSIColors
__all__ = ['extract_stack', 'extract_tb', 'format_exception',
'format_exception_only', 'format_list', 'format_stack',
# Formatting and printing lists of traceback lines.
#
-_COLORIZE = True
def print_list(extracted_list, file=None):
"""Print the list of tuples as returned by extract_tb() or
BUILTIN_EXCEPTION_LIMIT = object()
-def _can_colorize():
- if sys.platform == "win32":
- try:
- import nt
- if not nt._supports_virtual_terminal():
- return False
- except (ImportError, AttributeError):
- return False
- if not sys.flags.ignore_environment:
- if os.environ.get("PYTHON_COLORS") == "0":
- return False
- if os.environ.get("PYTHON_COLORS") == "1":
- return True
- if "NO_COLOR" in os.environ:
- return False
- if not _COLORIZE:
- return False
- if not sys.flags.ignore_environment:
- if "FORCE_COLOR" in os.environ:
- return True
- if os.environ.get("TERM") == "dumb":
- return False
-
- if not hasattr(sys.stderr, "fileno"):
- return False
-
- try:
- return os.isatty(sys.stderr.fileno())
- except io.UnsupportedOperation:
- return sys.stderr.isatty()
-
def _print_exception_bltin(exc, /):
file = sys.stderr if sys.stderr is not None else sys.__stderr__
- colorize = _can_colorize()
+ colorize = _colorize.can_colorize()
return print_exception(exc, limit=BUILTIN_EXCEPTION_LIMIT, file=file, colorize=colorize)
end_char = "\n" if insert_final_newline else ""
if colorize:
if value is None or not valuestr:
- line = f"{_ANSIColors.BOLD_MAGENTA}{etype}{_ANSIColors.RESET}{end_char}"
+ line = f"{ANSIColors.BOLD_MAGENTA}{etype}{ANSIColors.RESET}{end_char}"
else:
- line = f"{_ANSIColors.BOLD_MAGENTA}{etype}{_ANSIColors.RESET}: {_ANSIColors.MAGENTA}{valuestr}{_ANSIColors.RESET}{end_char}"
+ line = f"{ANSIColors.BOLD_MAGENTA}{etype}{ANSIColors.RESET}: {ANSIColors.MAGENTA}{valuestr}{ANSIColors.RESET}{end_char}"
else:
if value is None or not valuestr:
line = f"{etype}{end_char}"
line = f"{etype}: {valuestr}{end_char}"
return line
+
def _safe_string(value, what, func=str):
try:
return func(value)
_RECURSIVE_CUTOFF = 3 # Also hardcoded in traceback.c.
-class _ANSIColors:
- RED = '\x1b[31m'
- BOLD_RED = '\x1b[1;31m'
- MAGENTA = '\x1b[35m'
- BOLD_MAGENTA = '\x1b[1;35m'
- GREEN = "\x1b[32m"
- BOLD_GREEN = "\x1b[1;32m"
- GREY = '\x1b[90m'
- RESET = '\x1b[0m'
- YELLOW = "\x1b[33m"
-
class StackSummary(list):
"""A list of FrameSummary objects, representing a stack of frames."""
filename = "<stdin>"
if colorize:
row.append(' File {}"{}"{}, line {}{}{}, in {}{}{}\n'.format(
- _ANSIColors.MAGENTA,
+ ANSIColors.MAGENTA,
filename,
- _ANSIColors.RESET,
- _ANSIColors.MAGENTA,
+ ANSIColors.RESET,
+ ANSIColors.MAGENTA,
frame_summary.lineno,
- _ANSIColors.RESET,
- _ANSIColors.MAGENTA,
+ ANSIColors.RESET,
+ ANSIColors.MAGENTA,
frame_summary.name,
- _ANSIColors.RESET,
+ ANSIColors.RESET,
)
)
else:
for color, group in itertools.groupby(itertools.zip_longest(line, carets, fillvalue=""), key=lambda x: x[1]):
caret_group = list(group)
if color == "^":
- colorized_line_parts.append(_ANSIColors.BOLD_RED + "".join(char for char, _ in caret_group) + _ANSIColors.RESET)
- colorized_carets_parts.append(_ANSIColors.BOLD_RED + "".join(caret for _, caret in caret_group) + _ANSIColors.RESET)
+ colorized_line_parts.append(ANSIColors.BOLD_RED + "".join(char for char, _ in caret_group) + ANSIColors.RESET)
+ colorized_carets_parts.append(ANSIColors.BOLD_RED + "".join(caret for _, caret in caret_group) + ANSIColors.RESET)
elif color == "~":
- colorized_line_parts.append(_ANSIColors.RED + "".join(char for char, _ in caret_group) + _ANSIColors.RESET)
- colorized_carets_parts.append(_ANSIColors.RED + "".join(caret for _, caret in caret_group) + _ANSIColors.RESET)
+ colorized_line_parts.append(ANSIColors.RED + "".join(char for char, _ in caret_group) + ANSIColors.RESET)
+ colorized_carets_parts.append(ANSIColors.RED + "".join(caret for _, caret in caret_group) + ANSIColors.RESET)
else:
colorized_line_parts.append("".join(char for char, _ in caret_group))
colorized_carets_parts.append("".join(caret for _, caret in caret_group))
if self.lineno is not None:
if colorize:
yield ' File {}"{}"{}, line {}{}{}\n'.format(
- _ANSIColors.MAGENTA,
+ ANSIColors.MAGENTA,
self.filename or "<string>",
- _ANSIColors.RESET,
- _ANSIColors.MAGENTA,
+ ANSIColors.RESET,
+ ANSIColors.MAGENTA,
self.lineno,
- _ANSIColors.RESET,
+ ANSIColors.RESET,
)
else:
yield ' File "{}", line {}\n'.format(
# colorize from colno to end_colno
ltext = (
ltext[:colno] +
- _ANSIColors.BOLD_RED + ltext[colno:end_colno] + _ANSIColors.RESET +
+ ANSIColors.BOLD_RED + ltext[colno:end_colno] + ANSIColors.RESET +
ltext[end_colno:]
)
- start_color = _ANSIColors.BOLD_RED
- end_color = _ANSIColors.RESET
+ start_color = ANSIColors.BOLD_RED
+ end_color = ANSIColors.RESET
yield ' {}\n'.format(ltext)
yield ' {}{}{}{}\n'.format(
"".join(caretspace),
msg = self.msg or "<no detail available>"
if colorize:
yield "{}{}{}: {}{}{}{}\n".format(
- _ANSIColors.BOLD_MAGENTA,
+ ANSIColors.BOLD_MAGENTA,
stype,
- _ANSIColors.RESET,
- _ANSIColors.MAGENTA,
+ ANSIColors.RESET,
+ ANSIColors.MAGENTA,
msg,
- _ANSIColors.RESET,
+ ANSIColors.RESET,
filename_suffix)
else:
yield "{}: {}{}\n".format(stype, msg, filename_suffix)
"_codecs_tw",
"_collections",
"_collections_abc",
+"_colorize",
"_compat_pickle",
"_compression",
"_contextvars",
projects / thirdparty / Python / cpython.git / commitdiff
