mirror of
https://github.com/python/cpython.git
synced 2024-11-23 18:04:37 +08:00
441 lines
16 KiB
ReStructuredText
441 lines
16 KiB
ReStructuredText
:mod:`traceback` --- Print or retrieve a stack traceback
|
|
========================================================
|
|
|
|
.. module:: traceback
|
|
:synopsis: Print or retrieve a stack traceback.
|
|
|
|
|
|
This module provides a standard interface to extract, format and print stack
|
|
traces of Python programs. It exactly mimics the behavior of the Python
|
|
interpreter when it prints a stack trace. This is useful when you want to print
|
|
stack traces under program control, such as in a "wrapper" around the
|
|
interpreter.
|
|
|
|
.. index:: object: traceback
|
|
|
|
The module uses traceback objects --- this is the object type that is stored in
|
|
the :data:`sys.last_traceback` variable and returned as the third item from
|
|
:func:`sys.exc_info`.
|
|
|
|
The module defines the following functions:
|
|
|
|
|
|
.. function:: print_tb(traceback, limit=None, file=None)
|
|
|
|
Print up to *limit* stack trace entries from *traceback*. If *limit* is omitted
|
|
or ``None``, all entries are printed. If *file* is omitted or ``None``, the
|
|
output goes to ``sys.stderr``; otherwise it should be an open file or file-like
|
|
object to receive the output.
|
|
|
|
|
|
.. function:: print_exception(type, value, traceback, limit=None, file=None, chain=True)
|
|
|
|
Print exception information and up to *limit* stack trace entries from
|
|
*traceback* to *file*. This differs from :func:`print_tb` in the following
|
|
ways:
|
|
|
|
* if *traceback* is not ``None``, it prints a header ``Traceback (most recent
|
|
call last):``
|
|
* it prints the exception *type* and *value* after the stack trace
|
|
* if *type* is :exc:`SyntaxError` and *value* has the appropriate format, it
|
|
prints the line where the syntax error occurred with a caret indicating the
|
|
approximate position of the error.
|
|
|
|
If *chain* is true (the default), then chained exceptions (the
|
|
:attr:`__cause__` or :attr:`__context__` attributes of the exception) will be
|
|
printed as well, like the interpreter itself does when printing an unhandled
|
|
exception.
|
|
|
|
|
|
.. function:: print_exc(limit=None, file=None, chain=True)
|
|
|
|
This is a shorthand for ``print_exception(*sys.exc_info())``.
|
|
|
|
|
|
.. function:: print_last(limit=None, file=None, chain=True)
|
|
|
|
This is a shorthand for ``print_exception(sys.last_type, sys.last_value,
|
|
sys.last_traceback, limit, file)``. In general it will work only after
|
|
an exception has reached an interactive prompt (see :data:`sys.last_type`).
|
|
|
|
|
|
.. function:: print_stack(f=None, limit=None, file=None)
|
|
|
|
This function prints a stack trace from its invocation point. The optional *f*
|
|
argument can be used to specify an alternate stack frame to start. The optional
|
|
*limit* and *file* arguments have the same meaning as for
|
|
:func:`print_exception`.
|
|
|
|
|
|
.. function:: extract_tb(traceback, limit=None)
|
|
|
|
Return a list of up to *limit* "pre-processed" stack trace entries extracted
|
|
from the traceback object *traceback*. It is useful for alternate formatting of
|
|
stack traces. If *limit* is omitted or ``None``, all entries are extracted. A
|
|
"pre-processed" stack trace entry is a 4-tuple (*filename*, *line number*,
|
|
*function name*, *text*) representing the information that is usually printed
|
|
for a stack trace. The *text* is a string with leading and trailing whitespace
|
|
stripped; if the source is not available it is ``None``.
|
|
|
|
|
|
.. function:: extract_stack(f=None, limit=None)
|
|
|
|
Extract the raw traceback from the current stack frame. The return value has
|
|
the same format as for :func:`extract_tb`. The optional *f* and *limit*
|
|
arguments have the same meaning as for :func:`print_stack`.
|
|
|
|
|
|
.. function:: format_list(list)
|
|
|
|
Given a list of tuples as returned by :func:`extract_tb` or
|
|
:func:`extract_stack`, return a list of strings ready for printing. Each string
|
|
in the resulting list corresponds to the item with the same index in the
|
|
argument list. Each string ends in a newline; the strings may contain internal
|
|
newlines as well, for those items whose source text line is not ``None``.
|
|
|
|
|
|
.. function:: format_exception_only(type, value)
|
|
|
|
Format the exception part of a traceback. The arguments are the exception type
|
|
and value such as given by ``sys.last_type`` and ``sys.last_value``. The return
|
|
value is a list of strings, each ending in a newline. Normally, the list
|
|
contains a single string; however, for :exc:`SyntaxError` exceptions, it
|
|
contains several lines that (when printed) display detailed information about
|
|
where the syntax error occurred. The message indicating which exception
|
|
occurred is the always last string in the list.
|
|
|
|
|
|
.. function:: format_exception(type, value, tb, limit=None, chain=True)
|
|
|
|
Format a stack trace and the exception information. The arguments have the
|
|
same meaning as the corresponding arguments to :func:`print_exception`. The
|
|
return value is 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 :func:`print_exception`.
|
|
|
|
|
|
.. function:: format_exc(limit=None, chain=True)
|
|
|
|
This is like ``print_exc(limit)`` but returns a string instead of printing to a
|
|
file.
|
|
|
|
|
|
.. function:: format_tb(tb, limit=None)
|
|
|
|
A shorthand for ``format_list(extract_tb(tb, limit))``.
|
|
|
|
|
|
.. function:: format_stack(f=None, limit=None)
|
|
|
|
A shorthand for ``format_list(extract_stack(f, limit))``.
|
|
|
|
.. function:: clear_frames(tb)
|
|
|
|
Clears the local variables of all the stack frames in a traceback *tb*
|
|
by calling the :meth:`clear` method of each frame object.
|
|
|
|
.. versionadded:: 3.4
|
|
|
|
.. function:: walk_stack(f)
|
|
|
|
Walk a stack following ``f.f_back`` from the given frame, yielding the frame
|
|
and line number for each frame. If *f* is ``None``, the current stack is
|
|
used. This helper is used with :meth:`StackSummary.extract`.
|
|
|
|
.. versionadded:: 3.5
|
|
|
|
.. function:: walk_tb(tb)
|
|
|
|
Walk a traceback following ``tb_next`` yielding the frame and line number
|
|
for each frame. This helper is used with :meth:`StackSummary.extract`.
|
|
|
|
.. versionadded:: 3.5
|
|
|
|
The module also defines the following classes:
|
|
|
|
:class:`TracebackException` Objects
|
|
-----------------------------------
|
|
|
|
.. versionadded:: 3.5
|
|
|
|
:class:`TracebackException` objects are created from actual exceptions to
|
|
capture data for later printing in a lightweight fashion.
|
|
|
|
.. class:: TracebackException(exc_type, exc_value, exc_traceback, *, limit=None, lookup_lines=True, capture_locals=False)
|
|
|
|
Capture an exception for later rendering. *limit*, *lookup_lines* and
|
|
*capture_locals* are as for the :class:`StackSummary` class.
|
|
|
|
Note that when locals are captured, they are also shown in the traceback.
|
|
|
|
.. attribute:: __cause__
|
|
|
|
A :class:`TracebackException` of the original ``__cause__``.
|
|
|
|
.. attribute:: __context__
|
|
|
|
A :class:`TracebackException` of the original ``__context__``.
|
|
|
|
.. attribute:: __suppress_context__
|
|
|
|
The ``__suppress_context__`` value from the original exception.
|
|
|
|
.. attribute:: stack
|
|
|
|
A :class:`StackSummary` representing the traceback.
|
|
|
|
.. attribute:: exc_type
|
|
|
|
The class of the original traceback.
|
|
|
|
.. attribute:: filename
|
|
|
|
For syntax errors - the file name where the error occurred.
|
|
|
|
.. attribute:: lineno
|
|
|
|
For syntax errors - the line number where the error occurred.
|
|
|
|
.. attribute:: text
|
|
|
|
For syntax errors - the text where the error occurred.
|
|
|
|
.. attribute:: offset
|
|
|
|
For syntax errors - the offset into the text where the error occurred.
|
|
|
|
.. attribute:: msg
|
|
|
|
For syntax errors - the compiler error message.
|
|
|
|
.. classmethod:: from_exception(exc, *, limit=None, lookup_lines=True, capture_locals=False)
|
|
|
|
Capture an exception for later rendering. *limit*, *lookup_lines* and
|
|
*capture_locals* are as for the :class:`StackSummary` class.
|
|
|
|
Note that when locals are captured, they are also shown in the traceback.
|
|
|
|
.. method:: format(*, chain=True)
|
|
|
|
Format the exception.
|
|
|
|
If *chain* is not ``True``, ``__cause__`` and ``__context__`` will not
|
|
be formatted.
|
|
|
|
The return value is a generator of strings, each ending in a newline and
|
|
some containing internal newlines. :func:`~traceback.print_exception`
|
|
is a wrapper around this method which just prints the lines to a file.
|
|
|
|
The message indicating which exception occurred is always the last
|
|
string in the output.
|
|
|
|
.. method:: format_exception_only()
|
|
|
|
Format the exception part of the traceback.
|
|
|
|
The return value is a generator of strings, each ending in a newline.
|
|
|
|
Normally, the generator emits a single string; however, for
|
|
:exc:`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.
|
|
|
|
|
|
:class:`StackSummary` Objects
|
|
-----------------------------
|
|
|
|
.. versionadded:: 3.5
|
|
|
|
:class:`StackSummary` objects represent a call stack ready for formatting.
|
|
|
|
.. class:: StackSummary
|
|
|
|
.. classmethod:: extract(frame_gen, *, limit=None, lookup_lines=True, capture_locals=False)
|
|
|
|
Construct a :class:`StackSummary` object from a frame generator (such as
|
|
is returned by :func:`~traceback.walk_stack` or
|
|
:func:`~traceback.walk_tb`).
|
|
|
|
If *limit* is supplied, only this many frames are taken from *frame_gen*.
|
|
If *lookup_lines* is ``False``, the returned :class:`FrameSummary`
|
|
objects will not have read their lines in yet, making the cost of
|
|
creating the :class:`StackSummary` cheaper (which may be valuable if it
|
|
may not actually get formatted). If *capture_locals* is ``True`` the
|
|
local variables in each :class:`FrameSummary` are captured as object
|
|
representations.
|
|
|
|
.. classmethod:: from_list(a_list)
|
|
|
|
Construct a :class:`StackSummary` object from a supplied old-style list
|
|
of tuples. Each tuple should be a 4-tuple with filename, lineno, name,
|
|
line as the elements.
|
|
|
|
|
|
:class:`FrameSummary` Objects
|
|
-----------------------------
|
|
|
|
.. versionadded:: 3.5
|
|
|
|
:class:`FrameSummary` objects represent a single frame in a traceback.
|
|
|
|
.. class:: FrameSummary(filename, lineno, name, lookup_line=True, locals=None, line=None)
|
|
|
|
Represent a single frame in the traceback or stack that is being formatted
|
|
or printed. It may optionally have a stringified version of the frames
|
|
locals included in it. If *lookup_line* is ``False``, the source code is not
|
|
looked up until the :class:`FrameSummary` has the :attr:`~FrameSummary.line`
|
|
attribute accessed (which also happens when casting it to a tuple).
|
|
:attr:`~FrameSummary.line` may be directly provided, and will prevent line
|
|
lookups happening at all. *locals* is an optional local variable
|
|
dictionary, and if supplied the variable representations are stored in the
|
|
summary for later display.
|
|
|
|
.. _traceback-example:
|
|
|
|
Traceback Examples
|
|
------------------
|
|
|
|
This simple example implements a basic read-eval-print loop, similar to (but
|
|
less useful than) the standard Python interactive interpreter loop. For a more
|
|
complete implementation of the interpreter loop, refer to the :mod:`code`
|
|
module. ::
|
|
|
|
import sys, traceback
|
|
|
|
def run_user_code(envdir):
|
|
source = input(">>> ")
|
|
try:
|
|
exec(source, envdir)
|
|
except Exception:
|
|
print("Exception in user code:")
|
|
print("-"*60)
|
|
traceback.print_exc(file=sys.stdout)
|
|
print("-"*60)
|
|
|
|
envdir = {}
|
|
while True:
|
|
run_user_code(envdir)
|
|
|
|
|
|
The following example demonstrates the different ways to print and format the
|
|
exception and traceback:
|
|
|
|
.. testcode::
|
|
|
|
import sys, traceback
|
|
|
|
def lumberjack():
|
|
bright_side_of_death()
|
|
|
|
def bright_side_of_death():
|
|
return tuple()[0]
|
|
|
|
try:
|
|
lumberjack()
|
|
except IndexError:
|
|
exc_type, exc_value, exc_traceback = sys.exc_info()
|
|
print("*** print_tb:")
|
|
traceback.print_tb(exc_traceback, limit=1, file=sys.stdout)
|
|
print("*** print_exception:")
|
|
traceback.print_exception(exc_type, exc_value, exc_traceback,
|
|
limit=2, file=sys.stdout)
|
|
print("*** print_exc:")
|
|
traceback.print_exc()
|
|
print("*** format_exc, first and last line:")
|
|
formatted_lines = traceback.format_exc().splitlines()
|
|
print(formatted_lines[0])
|
|
print(formatted_lines[-1])
|
|
print("*** format_exception:")
|
|
print(repr(traceback.format_exception(exc_type, exc_value,
|
|
exc_traceback)))
|
|
print("*** extract_tb:")
|
|
print(repr(traceback.extract_tb(exc_traceback)))
|
|
print("*** format_tb:")
|
|
print(repr(traceback.format_tb(exc_traceback)))
|
|
print("*** tb_lineno:", exc_traceback.tb_lineno)
|
|
|
|
The output for the example would look similar to this:
|
|
|
|
.. testoutput::
|
|
:options: +NORMALIZE_WHITESPACE
|
|
|
|
*** print_tb:
|
|
File "<doctest...>", line 10, in <module>
|
|
lumberjack()
|
|
*** print_exception:
|
|
Traceback (most recent call last):
|
|
File "<doctest...>", line 10, in <module>
|
|
lumberjack()
|
|
File "<doctest...>", line 4, in lumberjack
|
|
bright_side_of_death()
|
|
IndexError: tuple index out of range
|
|
*** print_exc:
|
|
Traceback (most recent call last):
|
|
File "<doctest...>", line 10, in <module>
|
|
lumberjack()
|
|
File "<doctest...>", line 4, in lumberjack
|
|
bright_side_of_death()
|
|
IndexError: tuple index out of range
|
|
*** format_exc, first and last line:
|
|
Traceback (most recent call last):
|
|
IndexError: tuple index out of range
|
|
*** format_exception:
|
|
['Traceback (most recent call last):\n',
|
|
' File "<doctest...>", line 10, in <module>\n lumberjack()\n',
|
|
' File "<doctest...>", line 4, in lumberjack\n bright_side_of_death()\n',
|
|
' File "<doctest...>", line 7, in bright_side_of_death\n return tuple()[0]\n',
|
|
'IndexError: tuple index out of range\n']
|
|
*** extract_tb:
|
|
[('<doctest...>', 10, '<module>', 'lumberjack()'),
|
|
('<doctest...>', 4, 'lumberjack', 'bright_side_of_death()'),
|
|
('<doctest...>', 7, 'bright_side_of_death', 'return tuple()[0]')]
|
|
*** format_tb:
|
|
[' File "<doctest...>", line 10, in <module>\n lumberjack()\n',
|
|
' File "<doctest...>", line 4, in lumberjack\n bright_side_of_death()\n',
|
|
' File "<doctest...>", line 7, in bright_side_of_death\n return tuple()[0]\n']
|
|
*** tb_lineno: 10
|
|
|
|
|
|
The following example shows the different ways to print and format the stack::
|
|
|
|
>>> import traceback
|
|
>>> def another_function():
|
|
... lumberstack()
|
|
...
|
|
>>> def lumberstack():
|
|
... traceback.print_stack()
|
|
... print(repr(traceback.extract_stack()))
|
|
... print(repr(traceback.format_stack()))
|
|
...
|
|
>>> another_function()
|
|
File "<doctest>", line 10, in <module>
|
|
another_function()
|
|
File "<doctest>", line 3, in another_function
|
|
lumberstack()
|
|
File "<doctest>", line 6, in lumberstack
|
|
traceback.print_stack()
|
|
[('<doctest>', 10, '<module>', 'another_function()'),
|
|
('<doctest>', 3, 'another_function', 'lumberstack()'),
|
|
('<doctest>', 7, 'lumberstack', 'print(repr(traceback.extract_stack()))')]
|
|
[' File "<doctest>", line 10, in <module>\n another_function()\n',
|
|
' File "<doctest>", line 3, in another_function\n lumberstack()\n',
|
|
' File "<doctest>", line 8, in lumberstack\n print(repr(traceback.format_stack()))\n']
|
|
|
|
|
|
This last example demonstrates the final few formatting functions:
|
|
|
|
.. doctest::
|
|
:options: +NORMALIZE_WHITESPACE
|
|
|
|
>>> import traceback
|
|
>>> traceback.format_list([('spam.py', 3, '<module>', 'spam.eggs()'),
|
|
... ('eggs.py', 42, 'eggs', 'return "bacon"')])
|
|
[' File "spam.py", line 3, in <module>\n spam.eggs()\n',
|
|
' File "eggs.py", line 42, in eggs\n return "bacon"\n']
|
|
>>> an_error = IndexError('tuple index out of range')
|
|
>>> traceback.format_exception_only(type(an_error), an_error)
|
|
['IndexError: tuple index out of range\n']
|