'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+1}, in f\n'
' if True: raise ValueError("basic caret tests")\n'
' ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+1}, in f_with_unicode\n'
' if True: raise ValueError("Ĥellö Wörld")\n'
' ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+1}, in f_with_type\n'
' def foo(a: THIS_DOES_NOT_EXIST ) -> int:\n'
' ^^^^^^^^^^^^^^^^^^^\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+1}, in f_with_multiline\n'
' if True: raise ValueError(\n'
- ' ^^^^^^^^^^^^^^^^^'
+ ' ^^^^^^^^^^^^^^^^^\n'
+ ' "error over multiple lines"\n'
+ ' ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
+ ' )\n'
+ ' ^'
)
result_lines = self.get_exception(f_with_multiline)
self.assertEqual(result_lines, expected_f.splitlines())
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+2}, in f_with_multiline\n'
' return compile(code, "?", "exec")\n'
- ' ^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
+ ' ~~~~~~~^^^^^^^^^^^^^^^^^^^\n'
' File "?", line 7\n'
' foo(a, z\n'
' ^'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+2}, in f_with_multiline\n'
' 2 + 1 /\n'
- ' ^^^'
+ ' ~~^\n'
+ ' 0\n'
+ ' ~'
)
result_lines = self.get_exception(f_with_multiline)
self.assertEqual(result_lines, expected_f.splitlines())
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n'
' return 10 + divisor / 0 + 30\n'
' ~~~~~~~~^~~\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n'
' return 10 + áóí / 0 + 30\n'
' ~~~~^~~\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n'
' return 10 + divisor // 0 + 30\n'
' ~~~~~~~~^^~~\n'
def f_with_binary_operator():
a = 1
b = ""
- return ( a ) + b
+ return ( a ) +b
lineno_f = f_with_binary_operator.__code__.co_firstlineno
expected_error = (
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'
- ' return ( a ) + b\n'
- ' ~~~~~~~~~~^~~\n'
+ ' return ( a ) +b\n'
+ ' ~~~~~~~~~~^~\n'
+ )
+ result_lines = self.get_exception(f_with_binary_operator)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
+ def test_caret_for_binary_operators_multiline(self):
+ def f_with_binary_operator():
+ b = 1
+ c = ""
+ a = b \
+ +\
+ c # test
+ return a
+
+ lineno_f = f_with_binary_operator.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'
+ ' a = b \\\n'
+ ' ~~~~~~\n'
+ ' +\\\n'
+ ' ^~\n'
+ ' c # test\n'
+ ' ~\n'
+ )
+ result_lines = self.get_exception(f_with_binary_operator)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
+ def test_caret_for_binary_operators_multiline_two_char(self):
+ def f_with_binary_operator():
+ b = 1
+ c = ""
+ a = (
+ (b # test +
+ ) \
+ # +
+ << (c # test
+ \
+ ) # test
+ )
+ return a
+
+ lineno_f = f_with_binary_operator.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+4}, in f_with_binary_operator\n'
+ ' (b # test +\n'
+ ' ~~~~~~~~~~~~\n'
+ ' ) \\\n'
+ ' ~~~~\n'
+ ' # +\n'
+ ' ~~~\n'
+ ' << (c # test\n'
+ ' ^^~~~~~~~~~~~\n'
+ ' \\\n'
+ ' ~\n'
+ ' ) # test\n'
+ ' ~\n'
+ )
+ result_lines = self.get_exception(f_with_binary_operator)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
+ def test_caret_for_binary_operators_multiline_with_unicode(self):
+ def f_with_binary_operator():
+ b = 1
+ a = ("ááá" +
+ "áá") + b
+ return a
+
+ lineno_f = f_with_binary_operator.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n'
+ ' a = ("ááá" +\n'
+ ' ~~~~~~~~\n'
+ ' "áá") + b\n'
+ ' ~~~~~~^~~\n'
)
result_lines = self.get_exception(f_with_binary_operator)
self.assertEqual(result_lines, expected_error.splitlines())
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+2}, in f_with_subscript\n'
" return some_dict['x']['y']['z']\n"
' ~~~~~~~~~~~~~~~~~~~^^^^^\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+2}, in f_with_subscript\n'
" return some_dict['ó']['á']['í']['beta']\n"
' ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'
' return b [ a ] + c\n'
' ~~~~~~^^^^^^^^^\n'
result_lines = self.get_exception(f_with_binary_operator)
self.assertEqual(result_lines, expected_error.splitlines())
+ def test_caret_for_subscript_multiline(self):
+ def f_with_subscript():
+ bbbbb = {}
+ ccc = 1
+ ddd = 2
+ b = bbbbb \
+ [ ccc # test
+
+ + ddd \
+
+ ] # test
+ return b
+
+ lineno_f = f_with_subscript.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+4}, in f_with_subscript\n'
+ ' b = bbbbb \\\n'
+ ' ~~~~~~~\n'
+ ' [ ccc # test\n'
+ ' ^^^^^^^^^^^^^\n'
+ ' \n'
+ ' \n'
+ ' + ddd \\\n'
+ ' ^^^^^^^^\n'
+ ' \n'
+ ' \n'
+ ' ] # test\n'
+ ' ^\n'
+ )
+ result_lines = self.get_exception(f_with_subscript)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
+ def test_caret_for_call(self):
+ def f_with_call():
+ def f1(a):
+ def f2(b):
+ raise RuntimeError("fail")
+ return f2
+ return f1("x")("y")
+
+ lineno_f = f_with_call.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+5}, in f_with_call\n'
+ ' return f1("x")("y")\n'
+ ' ~~~~~~~^^^^^\n'
+ f' File "{__file__}", line {lineno_f+3}, in f2\n'
+ ' raise RuntimeError("fail")\n'
+ )
+ result_lines = self.get_exception(f_with_call)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
+ def test_caret_for_call_unicode(self):
+ def f_with_call():
+ def f1(a):
+ def f2(b):
+ raise RuntimeError("fail")
+ return f2
+ return f1("ó")("á")
+
+ lineno_f = f_with_call.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+5}, in f_with_call\n'
+ ' return f1("ó")("á")\n'
+ ' ~~~~~~~^^^^^\n'
+ f' File "{__file__}", line {lineno_f+3}, in f2\n'
+ ' raise RuntimeError("fail")\n'
+ )
+ result_lines = self.get_exception(f_with_call)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
+ def test_caret_for_call_with_spaces_and_parenthesis(self):
+ def f_with_binary_operator():
+ def f(a):
+ raise RuntimeError("fail")
+ return f ( "x" ) + 2
+
+ lineno_f = f_with_binary_operator.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'
+ ' return f ( "x" ) + 2\n'
+ ' ~~~~~~^^^^^^^^^^^\n'
+ f' File "{__file__}", line {lineno_f+2}, in f\n'
+ ' raise RuntimeError("fail")\n'
+ )
+ result_lines = self.get_exception(f_with_binary_operator)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
+ def test_caret_for_call_multiline(self):
+ def f_with_call():
+ class C:
+ def y(self, a):
+ def f(b):
+ raise RuntimeError("fail")
+ return f
+ def g(x):
+ return C()
+ a = (g(1).y)(
+ 2
+ )(3)(4)
+ return a
+
+ lineno_f = f_with_call.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+8}, in f_with_call\n'
+ ' a = (g(1).y)(\n'
+ ' ~~~~~~~~~\n'
+ ' 2\n'
+ ' ~\n'
+ ' )(3)(4)\n'
+ ' ~^^^\n'
+ f' File "{__file__}", line {lineno_f+4}, in f\n'
+ ' raise RuntimeError("fail")\n'
+ )
+ result_lines = self.get_exception(f_with_call)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
+ def test_many_lines(self):
+ def f():
+ x = 1
+ if True: x += (
+ "a" +
+ "a"
+ ) # test
+
+ lineno_f = f.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+2}, in f\n'
+ ' if True: x += (\n'
+ ' ^^^^^^\n'
+ ' ...<2 lines>...\n'
+ ' ) # test\n'
+ ' ^\n'
+ )
+ result_lines = self.get_exception(f)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
+ def test_many_lines_no_caret(self):
+ def f():
+ x = 1
+ x += (
+ "a" +
+ "a"
+ )
+
+ lineno_f = f.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+2}, in f\n'
+ ' x += (\n'
+ ' ...<2 lines>...\n'
+ ' )\n'
+ )
+ result_lines = self.get_exception(f)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
+ def test_many_lines_binary_op(self):
+ def f_with_binary_operator():
+ b = 1
+ c = "a"
+ a = (
+ b +
+ b
+ ) + (
+ c +
+ c +
+ c
+ )
+ return a
+
+ lineno_f = f_with_binary_operator.__code__.co_firstlineno
+ expected_error = (
+ 'Traceback (most recent call last):\n'
+ f' File "{__file__}", line {self.callable_line}, in get_exception\n'
+ ' callable()\n'
+ ' ~~~~~~~~^^\n'
+ f' File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'
+ ' a = (\n'
+ ' ~\n'
+ ' b +\n'
+ ' ~~~\n'
+ ' b\n'
+ ' ~\n'
+ ' ) + (\n'
+ ' ~~^~~\n'
+ ' c +\n'
+ ' ~~~\n'
+ ' ...<2 lines>...\n'
+ ' )\n'
+ ' ~\n'
+ )
+ result_lines = self.get_exception(f_with_binary_operator)
+ self.assertEqual(result_lines, expected_error.splitlines())
+
def test_traceback_specialization_with_syntax_error(self):
bytecode = compile("1 / 0 / 1 / 2\n", TESTFN, "exec")
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{TESTFN}", line {lineno_f}, in <module>\n'
" 1 $ 0 / 1 / 2\n"
' ^^^^^\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{TESTFN}", line {lineno_f}, in <module>\n'
f' {source}\n'
f' {" "*len("if True: ") + "^"*256}\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_f+2}, in f_with_subscript\n'
" some_dict['x']['y']['z']\n"
' ~~~~~~~~~~~~~~~~~~~^^^^^\n'
f' + Exception Group Traceback (most recent call last):\n'
f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
f' | callable()\n'
+ f' | ~~~~~~~~^^\n'
f' | File "{__file__}", line {exc.__code__.co_firstlineno + 1}, in exc\n'
f' | if True: raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])\n'
f' | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_applydescs + 1}, in applydecs\n'
' @dec_error\n'
' ^^^^^^^^^\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
+ ' ~~~~~~~~^^\n'
f' File "{__file__}", line {lineno_applydescs_class + 1}, in applydecs_class\n'
' @dec_error\n'
' ^^^^^^^^^\n'
"Traceback (most recent call last):",
f" File \"{__file__}\", line {self.callable_line}, in get_exception",
" callable()",
+ " ~~~~~~~~^^",
f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",
" .method",
" ^^^^^^",
"Traceback (most recent call last):",
f" File \"{__file__}\", line {self.callable_line}, in get_exception",
" callable()",
+ " ~~~~~~~~^^",
f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",
" method",
]
"Traceback (most recent call last):",
f" File \"{__file__}\", line {self.callable_line}, in get_exception",
" callable()",
+ " ~~~~~~~~^^",
f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",
" . method",
" ^^^^^^",
"Traceback (most recent call last):",
f" File \"{__file__}\", line {self.callable_line}, in get_exception",
" callable()",
+ " ~~~~~~~~^^",
f" File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
" ｗｉｄｔｈ",
]
"Traceback (most recent call last):",
f" File \"{__file__}\", line {self.callable_line}, in get_exception",
" callable()",
+ " ~~~~~~~~^^",
f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",
" raise ValueError(ｗｉｄｔｈ)",
]
"Traceback (most recent call last):",
f" File \"{__file__}\", line {self.callable_line}, in get_exception",
" callable()",
+ " ~~~~~~~~^^",
f" File \"{__file__}\", line {f.__code__.co_firstlineno + 4}, in f",
f" print(1, ｗｗｗ(",
- f" ^^^^^^^",
+ f" ~~~~~~^",
+ f" ｔｈ))",
+ f" ^^^^^",
]
self.assertEqual(actual, expected)
f"Traceback (most recent call last):",
f" File \"{__file__}\", line {self.callable_line}, in get_exception",
f" callable()",
+ f" ~~~~~~~~^^",
f" File \"{__file__}\", line {f.__code__.co_firstlineno + 3}, in f",
f" return 说明说明 / şçöğıĤellö",
f" ~~~~~~~~~^~~~~~~~~~~~",
f"Traceback (most recent call last):",
f" File \"{__file__}\", line {self.callable_line}, in get_exception",
f" callable()",
+ f" ~~~~~~~~^^",
f" File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
f' return "✨🐍" + func_说明说明("📗🚛",',
f" ^^^^^^^^^^^^^",
f"Traceback (most recent call last):",
f" File \"{__file__}\", line {self.callable_line}, in get_exception",
f" callable()",
+ f" ~~~~~~~~^^",
f" File \"{__file__}\", line {f.__code__.co_firstlineno + 8}, in f",
f' return my_dct["✨🚛✨"]["说明"]["🐍"]["说明"]["🐍🐍"]',
f" ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^",
expected = ['Traceback (most recent call last):',
f' File "{__file__}", line {self.callable_line}, in get_exception',
' callable()',
+ ' ~~~~~~~~^^',
f' File "{__file__}", line {f.__code__.co_firstlineno + 1}, in f',
' raise MemoryError()']
self.assertEqual(actual, expected)
def some_exception(self):
raise KeyError('blah')
+ def _filter_debug_ranges(self, expected):
+ return [line for line in expected if not set(line.strip()) <= set("^~")]
+
+ def _maybe_filter_debug_ranges(self, expected):
+ if not self.DEBUG_RANGES:
+ return self._filter_debug_ranges(expected)
+ return expected
+
@cpython_only
def check_traceback_format(self, cleanup_func=None):
from _testcapi import traceback_print
cleanup_func(tb.tb_next)
traceback_fmt = 'Traceback (most recent call last):\n' + \
''.join(traceback.format_tb(tb))
+ # clear caret lines from traceback_fmt since internal API does
+ # not emit them
+ traceback_fmt = "\n".join(
+ self._filter_debug_ranges(traceback_fmt.splitlines())
+ ) + "\n"
file_ = StringIO()
traceback_print(tb, file_)
python_fmt = file_.getvalue()
'Traceback (most recent call last):\n'
f' File "{__file__}", line {lineno_f+5}, in _check_recursive_traceback_display\n'
' f()\n'
+ ' ~^^\n'
f' File "{__file__}", line {lineno_f+1}, in f\n'
' f()\n'
+ ' ~^^\n'
f' File "{__file__}", line {lineno_f+1}, in f\n'
' f()\n'
+ ' ~^^\n'
f' File "{__file__}", line {lineno_f+1}, in f\n'
' f()\n'
+ ' ~^^\n'
# XXX: The following line changes depending on whether the tests
# are run through the interactive interpreter or with -m
# It also varies depending on the platform (stack size)
'RecursionError: maximum recursion depth exceeded\n'
)
- expected = result_f.splitlines()
+ expected = self._maybe_filter_debug_ranges(result_f.splitlines())
actual = stderr_f.getvalue().splitlines()
# Check the output text matches expectations
result_g = (
f' File "{__file__}", line {lineno_g+2}, in g\n'
' return g(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
f' File "{__file__}", line {lineno_g+2}, in g\n'
' return g(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
f' File "{__file__}", line {lineno_g+2}, in g\n'
' return g(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
' [Previous line repeated 7 more times]\n'
f' File "{__file__}", line {lineno_g+3}, in g\n'
' raise ValueError\n'
'Traceback (most recent call last):\n'
f' File "{__file__}", line {lineno_g+7}, in _check_recursive_traceback_display\n'
' g()\n'
+ ' ~^^\n'
)
- expected = (tb_line + result_g).splitlines()
+ expected = self._maybe_filter_debug_ranges((tb_line + result_g).splitlines())
actual = stderr_g.getvalue().splitlines()
- if not self.DEBUG_RANGES:
- expected = [line for line in expected if not set(line.strip()) == {"^"}]
self.assertEqual(actual, expected)
# Check 2 different repetitive sections
'Traceback (most recent call last):\n'
f' File "{__file__}", line {lineno_h+7}, in _check_recursive_traceback_display\n'
' h()\n'
+ ' ~^^\n'
f' File "{__file__}", line {lineno_h+2}, in h\n'
' return h(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
f' File "{__file__}", line {lineno_h+2}, in h\n'
' return h(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
f' File "{__file__}", line {lineno_h+2}, in h\n'
' return h(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
' [Previous line repeated 7 more times]\n'
f' File "{__file__}", line {lineno_h+3}, in h\n'
' g()\n'
+ ' ~^^\n'
)
- expected = (result_h + result_g).splitlines()
+ expected = self._maybe_filter_debug_ranges((result_h + result_g).splitlines())
actual = stderr_h.getvalue().splitlines()
- if not self.DEBUG_RANGES:
- expected = [line for line in expected if not set(line.strip()) == {"^"}]
self.assertEqual(actual, expected)
# Check the boundary conditions. First, test just below the cutoff.
result_g = (
f' File "{__file__}", line {lineno_g+2}, in g\n'
' return g(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
f' File "{__file__}", line {lineno_g+2}, in g\n'
' return g(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
f' File "{__file__}", line {lineno_g+2}, in g\n'
' return g(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
f' File "{__file__}", line {lineno_g+3}, in g\n'
' raise ValueError\n'
'ValueError\n'
)
tb_line = (
'Traceback (most recent call last):\n'
- f' File "{__file__}", line {lineno_g+81}, in _check_recursive_traceback_display\n'
+ f' File "{__file__}", line {lineno_g+80}, in _check_recursive_traceback_display\n'
' g(traceback._RECURSIVE_CUTOFF)\n'
+ ' ~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
)
- expected = (tb_line + result_g).splitlines()
+ expected = self._maybe_filter_debug_ranges((tb_line + result_g).splitlines())
actual = stderr_g.getvalue().splitlines()
- if not self.DEBUG_RANGES:
- expected = [line for line in expected if not set(line.strip()) == {"^"}]
self.assertEqual(actual, expected)
# Second, test just above the cutoff.
result_g = (
f' File "{__file__}", line {lineno_g+2}, in g\n'
' return g(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
f' File "{__file__}", line {lineno_g+2}, in g\n'
' return g(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
f' File "{__file__}", line {lineno_g+2}, in g\n'
' return g(count-1)\n'
- ' ^^^^^^^^^^\n'
+ ' ~^^^^^^^^^\n'
' [Previous line repeated 1 more time]\n'
f' File "{__file__}", line {lineno_g+3}, in g\n'
' raise ValueError\n'
)
tb_line = (
'Traceback (most recent call last):\n'
- f' File "{__file__}", line {lineno_g+114}, in _check_recursive_traceback_display\n'
+ f' File "{__file__}", line {lineno_g+112}, in _check_recursive_traceback_display\n'
' g(traceback._RECURSIVE_CUTOFF + 1)\n'
+ ' ~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
)
- expected = (tb_line + result_g).splitlines()
+ expected = self._maybe_filter_debug_ranges((tb_line + result_g).splitlines())
actual = stderr_g.getvalue().splitlines()
- if not self.DEBUG_RANGES:
- expected = [line for line in expected if not set(line.strip()) == {"^"}]
self.assertEqual(actual, expected)
@requires_debug_ranges()
f' + Exception Group Traceback (most recent call last):\n'
f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
f' | exception_or_callable()\n'
+ f' | ~~~~~~~~~~~~~~~~~~~~~^^\n'
f' | File "{__file__}", line {exc.__code__.co_firstlineno + 1}, in exc\n'
f' | raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])\n'
f' | ExceptionGroup: eg (2 sub-exceptions)\n'
f' + Exception Group Traceback (most recent call last):\n'
f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
f' | exception_or_callable()\n'
+ f' | ~~~~~~~~~~~~~~~~~~~~~^^\n'
f' | File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n'
f' | raise EG("eg2", [ValueError(3), TypeError(4)]) from e\n'
f' | ExceptionGroup: eg2 (2 sub-exceptions)\n'
f'Traceback (most recent call last):\n'
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
f' exception_or_callable()\n'
+ f' ~~~~~~~~~~~~~~~~~~~~~^^\n'
f' File "{__file__}", line {exc.__code__.co_firstlineno + 8}, in exc\n'
f' raise ImportError(5)\n'
f'ImportError: 5\n')
f' + Exception Group Traceback (most recent call last):\n'
f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
f' | exception_or_callable()\n'
+ f' | ~~~~~~~~~~~~~~~~~~~~~^^\n'
f' | File "{__file__}", line {exc.__code__.co_firstlineno + 11}, in exc\n'
f' | raise EG("top", [VE(5)])\n'
f' | ExceptionGroup: top (1 sub-exception)\n'
expected = (f' + Exception Group Traceback (most recent call last):\n'
f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
f' | exception_or_callable()\n'
+ f' | ~~~~~~~~~~~~~~~~~~~~~^^\n'
f' | File "{__file__}", line {exc.__code__.co_firstlineno + 9}, in exc\n'
f' | raise ExceptionGroup("nested", excs)\n'
f' | ExceptionGroup: nested (2 sub-exceptions)\n'
expected = (f' + Exception Group Traceback (most recent call last):\n'
f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
f' | exception_or_callable()\n'
+ f' | ~~~~~~~~~~~~~~~~~~~~~^^\n'
f' | File "{__file__}", line {exc.__code__.co_firstlineno + 10}, in exc\n'
f' | raise ExceptionGroup("nested", excs)\n'
f' | ExceptionGroup: nested (2 sub-exceptions)\n'
def test_lazy_lines(self):
linecache.clearcache()
f = traceback.FrameSummary("f", 1, "dummy", lookup_line=False)
- self.assertEqual(None, f._line)
+ self.assertEqual(None, f._lines)
linecache.lazycache("f", globals())
self.assertEqual(
'"""Test cases for traceback module"""',
f' | Traceback (most recent call last):',
f' | File "{__file__}", line {lno_g+9}, in _get_exception_group',
f' | f()',
+ f' | ~^^',
f' | File "{__file__}", line {lno_f+1}, in f',
f' | 1/0',
f' | ~^~',
f' | Traceback (most recent call last):',
f' | File "{__file__}", line {lno_g+13}, in _get_exception_group',
f' | g(42)',
+ f' | ~^^^^',
f' | File "{__file__}", line {lno_g+1}, in g',
f' | raise ValueError(v)',
f' | ValueError: 42',
f' | Traceback (most recent call last):',
f' | File "{__file__}", line {lno_g+20}, in _get_exception_group',
f' | g(24)',
+ f' | ~^^^^',
f' | File "{__file__}", line {lno_g+1}, in g',
f' | raise ValueError(v)',
f' | ValueError: 24',
"""
__slots__ = ('filename', 'lineno', 'end_lineno', 'colno', 'end_colno',
- 'name', '_line', 'locals')
+ 'name', '_lines', '_lines_dedented', 'locals')
def __init__(self, filename, lineno, name, *, lookup_line=True,
locals=None, line=None,
"""
self.filename = filename
self.lineno = lineno
+ self.end_lineno = lineno if end_lineno is None else end_lineno
+ self.colno = colno
+ self.end_colno = end_colno
self.name = name
- self._line = line
+ self._lines = line
+ self._lines_dedented = None
if lookup_line:
self.line
self.locals = {k: _safe_string(v, 'local', func=repr)
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):
def __len__(self):
return 4
+ def _set_lines(self):
+ if (
+ self._lines is None
+ and self.lineno is not None
+ and self.end_lineno is not None
+ ):
+ lines = []
+ for lineno in range(self.lineno, self.end_lineno + 1):
+ # treat errors (empty string) and empty lines (newline) as the same
+ lines.append(linecache.getline(self.filename, lineno).rstrip())
+ self._lines = "\n".join(lines) + "\n"
+
@property
- def _original_line(self):
+ def _original_lines(self):
# Returns the line as-is from the source, without modifying whitespace.
- self.line
- return self._line
+ self._set_lines()
+ return self._lines
+
+ @property
+ def _dedented_lines(self):
+ # Returns _original_lines, but dedented
+ self._set_lines()
+ if self._lines_dedented is None and self._lines is not None:
+ self._lines_dedented = textwrap.dedent(self._lines)
+ return self._lines_dedented
@property
def line(self):
- if self._line is None:
- if self.lineno is None:
- return None
- self._line = linecache.getline(self.filename, self.lineno)
- return self._line.strip()
+ self._set_lines()
+ if self._lines is None:
+ return None
+ # return only the first line, stripped
+ return self._lines.partition("\n")[0].strip()
def walk_stack(f):
filename = "<stdin>"
row.append(' File "{}", line {}, in {}\n'.format(
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._dedented_lines and frame_summary._dedented_lines.strip():
if (
- frame_summary.colno is not None
- and frame_summary.end_colno is not None
+ frame_summary.colno is None or
+ frame_summary.end_colno is 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]
+ # only output first line if column information is missing
+ row.append(textwrap.indent(frame_summary.line, ' ') + "\n")
+ else:
+ # get first and last line
+ all_lines_original = frame_summary._original_lines.splitlines()
+ first_line = all_lines_original[0]
+ # assume all_lines_original has enough lines (since we constructed it)
+ last_line = all_lines_original[frame_summary.end_lineno - frame_summary.lineno]
+
+ # character index of the start/end of the instruction
+ start_offset = _byte_offset_to_character_offset(first_line, frame_summary.colno)
+ end_offset = _byte_offset_to_character_offset(last_line, frame_summary.end_colno)
+
+ all_lines = frame_summary._dedented_lines.splitlines()[
+ :frame_summary.end_lineno - frame_summary.lineno + 1
+ ]
+ # adjust start/end offset based on dedent
+ dedent_characters = len(first_line) - len(all_lines[0])
+ start_offset = max(0, start_offset - dedent_characters)
+ end_offset = max(0, end_offset - dedent_characters)
+
+ # 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(all_lines[0], offset=start_offset)
+ dp_end_offset = _display_width(all_lines[-1], offset=end_offset)
+
+ # get exact code segment corresponding to the instruction
+ segment = "\n".join(all_lines)
+ segment = segment[start_offset:len(segment) - (len(all_lines[-1]) - end_offset)]
+
+ # attempt to parse for anchors
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))
+ with suppress(Exception):
+ anchors = _extract_caret_anchors_from_line_segment(segment)
+
+ # only use carets if there are anchors or the carets do not span all lines
+ show_carets = False
+ if anchors or all_lines[0][:start_offset].lstrip() or all_lines[-1][end_offset:].rstrip():
+ show_carets = True
+
+ result = []
+
+ # only display first line, last line, and lines around anchor start/end
+ significant_lines = {0, len(all_lines) - 1}
+
+ anchors_left_end_offset = 0
+ anchors_right_start_offset = 0
+ primary_char = "^"
+ secondary_char = "^"
+ if anchors:
+ anchors_left_end_offset = anchors.left_end_offset
+ anchors_right_start_offset = anchors.right_start_offset
+ # computed anchor positions do not take start_offset into account,
+ # so account for it here
+ if anchors.left_end_lineno == 0:
+ anchors_left_end_offset += start_offset
+ if anchors.right_start_lineno == 0:
+ anchors_right_start_offset += start_offset
+
+ # account for display width
+ anchors_left_end_offset = _display_width(
+ all_lines[anchors.left_end_lineno], offset=anchors_left_end_offset
+ )
+ anchors_right_start_offset = _display_width(
+ all_lines[anchors.right_start_lineno], offset=anchors_right_start_offset
+ )
- row.append('\n')
+ primary_char = anchors.primary_char
+ secondary_char = anchors.secondary_char
+ significant_lines.update(
+ range(anchors.left_end_lineno - 1, anchors.left_end_lineno + 2)
+ )
+ significant_lines.update(
+ range(anchors.right_start_lineno - 1, anchors.right_start_lineno + 2)
+ )
+ # remove bad line numbers
+ significant_lines.discard(-1)
+ significant_lines.discard(len(all_lines))
+
+ def output_line(lineno):
+ """output all_lines[lineno] along with carets"""
+ result.append(all_lines[lineno] + "\n")
+ if not show_carets:
+ return
+ num_spaces = len(all_lines[lineno]) - len(all_lines[lineno].lstrip())
+ carets = []
+ num_carets = dp_end_offset if lineno == len(all_lines) - 1 else _display_width(all_lines[lineno])
+ # compute caret character for each position
+ for col in range(num_carets):
+ if col < num_spaces or (lineno == 0 and col < dp_start_offset):
+ # before first non-ws char of the line, or before start of instruction
+ carets.append(' ')
+ elif anchors and (
+ lineno > anchors.left_end_lineno or
+ (lineno == anchors.left_end_lineno and col >= anchors_left_end_offset)
+ ) and (
+ lineno < anchors.right_start_lineno or
+ (lineno == anchors.right_start_lineno and col < anchors_right_start_offset)
+ ):
+ # within anchors
+ carets.append(secondary_char)
+ else:
+ carets.append(primary_char)
+ result.append("".join(carets) + "\n")
+
+ # display significant lines
+ sig_lines_list = sorted(significant_lines)
+ for i, lineno in enumerate(sig_lines_list):
+ if i:
+ linediff = lineno - sig_lines_list[i - 1]
+ if linediff == 2:
+ # 1 line in between - just output it
+ output_line(lineno - 1)
+ elif linediff > 2:
+ # > 1 line in between - abbreviate
+ result.append(f"...<{linediff - 1} lines>...\n")
+ output_line(lineno)
+
+ row.append(
+ textwrap.indent(textwrap.dedent("".join(result)), ' ', lambda line: True)
+ )
if frame_summary.locals:
for name, value in sorted(frame_summary.locals.items()):
row.append(' {name} = {value}\n'.format(name=name, value=value))
_Anchors = collections.namedtuple(
"_Anchors",
[
+ "left_end_lineno",
"left_end_offset",
+ "right_start_lineno",
"right_start_offset",
"primary_char",
"secondary_char",
)
def _extract_caret_anchors_from_line_segment(segment):
+ """
+ Given source code `segment` corresponding to a FrameSummary, determine:
+ - for binary ops, the location of the binary op
+ - for indexing and function calls, the location of the brackets.
+ `segment` is expected to be a valid Python expression.
+ """
import ast
try:
- tree = ast.parse(segment)
+ # Without parentheses, `segment` is parsed as a statement.
+ # Binary ops, subscripts, and calls are expressions, so
+ # we can wrap them with parentheses to parse them as
+ # (possibly multi-line) expressions.
+ # e.g. if we try to highlight the addition in
+ # x = (
+ # a +
+ # b
+ # )
+ # then we would ast.parse
+ # a +
+ # b
+ # which is not a valid statement because of the newline.
+ # Adding brackets makes it a valid expression.
+ # (
+ # a +
+ # b
+ # )
+ # Line locations will be different than the original,
+ # which is taken into account later on.
+ tree = ast.parse(f"(\n{segment}\n)")
except SyntaxError:
return None
if len(tree.body) != 1:
return None
- normalize = lambda offset: _byte_offset_to_character_offset(segment, offset)
+ lines = segment.splitlines()
+
+ def normalize(lineno, offset):
+ """Get character index given byte offset"""
+ return _byte_offset_to_character_offset(lines[lineno], offset)
+
+ def next_valid_char(lineno, col):
+ """Gets the next valid character index in `lines`, if
+ the current location is not valid. Handles empty lines.
+ """
+ while lineno < len(lines) and col >= len(lines[lineno]):
+ col = 0
+ lineno += 1
+ assert lineno < len(lines) and col < len(lines[lineno])
+ return lineno, col
+
+ def increment(lineno, col):
+ """Get the next valid character index in `lines`."""
+ col += 1
+ lineno, col = next_valid_char(lineno, col)
+ return lineno, col
+
+ def nextline(lineno, col):
+ """Get the next valid character at least on the next line"""
+ col = 0
+ lineno += 1
+ lineno, col = next_valid_char(lineno, col)
+ return lineno, col
+
+ def increment_until(lineno, col, stop):
+ """Get the next valid non-"\\#" character that satisfies the `stop` predicate"""
+ while True:
+ ch = lines[lineno][col]
+ if ch in "\\#":
+ lineno, col = nextline(lineno, col)
+ elif not stop(ch):
+ lineno, col = increment(lineno, col)
+ else:
+ break
+ return lineno, col
+
+ def setup_positions(expr, force_valid=True):
+ """Get the lineno/col position of the end of `expr`. If `force_valid` is True,
+ forces the position to be a valid character (e.g. if the position is beyond the
+ end of the line, move to the next line)
+ """
+ # -2 since end_lineno is 1-indexed and because we added an extra
+ # bracket + newline to `segment` when calling ast.parse
+ lineno = expr.end_lineno - 2
+ col = normalize(lineno, expr.end_col_offset)
+ return next_valid_char(lineno, col) if force_valid else (lineno, col)
+
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())
+ # ast gives these locations for BinOp subexpressions
+ # ( left_expr ) + ( right_expr )
+ # left^^^^^ right^^^^^
+ lineno, col = setup_positions(expr.left)
- left_anchor = expr.left.end_col_offset + operator_offset
- right_anchor = left_anchor + 1
+ # First operator character is the first non-space/')' character
+ lineno, col = increment_until(lineno, col, lambda x: not x.isspace() and x != ')')
+
+ # binary op is 1 or 2 characters long, on the same line,
+ # before the right subexpression
+ right_col = col + 1
if (
- operator_offset + 1 < len(operator_str)
- and not operator_str[operator_offset + 1].isspace()
+ right_col < len(lines[lineno])
+ and (
+ # operator char should not be in the right subexpression
+ expr.right.lineno - 2 > lineno or
+ right_col < normalize(expr.right.lineno - 2, expr.right.col_offset)
+ )
+ and not (ch := lines[lineno][right_col]).isspace()
+ and ch not in "\\#"
):
- right_anchor += 1
+ right_col += 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))
+ # right_col can be invalid since it is exclusive
+ return _Anchors(lineno, col, lineno, right_col)
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)
+ # ast gives these locations for value and slice subexpressions
+ # ( value_expr ) [ slice_expr ]
+ # value^^^^^ slice^^^^^
+ # subscript^^^^^^^^^^^^^^^^^^^^
+
+ # find left bracket
+ left_lineno, left_col = setup_positions(expr.value)
+ left_lineno, left_col = increment_until(left_lineno, left_col, lambda x: x == '[')
+ # find right bracket (final character of expression)
+ right_lineno, right_col = setup_positions(expr, force_valid=False)
+ return _Anchors(left_lineno, left_col, right_lineno, right_col)
+ case ast.Call():
+ # ast gives these locations for function call expressions
+ # ( func_expr ) (args, kwargs)
+ # func^^^^^
+ # call^^^^^^^^^^^^^^^^^^^^^^^^
+
+ # find left bracket
+ left_lineno, left_col = setup_positions(expr.func)
+ left_lineno, left_col = increment_until(left_lineno, left_col, lambda x: x == '(')
+ # find right bracket (final character of expression)
+ right_lineno, right_col = setup_positions(expr, force_valid=False)
+ return _Anchors(left_lineno, left_col, right_lineno, right_col)
return None
_WIDE_CHAR_SPECIFIERS = "WF"
-def _display_width(line, offset):
+def _display_width(line, offset=None):
"""Calculate the extra amount of width space the given source
code segment might take if it were to be displayed on a fixed
width output device. Supports wide unicode characters and emojis."""
+ if offset is None:
+ offset = len(line)
+
# Fast track for ASCII-only strings
if line.isascii():
return offset
projects / thirdparty / Python / cpython.git / commitdiff
