python traceback模块_Python 进阶 之 traceback模块

1 """Extract, format and print information about Python stack traces."""

2

3 importlinecache4 importsys5 importtypes6

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

16 def print_list(extracted_list, file=None):17 """Print the list of tuples as returned by extract_tb() or18 extract_stack() as a formatted stack trace to the given file."""

19 if file isNone:20 file =sys.stderr21 for filename, lineno, name, line inextracted_list:22 _print(file,23 'File "%s", line %d, in %s' %(filename,lineno,name))24 ifline:25 _print(file, '%s' %line.strip())26

27 defformat_list(extracted_list):28 """Format a list of traceback entry tuples for printing.29

30 Given a list of tuples as returned by extract_tb() or31 extract_stack(), return a list of strings ready for printing.32 Each string in the resulting list corresponds to the item with the33 same index in the argument list. Each string ends in a newline;34 the strings may contain internal newlines as well, for those items35 whose source text line is not None.36 """

37 list =[]38 for filename, lineno, name, line inextracted_list:39 item = 'File "%s", line %d, in %s\n' %(filename,lineno,name)40 ifline:41 item = item + '%s\n' %line.strip()42 list.append(item)43 returnlist44

45

46 def print_tb(tb, limit=None, file=None):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; otherwise51 'file' should be an open file or file-like object with a write()52 method.53 """

54 if file isNone:55 file =sys.stderr56 if limit isNone:57 if hasattr(sys, 'tracebacklimit'):58 limit =sys.tracebacklimit59 n =060 while tb is not None and (limit is None or n

73

74 def format_tb(tb, limit =None):75 """A shorthand for 'format_list(extract_stack(f, limit))."""

76 returnformat_list(extract_tb(tb, limit))77

78 def extract_tb(tb, limit =None):79 """Return list of up to limit pre-processed entries from traceback.80

81 This is useful for alternate formatting of stack traces. If82 'limit' is omitted or None, all entries are extracted. A83 pre-processed stack trace entry is a quadruple (filename, line84 number, function name, text) representing the information that is85 usually printed for a stack trace. The text is a string with86 leading and trailing whitespace stripped; if the source is not87 available it is None.88 """

89 if limit isNone:90 if hasattr(sys, 'tracebacklimit'):91 limit =sys.tracebacklimit92 list =[]93 n =094 while tb is not None and (limit is None or n

107 returnlist108

109

110 def print_exception(etype, value, tb, limit=None, file=None):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) if114 traceback is not None, it prints a header "Traceback (most recent115 call last):"; (2) it prints the exception type and value after the116 stack trace; (3) if type is SyntaxError and value has the117 appropriate format, it prints the line where the syntax error118 occurred with a caret on the next line indicating the approximate119 position of the error.120 """

121 if file isNone:122 file =sys.stderr123 iftb:124 _print(file, 'Traceback (most recent call last):')125 print_tb(tb, limit, file)126 lines =format_exception_only(etype, value)127 for line inlines:128 _print(file, line, '')129

130 def format_exception(etype, value, tb, limit =None):131 """Format a stack trace and the exception information.132

133 The arguments have the same meaning as the corresponding arguments134 to print_exception(). The return value is a list of strings, each135 ending in a newline and some containing internal newlines. When136 these lines are concatenated and printed, exactly the same text is137 printed as does print_exception().138 """

139 iftb:140 list = ['Traceback (most recent call last):\n']141 list = list +format_tb(tb, limit)142 else:143 list =[]144 list = list +format_exception_only(etype, value)145 returnlist146

147 defformat_exception_only(etype, value):148 """Format the exception part of a traceback.149

150 The arguments are the exception type and value such as given by151 sys.last_type and sys.last_value. The return value is a list of152 strings, each ending in a newline.153

154 Normally, the list contains a single string; however, for155 SyntaxError exceptions, it contains several lines that (when156 printed) display detailed information about where the syntax157 error occurred.158

159 The message indicating which exception occurred is always the last160 string in the list.161

162 """

163

164 #An instance should not have a meaningful value parameter, but

165 #sometimes does, particularly for string exceptions, such as

166 #>>> raise string1, string2 # deprecated

167 #168 #Clear these out first because issubtype(string1, SyntaxError)

169 #would raise another exception and mask the original problem.

170 if (isinstance(etype, BaseException) or

171 isinstance(etype, types.InstanceType) or

172 etype is None or type(etype) isstr):173 return[_format_final_exc_line(etype, value)]174

175 stype = etype.__name__

176

177 if notissubclass(etype, SyntaxError):178 return[_format_final_exc_line(stype, value)]179

180 #It was a syntax error; show exactly where the problem was found.

181 lines =[]182 try:183 msg, (filename, lineno, offset, badline) =value.args184 exceptException:185 pass

186 else:187 filename = filename or ""

188 lines.append('File "%s", line %d\n' %(filename, lineno))189 if badline is notNone:190 lines.append('%s\n' %badline.strip())191 if offset is notNone:192 caretspace = badline.rstrip('\n')[:offset].lstrip()193 #non-space whitespace (likes tabs) must be kept for alignment

194 caretspace = ((c.isspace() and c or ' ') for c incaretspace)195 #only three spaces to account for offset1 == pos 0

196 lines.append('%s^\n' % ''.join(caretspace))197 value =msg198

199 lines.append(_format_final_exc_line(stype, value))200 returnlines201

202 def_format_final_exc_line(etype, value):203 """Return a list of a single line -- normal case for format_exception_only"""

204 valuestr =_some_str(value)205 if value is None or notvaluestr:206 line = "%s\n" %etype207 else:208 line = "%s: %s\n" %(etype, valuestr)209 returnline210

211 def_some_str(value):212 try:213 returnstr(value)214 exceptException:215 pass

216 try:217 value =unicode(value)218 return value.encode("ascii", "backslashreplace")219 exceptException:220 pass

221 return '' % type(value).__name__

222

223

224 def print_exc(limit=None, file=None):225 """Shorthand for 'print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file)'.226 (In fact, it uses sys.exc_info() to retrieve the same information227 in a thread-safe way.)"""

228 if file isNone:229 file =sys.stderr230 try:231 etype, value, tb =sys.exc_info()232 print_exception(etype, value, tb, limit, file)233 finally:234 etype = value = tb =None235

236

237 def format_exc(limit=None):238 """Like print_exc() but return a string."""

239 try:240 etype, value, tb =sys.exc_info()241 return ''.join(format_exception(etype, value, tb, limit))242 finally:243 etype = value = tb =None244

245

246 def print_last(limit=None, file=None):247 """This is a shorthand for 'print_exception(sys.last_type,248 sys.last_value, sys.last_traceback, limit, file)'."""

249 if not hasattr(sys, "last_type"):250 raise ValueError("no last exception")251 if file isNone:252 file =sys.stderr253 print_exception(sys.last_type, sys.last_value, sys.last_traceback,254 limit, file)255

256

257 def print_stack(f=None, limit=None, file=None):258 """Print a stack trace from its invocation point.259

260 The optional 'f' argument can be used to specify an alternate261 stack frame at which to start. The optional 'limit' and 'file'262 arguments have the same meaning as for print_exception().263 """

264 if f isNone:265 try:266 raiseZeroDivisionError267 exceptZeroDivisionError:268 f = sys.exc_info()[2].tb_frame.f_back269 print_list(extract_stack(f, limit), file)270

271 def format_stack(f=None, limit=None):272 """Shorthand for 'format_list(extract_stack(f, limit))'."""

273 if f isNone:274 try:275 raiseZeroDivisionError276 exceptZeroDivisionError:277 f = sys.exc_info()[2].tb_frame.f_back278 returnformat_list(extract_stack(f, limit))279

280 def extract_stack(f=None, limit =None):281 """Extract the raw traceback from the current stack frame.282

283 The return value has the same format as for extract_tb(). The284 optional 'f' and 'limit' arguments have the same meaning as for285 print_stack(). Each item in the list is a quadruple (filename,286 line number, function name, text), and the entries are in order287 from oldest to newest stack frame.288 """

289 if f isNone:290 try:291 raiseZeroDivisionError292 exceptZeroDivisionError:293 f = sys.exc_info()[2].tb_frame.f_back294 if limit isNone:295 if hasattr(sys, 'tracebacklimit'):296 limit =sys.tracebacklimit297 list =[]298 n =0299 while f is not None and (limit is None or n

311 list.reverse()312 returnlist313

314 deftb_lineno(tb):315 """Calculate correct line number of traceback given in tb.316

317 Obsolete in 2.3.318 """

319 return tb.tb_lineno