1 """Extract, format and print information about Python stack traces."""
2
3 import linecache
4 import sys
5 import types
6
7 __all__ = ['extract_stack', 'extract_tb', 'format_exception',
8 'format_exception_only', 'format_list', 'format_stack',
9 'format_tb', 'print_exc', 'format_exc', 'print_exception',
10 'print_last', 'print_stack', 'print_tb', 'tb_lineno']
11
12 -def _print(file, str='', terminator='\n'):
14
15
17 """Print the list of tuples as returned by extract_tb() or
18 extract_stack() as a formatted stack trace to the given file."""
19 if file is None:
20 file = sys.stderr
21 for filename, lineno, name, line in extracted_list:
22 _print(file,
23 ' File "%s", line %d, in %s' % (filename,lineno,name))
24 if line:
25 _print(file, ' %s' % line.strip())
26
44
45
47 """Print up to 'limit' stack trace entries from the traceback 'tb'.
48
49 If 'limit' is omitted or None, all entries are printed. If 'file'
50 is omitted or None, the output goes to sys.stderr; otherwise
51 'file' should be an open file or file-like object with a write()
52 method.
53 """
54 if file is None:
55 file = sys.stderr
56 if limit is None:
57 if hasattr(sys, 'tracebacklimit'):
58 limit = sys.tracebacklimit
59 n = 0
60 while tb is not None and (limit is None or n < limit):
61 f = tb.tb_frame
62 lineno = tb.tb_lineno
63 co = f.f_code
64 filename = co.co_filename
65 name = co.co_name
66 _print(file,
67 ' File "%s", line %d, in %s' % (filename, lineno, name))
68 linecache.checkcache(filename)
69 line = linecache.getline(filename, lineno, f.f_globals)
70 if line: _print(file, ' ' + line.strip())
71 tb = tb.tb_next
72 n = n+1
73
77
79 """Return list of up to limit pre-processed entries from traceback.
80
81 This is useful for alternate formatting of stack traces. If
82 'limit' is omitted or None, all entries are extracted. A
83 pre-processed stack trace entry is a quadruple (filename, line
84 number, function name, text) representing the information that is
85 usually printed for a stack trace. The text is a string with
86 leading and trailing whitespace stripped; if the source is not
87 available it is None.
88 """
89 if limit is None:
90 if hasattr(sys, 'tracebacklimit'):
91 limit = sys.tracebacklimit
92 list = []
93 n = 0
94 while tb is not None and (limit is None or n < limit):
95 f = tb.tb_frame
96 lineno = tb.tb_lineno
97 co = f.f_code
98 filename = co.co_filename
99 name = co.co_name
100 linecache.checkcache(filename)
101 line = linecache.getline(filename, lineno, f.f_globals)
102 if line: line = line.strip()
103 else: line = None
104 list.append((filename, lineno, name, line))
105 tb = tb.tb_next
106 n = n+1
107 return list
108
109
111 """Print exception up to 'limit' stack trace entries from 'tb' to 'file'.
112
113 This differs from print_tb() in the following ways: (1) if
114 traceback is not None, it prints a header "Traceback (most recent
115 call last):"; (2) it prints the exception type and value after the
116 stack trace; (3) if type is SyntaxError and value has the
117 appropriate format, it prints the line where the syntax error
118 occurred with a caret on the next line indicating the approximate
119 position of the error.
120 """
121 if file is None:
122 file = sys.stderr
123 if tb:
124 _print(file, 'Traceback (most recent call last):')
125 print_tb(tb, limit, file)
126 lines = format_exception_only(etype, value)
127 for line in lines:
128 _print(file, line, '')
129
146
202
211
213 try:
214 return str(value)
215 except Exception:
216 pass
217 try:
218 value = unicode(value)
219 return value.encode("ascii", "backslashreplace")
220 except Exception:
221 pass
222 return '<unprintable %s object>' % type(value).__name__
223
224
226 """Shorthand for 'print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file)'.
227 (In fact, it uses sys.exc_info() to retrieve the same information
228 in a thread-safe way.)"""
229 if file is None:
230 file = sys.stderr
231 try:
232 etype, value, tb = sys.exc_info()
233 print_exception(etype, value, tb, limit, file)
234 finally:
235 etype = value = tb = None
236
237
245
246
248 """This is a shorthand for 'print_exception(sys.last_type,
249 sys.last_value, sys.last_traceback, limit, file)'."""
250 if not hasattr(sys, "last_type"):
251 raise ValueError("no last exception")
252 if file is None:
253 file = sys.stderr
254 print_exception(sys.last_type, sys.last_value, sys.last_traceback,
255 limit, file)
256
257
259 """Print a stack trace from its invocation point.
260
261 The optional 'f' argument can be used to specify an alternate
262 stack frame at which to start. The optional 'limit' and 'file'
263 arguments have the same meaning as for print_exception().
264 """
265 if f is None:
266 try:
267 raise ZeroDivisionError
268 except ZeroDivisionError:
269 f = sys.exc_info()[2].tb_frame.f_back
270 print_list(extract_stack(f, limit), file)
271
280
282 """Extract the raw traceback from the current stack frame.
283
284 The return value has the same format as for extract_tb(). The
285 optional 'f' and 'limit' arguments have the same meaning as for
286 print_stack(). Each item in the list is a quadruple (filename,
287 line number, function name, text), and the entries are in order
288 from oldest to newest stack frame.
289 """
290 if f is None:
291 try:
292 raise ZeroDivisionError
293 except ZeroDivisionError:
294 f = sys.exc_info()[2].tb_frame.f_back
295 if limit is None:
296 if hasattr(sys, 'tracebacklimit'):
297 limit = sys.tracebacklimit
298 list = []
299 n = 0
300 while f is not None and (limit is None or n < limit):
301 lineno = f.f_lineno
302 co = f.f_code
303 filename = co.co_filename
304 name = co.co_name
305 linecache.checkcache(filename)
306 line = linecache.getline(filename, lineno, f.f_globals)
307 if line: line = line.strip()
308 else: line = None
309 list.append((filename, lineno, name, line))
310 f = f.f_back
311 n = n+1
312 list.reverse()
313 return list
314
316 """Calculate correct line number of traceback given in tb.
317
318 Obsolete in 2.3.
319 """
320 return tb.tb_lineno
321