Module traceback
[hide private]
[frames] | no frames]

Source Code for Module traceback

  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 26
27 -def format_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() or 31 extract_stack(), return a list of strings ready for printing. 32 Each string in the resulting list corresponds to the item with the 33 same index in the argument list. Each string ends in a newline; 34 the strings may contain internal newlines as well, for those items 35 whose source text line is not None. 36 """ 37 list = [] 38 for filename, lineno, name, line in extracted_list: 39 item = ' File "%s", line %d, in %s\n' % (filename,lineno,name) 40 if line: 41 item = item + ' %s\n' % line.strip() 42 list.append(item) 43 return list
44 45 73
74 -def format_tb(tb, limit = None):
75 """A shorthand for 'format_list(extract_tb(tb, limit))'.""" 76 return format_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. 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 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 arguments 134 to print_exception(). The return value is a list of strings, each 135 ending in a newline and some containing internal newlines. When 136 these lines are concatenated and printed, exactly the same text is 137 printed as does print_exception(). 138 """ 139 if tb: 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 return list
146
147 -def format_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 by 151 sys.last_type and sys.last_value. The return value is a list of 152 strings, each ending in a newline. 153 154 Normally, the list contains a single string; however, for 155 SyntaxError exceptions, it contains several lines that (when 156 printed) display detailed information about where the syntax 157 error occurred. 158 159 The message indicating which exception occurred is always the last 160 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) is str): 173 return [_format_final_exc_line(etype, value)] 174 175 stype = etype.__name__ 176 177 if not issubclass(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.args 184 except Exception: 185 pass 186 else: 187 filename = filename or "<string>" 188 lines.append(' File "%s", line %d\n' % (filename, lineno)) 189 if badline is not None: 190 lines.append(' %s\n' % badline.strip()) 191 if offset is not None: 192 caretspace = badline.rstrip('\n') 193 offset = min(len(caretspace), offset) - 1 194 caretspace = caretspace[:offset].lstrip() 195 # non-space whitespace (likes tabs) must be kept for alignment 196 caretspace = ((c.isspace() and c or ' ') for c in caretspace) 197 lines.append(' %s^\n' % ''.join(caretspace)) 198 value = msg 199 200 lines.append(_format_final_exc_line(stype, value)) 201 return lines
202
203 -def _format_final_exc_line(etype, value):
204 """Return a list of a single line -- normal case for format_exception_only""" 205 valuestr = _some_str(value) 206 if value is None or not valuestr: 207 line = "%s\n" % etype 208 else: 209 line = "%s: %s\n" % (etype, valuestr) 210 return line
211
212 -def _some_str(value):
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 236 237
238 -def format_exc(limit=None):
239 """Like print_exc() but return a string.""" 240 try: 241 etype, value, tb = sys.exc_info() 242 return ''.join(format_exception(etype, value, tb, limit)) 243 finally: 244 etype = value = tb = None
245 246 256 257 271
272 -def format_stack(f=None, limit=None):
273 """Shorthand for 'format_list(extract_stack(f, limit))'.""" 274 if f is None: 275 try: 276 raise ZeroDivisionError 277 except ZeroDivisionError: 278 f = sys.exc_info()[2].tb_frame.f_back 279 return format_list(extract_stack(f, limit))
280
281 -def extract_stack(f=None, limit = None):
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
315 -def tb_lineno(tb):
316 """Calculate correct line number of traceback given in tb. 317 318 Obsolete in 2.3. 319 """ 320 return tb.tb_lineno
321