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'):
13 file.write(str+terminator)
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[:-1]:
128 _print(file, line, ' ')
129 _print(file, lines[-1], '')
130
147
202
211
213 try:
214 return str(value)
215 except:
216 return '<unprintable %s object>' % type(value).__name__
217
218
220 """Shorthand for 'print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file)'.
221 (In fact, it uses sys.exc_info() to retrieve the same information
222 in a thread-safe way.)"""
223 if file is None:
224 file = sys.stderr
225 try:
226 etype, value, tb = sys.exc_info()
227 print_exception(etype, value, tb, limit, file)
228 finally:
229 etype = value = tb = None
230
231
239
240
242 """This is a shorthand for 'print_exception(sys.last_type,
243 sys.last_value, sys.last_traceback, limit, file)'."""
244 if file is None:
245 file = sys.stderr
246 print_exception(sys.last_type, sys.last_value, sys.last_traceback,
247 limit, file)
248
249
251 """Print a stack trace from its invocation point.
252
253 The optional 'f' argument can be used to specify an alternate
254 stack frame at which to start. The optional 'limit' and 'file'
255 arguments have the same meaning as for print_exception().
256 """
257 if f is None:
258 try:
259 raise ZeroDivisionError
260 except ZeroDivisionError:
261 f = sys.exc_info()[2].tb_frame.f_back
262 print_list(extract_stack(f, limit), file)
263
272
274 """Extract the raw traceback from the current stack frame.
275
276 The return value has the same format as for extract_tb(). The
277 optional 'f' and 'limit' arguments have the same meaning as for
278 print_stack(). Each item in the list is a quadruple (filename,
279 line number, function name, text), and the entries are in order
280 from oldest to newest stack frame.
281 """
282 if f is None:
283 try:
284 raise ZeroDivisionError
285 except ZeroDivisionError:
286 f = sys.exc_info()[2].tb_frame.f_back
287 if limit is None:
288 if hasattr(sys, 'tracebacklimit'):
289 limit = sys.tracebacklimit
290 list = []
291 n = 0
292 while f is not None and (limit is None or n < limit):
293 lineno = f.f_lineno
294 co = f.f_code
295 filename = co.co_filename
296 name = co.co_name
297 linecache.checkcache(filename)
298 line = linecache.getline(filename, lineno, f.f_globals)
299 if line: line = line.strip()
300 else: line = None
301 list.append((filename, lineno, name, line))
302 f = f.f_back
303 n = n+1
304 list.reverse()
305 return list
306
308 """Calculate correct line number of traceback given in tb.
309
310 Obsolete in 2.3.
311 """
312 return tb.tb_lineno
313