##// END OF EJS Templates
fix syntax error
Quentin Peter -
Show More
@@ -1,1502 +1,1505 b''
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 Verbose and colourful traceback formatting.
4 4
5 5 **ColorTB**
6 6
7 7 I've always found it a bit hard to visually parse tracebacks in Python. The
8 8 ColorTB class is a solution to that problem. It colors the different parts of a
9 9 traceback in a manner similar to what you would expect from a syntax-highlighting
10 10 text editor.
11 11
12 12 Installation instructions for ColorTB::
13 13
14 14 import sys,ultratb
15 15 sys.excepthook = ultratb.ColorTB()
16 16
17 17 **VerboseTB**
18 18
19 19 I've also included a port of Ka-Ping Yee's "cgitb.py" that produces all kinds
20 20 of useful info when a traceback occurs. Ping originally had it spit out HTML
21 21 and intended it for CGI programmers, but why should they have all the fun? I
22 22 altered it to spit out colored text to the terminal. It's a bit overwhelming,
23 23 but kind of neat, and maybe useful for long-running programs that you believe
24 24 are bug-free. If a crash *does* occur in that type of program you want details.
25 25 Give it a shot--you'll love it or you'll hate it.
26 26
27 27 .. note::
28 28
29 29 The Verbose mode prints the variables currently visible where the exception
30 30 happened (shortening their strings if too long). This can potentially be
31 31 very slow, if you happen to have a huge data structure whose string
32 32 representation is complex to compute. Your computer may appear to freeze for
33 33 a while with cpu usage at 100%. If this occurs, you can cancel the traceback
34 34 with Ctrl-C (maybe hitting it more than once).
35 35
36 36 If you encounter this kind of situation often, you may want to use the
37 37 Verbose_novars mode instead of the regular Verbose, which avoids formatting
38 38 variables (but otherwise includes the information and context given by
39 39 Verbose).
40 40
41 41 .. note::
42 42
43 43 The verbose mode print all variables in the stack, which means it can
44 44 potentially leak sensitive information like access keys, or unencrypted
45 45 password.
46 46
47 47 Installation instructions for VerboseTB::
48 48
49 49 import sys,ultratb
50 50 sys.excepthook = ultratb.VerboseTB()
51 51
52 52 Note: Much of the code in this module was lifted verbatim from the standard
53 53 library module 'traceback.py' and Ka-Ping Yee's 'cgitb.py'.
54 54
55 55 Color schemes
56 56 -------------
57 57
58 58 The colors are defined in the class TBTools through the use of the
59 59 ColorSchemeTable class. Currently the following exist:
60 60
61 61 - NoColor: allows all of this module to be used in any terminal (the color
62 62 escapes are just dummy blank strings).
63 63
64 64 - Linux: is meant to look good in a terminal like the Linux console (black
65 65 or very dark background).
66 66
67 67 - LightBG: similar to Linux but swaps dark/light colors to be more readable
68 68 in light background terminals.
69 69
70 70 - Neutral: a neutral color scheme that should be readable on both light and
71 71 dark background
72 72
73 73 You can implement other color schemes easily, the syntax is fairly
74 74 self-explanatory. Please send back new schemes you develop to the author for
75 75 possible inclusion in future releases.
76 76
77 77 Inheritance diagram:
78 78
79 79 .. inheritance-diagram:: IPython.core.ultratb
80 80 :parts: 3
81 81 """
82 82
83 83 #*****************************************************************************
84 84 # Copyright (C) 2001 Nathaniel Gray <n8gray@caltech.edu>
85 85 # Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
86 86 #
87 87 # Distributed under the terms of the BSD License. The full license is in
88 88 # the file COPYING, distributed as part of this software.
89 89 #*****************************************************************************
90 90
91 91
92 92 import dis
93 93 import inspect
94 94 import keyword
95 95 import linecache
96 96 import os
97 97 import pydoc
98 98 import re
99 99 import sys
100 100 import time
101 101 import tokenize
102 102 import traceback
103 103
104 104 try: # Python 2
105 105 generate_tokens = tokenize.generate_tokens
106 106 except AttributeError: # Python 3
107 107 generate_tokens = tokenize.tokenize
108 108
109 109 # For purposes of monkeypatching inspect to fix a bug in it.
110 110 from inspect import getsourcefile, getfile, getmodule, \
111 111 ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode
112 112
113 113 # IPython's own modules
114 114 from IPython import get_ipython
115 115 from IPython.core import debugger
116 116 from IPython.core.display_trap import DisplayTrap
117 117 from IPython.core.excolors import exception_colors
118 118 from IPython.utils import PyColorize
119 119 from IPython.utils import path as util_path
120 120 from IPython.utils import py3compat
121 121 from IPython.utils.data import uniq_stable
122 122 from IPython.utils.terminal import get_terminal_size
123 123
124 124 from logging import info, error, debug
125 125
126 126 from importlib.util import source_from_cache
127 127
128 128 import IPython.utils.colorable as colorable
129 129
130 130 # Globals
131 131 # amount of space to put line numbers before verbose tracebacks
132 132 INDENT_SIZE = 8
133 133
134 134 # Default color scheme. This is used, for example, by the traceback
135 135 # formatter. When running in an actual IPython instance, the user's rc.colors
136 136 # value is used, but having a module global makes this functionality available
137 137 # to users of ultratb who are NOT running inside ipython.
138 138 DEFAULT_SCHEME = 'NoColor'
139 139
140 140
141 141 # Number of frame above which we are likely to have a recursion and will
142 142 # **attempt** to detect it. Made modifiable mostly to speedup test suite
143 143 # as detecting recursion is one of our slowest test
144 144 _FRAME_RECURSION_LIMIT = 500
145 145
146 146 # ---------------------------------------------------------------------------
147 147 # Code begins
148 148
149 149 # Utility functions
150 150 def inspect_error():
151 151 """Print a message about internal inspect errors.
152 152
153 153 These are unfortunately quite common."""
154 154
155 155 error('Internal Python error in the inspect module.\n'
156 156 'Below is the traceback from this internal error.\n')
157 157
158 158
159 159 # This function is a monkeypatch we apply to the Python inspect module. We have
160 160 # now found when it's needed (see discussion on issue gh-1456), and we have a
161 161 # test case (IPython.core.tests.test_ultratb.ChangedPyFileTest) that fails if
162 162 # the monkeypatch is not applied. TK, Aug 2012.
163 163 def findsource(object):
164 164 """Return the entire source file and starting line number for an object.
165 165
166 166 The argument may be a module, class, method, function, traceback, frame,
167 167 or code object. The source code is returned as a list of all the lines
168 168 in the file and the line number indexes a line in that list. An IOError
169 169 is raised if the source code cannot be retrieved.
170 170
171 171 FIXED version with which we monkeypatch the stdlib to work around a bug."""
172 172
173 173 file = getsourcefile(object) or getfile(object)
174 174 # If the object is a frame, then trying to get the globals dict from its
175 175 # module won't work. Instead, the frame object itself has the globals
176 176 # dictionary.
177 177 globals_dict = None
178 178 if inspect.isframe(object):
179 179 # XXX: can this ever be false?
180 180 globals_dict = object.f_globals
181 181 else:
182 182 module = getmodule(object, file)
183 183 if module:
184 184 globals_dict = module.__dict__
185 185 lines = linecache.getlines(file, globals_dict)
186 186 if not lines:
187 187 raise IOError('could not get source code')
188 188
189 189 if ismodule(object):
190 190 return lines, 0
191 191
192 192 if isclass(object):
193 193 name = object.__name__
194 194 pat = re.compile(r'^(\s*)class\s*' + name + r'\b')
195 195 # make some effort to find the best matching class definition:
196 196 # use the one with the least indentation, which is the one
197 197 # that's most probably not inside a function definition.
198 198 candidates = []
199 199 for i, line in enumerate(lines):
200 200 match = pat.match(line)
201 201 if match:
202 202 # if it's at toplevel, it's already the best one
203 203 if line[0] == 'c':
204 204 return lines, i
205 205 # else add whitespace to candidate list
206 206 candidates.append((match.group(1), i))
207 207 if candidates:
208 208 # this will sort by whitespace, and by line number,
209 209 # less whitespace first
210 210 candidates.sort()
211 211 return lines, candidates[0][1]
212 212 else:
213 213 raise IOError('could not find class definition')
214 214
215 215 if ismethod(object):
216 216 object = object.__func__
217 217 if isfunction(object):
218 218 object = object.__code__
219 219 if istraceback(object):
220 220 object = object.tb_frame
221 221 if isframe(object):
222 222 object = object.f_code
223 223 if iscode(object):
224 224 if not hasattr(object, 'co_firstlineno'):
225 225 raise IOError('could not find function definition')
226 226 pat = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
227 227 pmatch = pat.match
228 228 # fperez - fix: sometimes, co_firstlineno can give a number larger than
229 229 # the length of lines, which causes an error. Safeguard against that.
230 230 lnum = min(object.co_firstlineno, len(lines)) - 1
231 231 while lnum > 0:
232 232 if pmatch(lines[lnum]):
233 233 break
234 234 lnum -= 1
235 235
236 236 return lines, lnum
237 237 raise IOError('could not find code object')
238 238
239 239
240 240 # This is a patched version of inspect.getargs that applies the (unmerged)
241 241 # patch for http://bugs.python.org/issue14611 by Stefano Taschini. This fixes
242 242 # https://github.com/ipython/ipython/issues/8205 and
243 243 # https://github.com/ipython/ipython/issues/8293
244 244 def getargs(co):
245 245 """Get information about the arguments accepted by a code object.
246 246
247 247 Three things are returned: (args, varargs, varkw), where 'args' is
248 248 a list of argument names (possibly containing nested lists), and
249 249 'varargs' and 'varkw' are the names of the * and ** arguments or None."""
250 250 if not iscode(co):
251 251 raise TypeError('{!r} is not a code object'.format(co))
252 252
253 253 nargs = co.co_argcount
254 254 names = co.co_varnames
255 255 args = list(names[:nargs])
256 256 step = 0
257 257
258 258 # The following acrobatics are for anonymous (tuple) arguments.
259 259 for i in range(nargs):
260 260 if args[i][:1] in ('', '.'):
261 261 stack, remain, count = [], [], []
262 262 while step < len(co.co_code):
263 263 op = ord(co.co_code[step])
264 264 step = step + 1
265 265 if op >= dis.HAVE_ARGUMENT:
266 266 opname = dis.opname[op]
267 267 value = ord(co.co_code[step]) + ord(co.co_code[step+1])*256
268 268 step = step + 2
269 269 if opname in ('UNPACK_TUPLE', 'UNPACK_SEQUENCE'):
270 270 remain.append(value)
271 271 count.append(value)
272 272 elif opname in ('STORE_FAST', 'STORE_DEREF'):
273 273 if op in dis.haslocal:
274 274 stack.append(co.co_varnames[value])
275 275 elif op in dis.hasfree:
276 276 stack.append((co.co_cellvars + co.co_freevars)[value])
277 277 # Special case for sublists of length 1: def foo((bar))
278 278 # doesn't generate the UNPACK_TUPLE bytecode, so if
279 279 # `remain` is empty here, we have such a sublist.
280 280 if not remain:
281 281 stack[0] = [stack[0]]
282 282 break
283 283 else:
284 284 remain[-1] = remain[-1] - 1
285 285 while remain[-1] == 0:
286 286 remain.pop()
287 287 size = count.pop()
288 288 stack[-size:] = [stack[-size:]]
289 289 if not remain:
290 290 break
291 291 remain[-1] = remain[-1] - 1
292 292 if not remain:
293 293 break
294 294 args[i] = stack[0]
295 295
296 296 varargs = None
297 297 if co.co_flags & inspect.CO_VARARGS:
298 298 varargs = co.co_varnames[nargs]
299 299 nargs = nargs + 1
300 300 varkw = None
301 301 if co.co_flags & inspect.CO_VARKEYWORDS:
302 302 varkw = co.co_varnames[nargs]
303 303 return inspect.Arguments(args, varargs, varkw)
304 304
305 305
306 306 # Monkeypatch inspect to apply our bugfix.
307 307 def with_patch_inspect(f):
308 308 """
309 309 Deprecated since IPython 6.0
310 310 decorator for monkeypatching inspect.findsource
311 311 """
312 312
313 313 def wrapped(*args, **kwargs):
314 314 save_findsource = inspect.findsource
315 315 save_getargs = inspect.getargs
316 316 inspect.findsource = findsource
317 317 inspect.getargs = getargs
318 318 try:
319 319 return f(*args, **kwargs)
320 320 finally:
321 321 inspect.findsource = save_findsource
322 322 inspect.getargs = save_getargs
323 323
324 324 return wrapped
325 325
326 326
327 327 def fix_frame_records_filenames(records):
328 328 """Try to fix the filenames in each record from inspect.getinnerframes().
329 329
330 330 Particularly, modules loaded from within zip files have useless filenames
331 331 attached to their code object, and inspect.getinnerframes() just uses it.
332 332 """
333 333 fixed_records = []
334 334 for frame, filename, line_no, func_name, lines, index in records:
335 335 # Look inside the frame's globals dictionary for __file__,
336 336 # which should be better. However, keep Cython filenames since
337 337 # we prefer the source filenames over the compiled .so file.
338 338 if not filename.endswith(('.pyx', '.pxd', '.pxi')):
339 339 better_fn = frame.f_globals.get('__file__', None)
340 340 if isinstance(better_fn, str):
341 341 # Check the type just in case someone did something weird with
342 342 # __file__. It might also be None if the error occurred during
343 343 # import.
344 344 filename = better_fn
345 345 fixed_records.append((frame, filename, line_no, func_name, lines, index))
346 346 return fixed_records
347 347
348 348
349 349 @with_patch_inspect
350 350 def _fixed_getinnerframes(etb, context=1, tb_offset=0):
351 351 LNUM_POS, LINES_POS, INDEX_POS = 2, 4, 5
352 352
353 353 records = fix_frame_records_filenames(inspect.getinnerframes(etb, context))
354 354 # If the error is at the console, don't build any context, since it would
355 355 # otherwise produce 5 blank lines printed out (there is no file at the
356 356 # console)
357 357 rec_check = records[tb_offset:]
358 358 try:
359 359 rname = rec_check[0][1]
360 360 if rname == '<ipython console>' or rname.endswith('<string>'):
361 361 return rec_check
362 362 except IndexError:
363 363 pass
364 364
365 365 aux = traceback.extract_tb(etb)
366 366 assert len(records) == len(aux)
367 367 for i, (file, lnum, _, _) in enumerate(aux):
368 368 maybeStart = lnum - 1 - context // 2
369 369 start = max(maybeStart, 0)
370 370 end = start + context
371 371 lines = linecache.getlines(file)[start:end]
372 372 buf = list(records[i])
373 373 buf[LNUM_POS] = lnum
374 374 buf[INDEX_POS] = lnum - 1 - start
375 375 buf[LINES_POS] = lines
376 376 records[i] = tuple(buf)
377 377 return records[tb_offset:]
378 378
379 379 # Helper function -- largely belongs to VerboseTB, but we need the same
380 380 # functionality to produce a pseudo verbose TB for SyntaxErrors, so that they
381 381 # can be recognized properly by ipython.el's py-traceback-line-re
382 382 # (SyntaxErrors have to be treated specially because they have no traceback)
383 383
384 384
385 385 def _format_traceback_lines(lnum, index, lines, Colors, lvals, _line_format):
386 386 """
387 387 Format tracebacks lines with pointing arrow, leading numbers...
388 388
389 389 Parameters
390 390 ==========
391 391
392 392 lnum: int
393 393 index: int
394 394 lines: list[string]
395 395 Colors:
396 396 ColorScheme used.
397 397 lvals: bytes
398 398 Values of local variables, already colored, to inject just after the error line.
399 399 _line_format: f (str) -> (str, bool)
400 400 return (colorized version of str, failure to do so)
401 401 """
402 402 numbers_width = INDENT_SIZE - 1
403 403 res = []
404 404
405 405 for i,line in enumerate(lines, lnum-index):
406 406 line = py3compat.cast_unicode(line)
407 407
408 408 new_line, err = _line_format(line, 'str')
409 409 if not err:
410 410 line = new_line
411 411
412 412 if i == lnum:
413 413 # This is the line with the error
414 414 pad = numbers_width - len(str(i))
415 415 num = '%s%s' % (debugger.make_arrow(pad), str(lnum))
416 416 line = '%s%s%s %s%s' % (Colors.linenoEm, num,
417 417 Colors.line, line, Colors.Normal)
418 418 else:
419 419 num = '%*s' % (numbers_width, i)
420 420 line = '%s%s%s %s' % (Colors.lineno, num,
421 421 Colors.Normal, line)
422 422
423 423 res.append(line)
424 424 if lvals and i == lnum:
425 425 res.append(lvals + '\n')
426 426 return res
427 427
428 428 def is_recursion_error(etype, value, records):
429 429 try:
430 430 # RecursionError is new in Python 3.5
431 431 recursion_error_type = RecursionError
432 432 except NameError:
433 433 recursion_error_type = RuntimeError
434 434
435 435 # The default recursion limit is 1000, but some of that will be taken up
436 436 # by stack frames in IPython itself. >500 frames probably indicates
437 437 # a recursion error.
438 438 return (etype is recursion_error_type) \
439 439 and "recursion" in str(value).lower() \
440 440 and len(records) > _FRAME_RECURSION_LIMIT
441 441
442 442 def find_recursion(etype, value, records):
443 443 """Identify the repeating stack frames from a RecursionError traceback
444 444
445 445 'records' is a list as returned by VerboseTB.get_records()
446 446
447 447 Returns (last_unique, repeat_length)
448 448 """
449 449 # This involves a bit of guesswork - we want to show enough of the traceback
450 450 # to indicate where the recursion is occurring. We guess that the innermost
451 451 # quarter of the traceback (250 frames by default) is repeats, and find the
452 452 # first frame (from in to out) that looks different.
453 453 if not is_recursion_error(etype, value, records):
454 454 return len(records), 0
455 455
456 456 # Select filename, lineno, func_name to track frames with
457 457 records = [r[1:4] for r in records]
458 458 inner_frames = records[-(len(records)//4):]
459 459 frames_repeated = set(inner_frames)
460 460
461 461 last_seen_at = {}
462 462 longest_repeat = 0
463 463 i = len(records)
464 464 for frame in reversed(records):
465 465 i -= 1
466 466 if frame not in frames_repeated:
467 467 last_unique = i
468 468 break
469 469
470 470 if frame in last_seen_at:
471 471 distance = last_seen_at[frame] - i
472 472 longest_repeat = max(longest_repeat, distance)
473 473
474 474 last_seen_at[frame] = i
475 475 else:
476 476 last_unique = 0 # The whole traceback was recursion
477 477
478 478 return last_unique, longest_repeat
479 479
480 480 #---------------------------------------------------------------------------
481 481 # Module classes
482 482 class TBTools(colorable.Colorable):
483 483 """Basic tools used by all traceback printer classes."""
484 484
485 485 # Number of frames to skip when reporting tracebacks
486 486 tb_offset = 0
487 487
488 488 def __init__(self, color_scheme='NoColor', call_pdb=False, ostream=None, parent=None, config=None):
489 489 # Whether to call the interactive pdb debugger after printing
490 490 # tracebacks or not
491 491 super(TBTools, self).__init__(parent=parent, config=config)
492 492 self.call_pdb = call_pdb
493 493
494 494 # Output stream to write to. Note that we store the original value in
495 495 # a private attribute and then make the public ostream a property, so
496 496 # that we can delay accessing sys.stdout until runtime. The way
497 497 # things are written now, the sys.stdout object is dynamically managed
498 498 # so a reference to it should NEVER be stored statically. This
499 499 # property approach confines this detail to a single location, and all
500 500 # subclasses can simply access self.ostream for writing.
501 501 self._ostream = ostream
502 502
503 503 # Create color table
504 504 self.color_scheme_table = exception_colors()
505 505
506 506 self.set_colors(color_scheme)
507 507 self.old_scheme = color_scheme # save initial value for toggles
508 508
509 509 if call_pdb:
510 510 self.pdb = debugger.Pdb()
511 511 else:
512 512 self.pdb = None
513 513
514 514 def _get_ostream(self):
515 515 """Output stream that exceptions are written to.
516 516
517 517 Valid values are:
518 518
519 519 - None: the default, which means that IPython will dynamically resolve
520 520 to sys.stdout. This ensures compatibility with most tools, including
521 521 Windows (where plain stdout doesn't recognize ANSI escapes).
522 522
523 523 - Any object with 'write' and 'flush' attributes.
524 524 """
525 525 return sys.stdout if self._ostream is None else self._ostream
526 526
527 527 def _set_ostream(self, val):
528 528 assert val is None or (hasattr(val, 'write') and hasattr(val, 'flush'))
529 529 self._ostream = val
530 530
531 531 ostream = property(_get_ostream, _set_ostream)
532 532
533 533 def get_parts_of_chained_exception(self, evalue):
534 534 def get_chained_exception(exception_value):
535 535 cause = getattr(exception_value, '__cause__', None)
536 536 if cause:
537 537 return cause
538 538 if getattr(exception_value, '__suppress_context__', False):
539 539 return None
540 540 return getattr(exception_value, '__context__', None)
541 541
542 542 chained_evalue = get_chained_exception(evalue)
543 543
544 544 if chained_evalue:
545 545 return chained_evalue.__class__, chained_evalue, chained_evalue.__traceback__
546 546
547 547 def prepare_chained_exception_message(self, cause):
548 548 direct_cause = "\nThe above exception was the direct cause of the following exception:\n"
549 549 exception_during_handling = "\nDuring handling of the above exception, another exception occurred:\n"
550 550
551 551 if cause:
552 552 message = [[direct_cause]]
553 553 else:
554 554 message = [[exception_during_handling]]
555 555 return message
556 556
557 557 def set_colors(self, *args, **kw):
558 558 """Shorthand access to the color table scheme selector method."""
559 559
560 560 # Set own color table
561 561 self.color_scheme_table.set_active_scheme(*args, **kw)
562 562 # for convenience, set Colors to the active scheme
563 563 self.Colors = self.color_scheme_table.active_colors
564 564 # Also set colors of debugger
565 565 if hasattr(self, 'pdb') and self.pdb is not None:
566 566 self.pdb.set_colors(*args, **kw)
567 567
568 568 def color_toggle(self):
569 569 """Toggle between the currently active color scheme and NoColor."""
570 570
571 571 if self.color_scheme_table.active_scheme_name == 'NoColor':
572 572 self.color_scheme_table.set_active_scheme(self.old_scheme)
573 573 self.Colors = self.color_scheme_table.active_colors
574 574 else:
575 575 self.old_scheme = self.color_scheme_table.active_scheme_name
576 576 self.color_scheme_table.set_active_scheme('NoColor')
577 577 self.Colors = self.color_scheme_table.active_colors
578 578
579 579 def stb2text(self, stb):
580 580 """Convert a structured traceback (a list) to a string."""
581 581 return '\n'.join(stb)
582 582
583 583 def text(self, etype, value, tb, tb_offset=None, context=5):
584 584 """Return formatted traceback.
585 585
586 586 Subclasses may override this if they add extra arguments.
587 587 """
588 588 tb_list = self.structured_traceback(etype, value, tb,
589 589 tb_offset, context)
590 590 return self.stb2text(tb_list)
591 591
592 592 def structured_traceback(self, etype, evalue, tb, tb_offset=None,
593 593 context=5, mode=None):
594 594 """Return a list of traceback frames.
595 595
596 596 Must be implemented by each class.
597 597 """
598 598 raise NotImplementedError()
599 599
600 600
601 601 #---------------------------------------------------------------------------
602 602 class ListTB(TBTools):
603 603 """Print traceback information from a traceback list, with optional color.
604 604
605 605 Calling requires 3 arguments: (etype, evalue, elist)
606 606 as would be obtained by::
607 607
608 608 etype, evalue, tb = sys.exc_info()
609 609 if tb:
610 610 elist = traceback.extract_tb(tb)
611 611 else:
612 612 elist = None
613 613
614 614 It can thus be used by programs which need to process the traceback before
615 615 printing (such as console replacements based on the code module from the
616 616 standard library).
617 617
618 618 Because they are meant to be called without a full traceback (only a
619 619 list), instances of this class can't call the interactive pdb debugger."""
620 620
621 621 def __init__(self, color_scheme='NoColor', call_pdb=False, ostream=None, parent=None, config=None):
622 622 TBTools.__init__(self, color_scheme=color_scheme, call_pdb=call_pdb,
623 623 ostream=ostream, parent=parent,config=config)
624 624
625 625 def __call__(self, etype, value, elist):
626 626 self.ostream.flush()
627 627 self.ostream.write(self.text(etype, value, elist))
628 628 self.ostream.write('\n')
629 629
630 def _extract_tb(self, tb):
631 if tb:
632 return traceback.extract_tb(tb)
633 else:
634 return None
635
630 636 def structured_traceback(self, etype, evalue, etb=None, tb_offset=None,
631 637 context=5):
632 638 """Return a color formatted string with the traceback info.
633 639
634 640 Parameters
635 641 ----------
636 642 etype : exception type
637 643 Type of the exception raised.
638 644
639 645 evalue : object
640 646 Data stored in the exception
641 647
642 648 etb : object
643 649 If list: List of frames, see class docstring for details.
644 650 If Traceback: Traceback of the exception.
645 651
646 652 tb_offset : int, optional
647 653 Number of frames in the traceback to skip. If not given, the
648 654 instance evalue is used (set in constructor).
649 655
650 656 context : int, optional
651 657 Number of lines of context information to print.
652 658
653 659 Returns
654 660 -------
655 661 String with formatted exception.
656 662 """
657 663 # This is a workaround to get chained_exc_ids in recursive calls
658 664 # etb should not be a tuple if structured_traceback is not recursive
659 665 if isinstance(etb, tuple):
660 666 etb, chained_exc_ids = etb
661 667 else:
662 668 chained_exc_ids = set()
663 669
664 670 if isinstance(etb, list):
665 671 elist = etb
666 672 elif etb is not None:
667 673 elist = self._extract_tb(etb)
668 674 else:
669 675 elist = []
670 676 tb_offset = self.tb_offset if tb_offset is None else tb_offset
671 677 Colors = self.Colors
672 678 out_list = []
673 679 if elist:
674 680
675 681 if tb_offset and len(elist) > tb_offset:
676 682 elist = elist[tb_offset:]
677 683
678 684 out_list.append('Traceback %s(most recent call last)%s:' %
679 685 (Colors.normalEm, Colors.Normal) + '\n')
680 686 out_list.extend(self._format_list(elist))
681 687 # The exception info should be a single entry in the list.
682 688 lines = ''.join(self._format_exception_only(etype, evalue))
683 689 out_list.append(lines)
684 690
685 691 exception = self.get_parts_of_chained_exception(evalue)
686 692
687 693 if exception and not id(exception[1]) in chained_exc_ids:
688 694 chained_exception_message = self.prepare_chained_exception_message(
689 695 evalue.__cause__)[0]
690 696 etype, evalue, etb = exception
691 697 # Trace exception to avoid infinite 'cause' loop
692 698 chained_exc_ids.add(id(exception[1]))
693 699 chained_exceptions_tb_offset = 0
694 700 out_list = (
695 701 self.structured_traceback(
696 702 etype, evalue, (etb, chained_exc_ids),
697 703 chained_exceptions_tb_offset, context)
698 704 + chained_exception_message
699 705 + out_list)
700 706
701 707 return out_list
702 708
703 709 def _format_list(self, extracted_list):
704 710 """Format a list of traceback entry tuples for printing.
705 711
706 712 Given a list of tuples as returned by extract_tb() or
707 713 extract_stack(), return a list of strings ready for printing.
708 714 Each string in the resulting list corresponds to the item with the
709 715 same index in the argument list. Each string ends in a newline;
710 716 the strings may contain internal newlines as well, for those items
711 717 whose source text line is not None.
712 718
713 719 Lifted almost verbatim from traceback.py
714 720 """
715 721
716 722 Colors = self.Colors
717 723 list = []
718 724 for filename, lineno, name, line in extracted_list[:-1]:
719 725 item = ' File %s"%s"%s, line %s%d%s, in %s%s%s\n' % \
720 726 (Colors.filename, filename, Colors.Normal,
721 727 Colors.lineno, lineno, Colors.Normal,
722 728 Colors.name, name, Colors.Normal)
723 729 if line:
724 730 item += ' %s\n' % line.strip()
725 731 list.append(item)
726 732 # Emphasize the last entry
727 733 filename, lineno, name, line = extracted_list[-1]
728 734 item = '%s File %s"%s"%s, line %s%d%s, in %s%s%s%s\n' % \
729 735 (Colors.normalEm,
730 736 Colors.filenameEm, filename, Colors.normalEm,
731 737 Colors.linenoEm, lineno, Colors.normalEm,
732 738 Colors.nameEm, name, Colors.normalEm,
733 739 Colors.Normal)
734 740 if line:
735 741 item += '%s %s%s\n' % (Colors.line, line.strip(),
736 742 Colors.Normal)
737 743 list.append(item)
738 744 return list
739 745
740 746 def _format_exception_only(self, etype, value):
741 747 """Format the exception part of a traceback.
742 748
743 749 The arguments are the exception type and value such as given by
744 750 sys.exc_info()[:2]. The return value is a list of strings, each ending
745 751 in a newline. Normally, the list contains a single string; however,
746 752 for SyntaxError exceptions, it contains several lines that (when
747 753 printed) display detailed information about where the syntax error
748 754 occurred. The message indicating which exception occurred is the
749 755 always last string in the list.
750 756
751 757 Also lifted nearly verbatim from traceback.py
752 758 """
753 759 have_filedata = False
754 760 Colors = self.Colors
755 761 list = []
756 762 stype = py3compat.cast_unicode(Colors.excName + etype.__name__ + Colors.Normal)
757 763 if value is None:
758 764 # Not sure if this can still happen in Python 2.6 and above
759 765 list.append(stype + '\n')
760 766 else:
761 767 if issubclass(etype, SyntaxError):
762 768 have_filedata = True
763 769 if not value.filename: value.filename = "<string>"
764 770 if value.lineno:
765 771 lineno = value.lineno
766 772 textline = linecache.getline(value.filename, value.lineno)
767 773 else:
768 774 lineno = 'unknown'
769 775 textline = ''
770 776 list.append('%s File %s"%s"%s, line %s%s%s\n' % \
771 777 (Colors.normalEm,
772 778 Colors.filenameEm, py3compat.cast_unicode(value.filename), Colors.normalEm,
773 779 Colors.linenoEm, lineno, Colors.Normal ))
774 780 if textline == '':
775 781 textline = py3compat.cast_unicode(value.text, "utf-8")
776 782
777 783 if textline is not None:
778 784 i = 0
779 785 while i < len(textline) and textline[i].isspace():
780 786 i += 1
781 787 list.append('%s %s%s\n' % (Colors.line,
782 788 textline.strip(),
783 789 Colors.Normal))
784 790 if value.offset is not None:
785 791 s = ' '
786 792 for c in textline[i:value.offset - 1]:
787 793 if c.isspace():
788 794 s += c
789 795 else:
790 796 s += ' '
791 797 list.append('%s%s^%s\n' % (Colors.caret, s,
792 798 Colors.Normal))
793 799
794 800 try:
795 801 s = value.msg
796 802 except Exception:
797 803 s = self._some_str(value)
798 804 if s:
799 805 list.append('%s%s:%s %s\n' % (stype, Colors.excName,
800 806 Colors.Normal, s))
801 807 else:
802 808 list.append('%s\n' % stype)
803 809
804 810 # sync with user hooks
805 811 if have_filedata:
806 812 ipinst = get_ipython()
807 813 if ipinst is not None:
808 814 ipinst.hooks.synchronize_with_editor(value.filename, value.lineno, 0)
809 815
810 816 return list
811 817
812 818 def get_exception_only(self, etype, value):
813 819 """Only print the exception type and message, without a traceback.
814 820
815 821 Parameters
816 822 ----------
817 823 etype : exception type
818 824 value : exception value
819 825 """
820 826 return ListTB.structured_traceback(self, etype, value)
821 827
822 828 def show_exception_only(self, etype, evalue):
823 829 """Only print the exception type and message, without a traceback.
824 830
825 831 Parameters
826 832 ----------
827 833 etype : exception type
828 834 value : exception value
829 835 """
830 836 # This method needs to use __call__ from *this* class, not the one from
831 837 # a subclass whose signature or behavior may be different
832 838 ostream = self.ostream
833 839 ostream.flush()
834 840 ostream.write('\n'.join(self.get_exception_only(etype, evalue)))
835 841 ostream.flush()
836 842
837 843 def _some_str(self, value):
838 844 # Lifted from traceback.py
839 845 try:
840 846 return py3compat.cast_unicode(str(value))
841 847 except:
842 848 return u'<unprintable %s object>' % type(value).__name__
843 849
844 850
845 851 #----------------------------------------------------------------------------
846 852 class VerboseTB(TBTools):
847 853 """A port of Ka-Ping Yee's cgitb.py module that outputs color text instead
848 854 of HTML. Requires inspect and pydoc. Crazy, man.
849 855
850 856 Modified version which optionally strips the topmost entries from the
851 857 traceback, to be used with alternate interpreters (because their own code
852 858 would appear in the traceback)."""
853 859
854 860 def __init__(self, color_scheme='Linux', call_pdb=False, ostream=None,
855 861 tb_offset=0, long_header=False, include_vars=True,
856 862 check_cache=None, debugger_cls = None,
857 863 parent=None, config=None):
858 864 """Specify traceback offset, headers and color scheme.
859 865
860 866 Define how many frames to drop from the tracebacks. Calling it with
861 867 tb_offset=1 allows use of this handler in interpreters which will have
862 868 their own code at the top of the traceback (VerboseTB will first
863 869 remove that frame before printing the traceback info)."""
864 870 TBTools.__init__(self, color_scheme=color_scheme, call_pdb=call_pdb,
865 871 ostream=ostream, parent=parent, config=config)
866 872 self.tb_offset = tb_offset
867 873 self.long_header = long_header
868 874 self.include_vars = include_vars
869 875 # By default we use linecache.checkcache, but the user can provide a
870 876 # different check_cache implementation. This is used by the IPython
871 877 # kernel to provide tracebacks for interactive code that is cached,
872 878 # by a compiler instance that flushes the linecache but preserves its
873 879 # own code cache.
874 880 if check_cache is None:
875 881 check_cache = linecache.checkcache
876 882 self.check_cache = check_cache
877 883
878 884 self.debugger_cls = debugger_cls or debugger.Pdb
879 885
880 886 def format_records(self, records, last_unique, recursion_repeat):
881 887 """Format the stack frames of the traceback"""
882 888 frames = []
883 889 for r in records[:last_unique+recursion_repeat+1]:
884 890 #print '*** record:',file,lnum,func,lines,index # dbg
885 891 frames.append(self.format_record(*r))
886 892
887 893 if recursion_repeat:
888 894 frames.append('... last %d frames repeated, from the frame below ...\n' % recursion_repeat)
889 895 frames.append(self.format_record(*records[last_unique+recursion_repeat+1]))
890 896
891 897 return frames
892 898
893 899 def format_record(self, frame, file, lnum, func, lines, index):
894 900 """Format a single stack frame"""
895 901 Colors = self.Colors # just a shorthand + quicker name lookup
896 902 ColorsNormal = Colors.Normal # used a lot
897 903 col_scheme = self.color_scheme_table.active_scheme_name
898 904 indent = ' ' * INDENT_SIZE
899 905 em_normal = '%s\n%s%s' % (Colors.valEm, indent, ColorsNormal)
900 906 undefined = '%sundefined%s' % (Colors.em, ColorsNormal)
901 907 tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
902 908 tpl_call = 'in %s%%s%s%%s%s' % (Colors.vName, Colors.valEm,
903 909 ColorsNormal)
904 910 tpl_call_fail = 'in %s%%s%s(***failed resolving arguments***)%s' % \
905 911 (Colors.vName, Colors.valEm, ColorsNormal)
906 912 tpl_local_var = '%s%%s%s' % (Colors.vName, ColorsNormal)
907 913 tpl_global_var = '%sglobal%s %s%%s%s' % (Colors.em, ColorsNormal,
908 914 Colors.vName, ColorsNormal)
909 915 tpl_name_val = '%%s %s= %%s%s' % (Colors.valEm, ColorsNormal)
910 916
911 917 if not file:
912 918 file = '?'
913 919 elif file.startswith(str("<")) and file.endswith(str(">")):
914 920 # Not a real filename, no problem...
915 921 pass
916 922 elif not os.path.isabs(file):
917 923 # Try to make the filename absolute by trying all
918 924 # sys.path entries (which is also what linecache does)
919 925 for dirname in sys.path:
920 926 try:
921 927 fullname = os.path.join(dirname, file)
922 928 if os.path.isfile(fullname):
923 929 file = os.path.abspath(fullname)
924 930 break
925 931 except Exception:
926 932 # Just in case that sys.path contains very
927 933 # strange entries...
928 934 pass
929 935
930 936 file = py3compat.cast_unicode(file, util_path.fs_encoding)
931 937 link = tpl_link % util_path.compress_user(file)
932 938 args, varargs, varkw, locals_ = inspect.getargvalues(frame)
933 939
934 940 if func == '?':
935 941 call = ''
936 942 elif func == '<module>':
937 943 call = tpl_call % (func, '')
938 944 else:
939 945 # Decide whether to include variable details or not
940 946 var_repr = eqrepr if self.include_vars else nullrepr
941 947 try:
942 948 call = tpl_call % (func, inspect.formatargvalues(args,
943 949 varargs, varkw,
944 950 locals_, formatvalue=var_repr))
945 951 except KeyError:
946 952 # This happens in situations like errors inside generator
947 953 # expressions, where local variables are listed in the
948 954 # line, but can't be extracted from the frame. I'm not
949 955 # 100% sure this isn't actually a bug in inspect itself,
950 956 # but since there's no info for us to compute with, the
951 957 # best we can do is report the failure and move on. Here
952 958 # we must *not* call any traceback construction again,
953 959 # because that would mess up use of %debug later on. So we
954 960 # simply report the failure and move on. The only
955 961 # limitation will be that this frame won't have locals
956 962 # listed in the call signature. Quite subtle problem...
957 963 # I can't think of a good way to validate this in a unit
958 964 # test, but running a script consisting of:
959 965 # dict( (k,v.strip()) for (k,v) in range(10) )
960 966 # will illustrate the error, if this exception catch is
961 967 # disabled.
962 968 call = tpl_call_fail % func
963 969
964 970 # Don't attempt to tokenize binary files.
965 971 if file.endswith(('.so', '.pyd', '.dll')):
966 972 return '%s %s\n' % (link, call)
967 973
968 974 elif file.endswith(('.pyc', '.pyo')):
969 975 # Look up the corresponding source file.
970 976 try:
971 977 file = source_from_cache(file)
972 978 except ValueError:
973 979 # Failed to get the source file for some reason
974 980 # E.g. https://github.com/ipython/ipython/issues/9486
975 981 return '%s %s\n' % (link, call)
976 982
977 983 def linereader(file=file, lnum=[lnum], getline=linecache.getline):
978 984 line = getline(file, lnum[0])
979 985 lnum[0] += 1
980 986 return line
981 987
982 988 # Build the list of names on this line of code where the exception
983 989 # occurred.
984 990 try:
985 991 names = []
986 992 name_cont = False
987 993
988 994 for token_type, token, start, end, line in generate_tokens(linereader):
989 995 # build composite names
990 996 if token_type == tokenize.NAME and token not in keyword.kwlist:
991 997 if name_cont:
992 998 # Continuation of a dotted name
993 999 try:
994 1000 names[-1].append(token)
995 1001 except IndexError:
996 1002 names.append([token])
997 1003 name_cont = False
998 1004 else:
999 1005 # Regular new names. We append everything, the caller
1000 1006 # will be responsible for pruning the list later. It's
1001 1007 # very tricky to try to prune as we go, b/c composite
1002 1008 # names can fool us. The pruning at the end is easy
1003 1009 # to do (or the caller can print a list with repeated
1004 1010 # names if so desired.
1005 1011 names.append([token])
1006 1012 elif token == '.':
1007 1013 name_cont = True
1008 1014 elif token_type == tokenize.NEWLINE:
1009 1015 break
1010 1016
1011 1017 except (IndexError, UnicodeDecodeError, SyntaxError):
1012 1018 # signals exit of tokenizer
1013 1019 # SyntaxError can occur if the file is not actually Python
1014 1020 # - see gh-6300
1015 1021 pass
1016 1022 except tokenize.TokenError as msg:
1017 1023 # Tokenizing may fail for various reasons, many of which are
1018 1024 # harmless. (A good example is when the line in question is the
1019 1025 # close of a triple-quoted string, cf gh-6864). We don't want to
1020 1026 # show this to users, but want make it available for debugging
1021 1027 # purposes.
1022 1028 _m = ("An unexpected error occurred while tokenizing input\n"
1023 1029 "The following traceback may be corrupted or invalid\n"
1024 1030 "The error message is: %s\n" % msg)
1025 1031 debug(_m)
1026 1032
1027 1033 # Join composite names (e.g. "dict.fromkeys")
1028 1034 names = ['.'.join(n) for n in names]
1029 1035 # prune names list of duplicates, but keep the right order
1030 1036 unique_names = uniq_stable(names)
1031 1037
1032 1038 # Start loop over vars
1033 1039 lvals = ''
1034 1040 lvals_list = []
1035 1041 if self.include_vars:
1036 1042 for name_full in unique_names:
1037 1043 name_base = name_full.split('.', 1)[0]
1038 1044 if name_base in frame.f_code.co_varnames:
1039 1045 if name_base in locals_:
1040 1046 try:
1041 1047 value = repr(eval(name_full, locals_))
1042 1048 except:
1043 1049 value = undefined
1044 1050 else:
1045 1051 value = undefined
1046 1052 name = tpl_local_var % name_full
1047 1053 else:
1048 1054 if name_base in frame.f_globals:
1049 1055 try:
1050 1056 value = repr(eval(name_full, frame.f_globals))
1051 1057 except:
1052 1058 value = undefined
1053 1059 else:
1054 1060 value = undefined
1055 1061 name = tpl_global_var % name_full
1056 1062 lvals_list.append(tpl_name_val % (name, value))
1057 1063 if lvals_list:
1058 1064 lvals = '%s%s' % (indent, em_normal.join(lvals_list))
1059 1065
1060 1066 level = '%s %s\n' % (link, call)
1061 1067
1062 1068 if index is None:
1063 1069 return level
1064 1070 else:
1065 1071 _line_format = PyColorize.Parser(style=col_scheme, parent=self).format2
1066 1072 return '%s%s' % (level, ''.join(
1067 1073 _format_traceback_lines(lnum, index, lines, Colors, lvals,
1068 1074 _line_format)))
1069 1075
1070 1076 def prepare_header(self, etype, long_version=False):
1071 1077 colors = self.Colors # just a shorthand + quicker name lookup
1072 1078 colorsnormal = colors.Normal # used a lot
1073 1079 exc = '%s%s%s' % (colors.excName, etype, colorsnormal)
1074 1080 width = min(75, get_terminal_size()[0])
1075 1081 if long_version:
1076 1082 # Header with the exception type, python version, and date
1077 1083 pyver = 'Python ' + sys.version.split()[0] + ': ' + sys.executable
1078 1084 date = time.ctime(time.time())
1079 1085
1080 1086 head = '%s%s%s\n%s%s%s\n%s' % (colors.topline, '-' * width, colorsnormal,
1081 1087 exc, ' ' * (width - len(str(etype)) - len(pyver)),
1082 1088 pyver, date.rjust(width) )
1083 1089 head += "\nA problem occurred executing Python code. Here is the sequence of function" \
1084 1090 "\ncalls leading up to the error, with the most recent (innermost) call last."
1085 1091 else:
1086 1092 # Simplified header
1087 1093 head = '%s%s' % (exc, 'Traceback (most recent call last)'. \
1088 1094 rjust(width - len(str(etype))) )
1089 1095
1090 1096 return head
1091 1097
1092 1098 def format_exception(self, etype, evalue):
1093 1099 colors = self.Colors # just a shorthand + quicker name lookup
1094 1100 colorsnormal = colors.Normal # used a lot
1095 1101 # Get (safely) a string form of the exception info
1096 1102 try:
1097 1103 etype_str, evalue_str = map(str, (etype, evalue))
1098 1104 except:
1099 1105 # User exception is improperly defined.
1100 1106 etype, evalue = str, sys.exc_info()[:2]
1101 1107 etype_str, evalue_str = map(str, (etype, evalue))
1102 1108 # ... and format it
1103 1109 return ['%s%s%s: %s' % (colors.excName, etype_str,
1104 1110 colorsnormal, py3compat.cast_unicode(evalue_str))]
1105 1111
1106 1112 def format_exception_as_a_whole(self, etype, evalue, etb, number_of_lines_of_context, tb_offset):
1107 1113 """Formats the header, traceback and exception message for a single exception.
1108 1114
1109 1115 This may be called multiple times by Python 3 exception chaining
1110 1116 (PEP 3134).
1111 1117 """
1112 1118 # some locals
1113 1119 orig_etype = etype
1114 1120 try:
1115 1121 etype = etype.__name__
1116 1122 except AttributeError:
1117 1123 pass
1118 1124
1119 1125 tb_offset = self.tb_offset if tb_offset is None else tb_offset
1120 1126 head = self.prepare_header(etype, self.long_header)
1121 1127 records = self.get_records(etb, number_of_lines_of_context, tb_offset)
1122 1128
1123 1129 if records is None:
1124 1130 return ""
1125 1131
1126 1132 last_unique, recursion_repeat = find_recursion(orig_etype, evalue, records)
1127 1133
1128 1134 frames = self.format_records(records, last_unique, recursion_repeat)
1129 1135
1130 1136 formatted_exception = self.format_exception(etype, evalue)
1131 1137 if records:
1132 1138 filepath, lnum = records[-1][1:3]
1133 1139 filepath = os.path.abspath(filepath)
1134 1140 ipinst = get_ipython()
1135 1141 if ipinst is not None:
1136 1142 ipinst.hooks.synchronize_with_editor(filepath, lnum, 0)
1137 1143
1138 1144 return [[head] + frames + [''.join(formatted_exception[0])]]
1139 1145
1140 1146 def get_records(self, etb, number_of_lines_of_context, tb_offset):
1141 1147 try:
1142 1148 # Try the default getinnerframes and Alex's: Alex's fixes some
1143 1149 # problems, but it generates empty tracebacks for console errors
1144 1150 # (5 blanks lines) where none should be returned.
1145 1151 return _fixed_getinnerframes(etb, number_of_lines_of_context, tb_offset)
1146 1152 except UnicodeDecodeError:
1147 1153 # This can occur if a file's encoding magic comment is wrong.
1148 1154 # I can't see a way to recover without duplicating a bunch of code
1149 1155 # from the stdlib traceback module. --TK
1150 1156 error('\nUnicodeDecodeError while processing traceback.\n')
1151 1157 return None
1152 1158 except:
1153 1159 # FIXME: I've been getting many crash reports from python 2.3
1154 1160 # users, traceable to inspect.py. If I can find a small test-case
1155 1161 # to reproduce this, I should either write a better workaround or
1156 1162 # file a bug report against inspect (if that's the real problem).
1157 1163 # So far, I haven't been able to find an isolated example to
1158 1164 # reproduce the problem.
1159 1165 inspect_error()
1160 1166 traceback.print_exc(file=self.ostream)
1161 1167 info('\nUnfortunately, your original traceback can not be constructed.\n')
1162 1168 return None
1163 1169
1164 1170 def structured_traceback(self, etype, evalue, etb, tb_offset=None,
1165 1171 number_of_lines_of_context=5):
1166 1172 """Return a nice text document describing the traceback."""
1167 1173
1168 1174 formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,
1169 1175 tb_offset)
1170 1176
1171 1177 colors = self.Colors # just a shorthand + quicker name lookup
1172 1178 colorsnormal = colors.Normal # used a lot
1173 1179 head = '%s%s%s' % (colors.topline, '-' * min(75, get_terminal_size()[0]), colorsnormal)
1174 1180 structured_traceback_parts = [head]
1175 1181 chained_exceptions_tb_offset = 0
1176 1182 lines_of_context = 3
1177 1183 formatted_exceptions = formatted_exception
1178 1184 exception = self.get_parts_of_chained_exception(evalue)
1179 1185 if exception:
1180 1186 formatted_exceptions += self.prepare_chained_exception_message(evalue.__cause__)
1181 1187 etype, evalue, etb = exception
1182 1188 else:
1183 1189 evalue = None
1184 1190 chained_exc_ids = set()
1185 1191 while evalue:
1186 1192 formatted_exceptions += self.format_exception_as_a_whole(etype, evalue, etb, lines_of_context,
1187 1193 chained_exceptions_tb_offset)
1188 1194 exception = self.get_parts_of_chained_exception(evalue)
1189 1195
1190 1196 if exception and not id(exception[1]) in chained_exc_ids:
1191 1197 chained_exc_ids.add(id(exception[1])) # trace exception to avoid infinite 'cause' loop
1192 1198 formatted_exceptions += self.prepare_chained_exception_message(evalue.__cause__)
1193 1199 etype, evalue, etb = exception
1194 1200 else:
1195 1201 evalue = None
1196 1202
1197 1203 # we want to see exceptions in a reversed order:
1198 1204 # the first exception should be on top
1199 1205 for formatted_exception in reversed(formatted_exceptions):
1200 1206 structured_traceback_parts += formatted_exception
1201 1207
1202 1208 return structured_traceback_parts
1203 1209
1204 1210 def debugger(self, force=False):
1205 1211 """Call up the pdb debugger if desired, always clean up the tb
1206 1212 reference.
1207 1213
1208 1214 Keywords:
1209 1215
1210 1216 - force(False): by default, this routine checks the instance call_pdb
1211 1217 flag and does not actually invoke the debugger if the flag is false.
1212 1218 The 'force' option forces the debugger to activate even if the flag
1213 1219 is false.
1214 1220
1215 1221 If the call_pdb flag is set, the pdb interactive debugger is
1216 1222 invoked. In all cases, the self.tb reference to the current traceback
1217 1223 is deleted to prevent lingering references which hamper memory
1218 1224 management.
1219 1225
1220 1226 Note that each call to pdb() does an 'import readline', so if your app
1221 1227 requires a special setup for the readline completers, you'll have to
1222 1228 fix that by hand after invoking the exception handler."""
1223 1229
1224 1230 if force or self.call_pdb:
1225 1231 if self.pdb is None:
1226 1232 self.pdb = self.debugger_cls()
1227 1233 # the system displayhook may have changed, restore the original
1228 1234 # for pdb
1229 1235 display_trap = DisplayTrap(hook=sys.__displayhook__)
1230 1236 with display_trap:
1231 1237 self.pdb.reset()
1232 1238 # Find the right frame so we don't pop up inside ipython itself
1233 1239 if hasattr(self, 'tb') and self.tb is not None:
1234 1240 etb = self.tb
1235 1241 else:
1236 1242 etb = self.tb = sys.last_traceback
1237 1243 while self.tb is not None and self.tb.tb_next is not None:
1238 1244 self.tb = self.tb.tb_next
1239 1245 if etb and etb.tb_next:
1240 1246 etb = etb.tb_next
1241 1247 self.pdb.botframe = etb.tb_frame
1242 1248 self.pdb.interaction(None, etb)
1243 1249
1244 1250 if hasattr(self, 'tb'):
1245 1251 del self.tb
1246 1252
1247 1253 def handler(self, info=None):
1248 1254 (etype, evalue, etb) = info or sys.exc_info()
1249 1255 self.tb = etb
1250 1256 ostream = self.ostream
1251 1257 ostream.flush()
1252 1258 ostream.write(self.text(etype, evalue, etb))
1253 1259 ostream.write('\n')
1254 1260 ostream.flush()
1255 1261
1256 1262 # Changed so an instance can just be called as VerboseTB_inst() and print
1257 1263 # out the right info on its own.
1258 1264 def __call__(self, etype=None, evalue=None, etb=None):
1259 1265 """This hook can replace sys.excepthook (for Python 2.1 or higher)."""
1260 1266 if etb is None:
1261 1267 self.handler()
1262 1268 else:
1263 1269 self.handler((etype, evalue, etb))
1264 1270 try:
1265 1271 self.debugger()
1266 1272 except KeyboardInterrupt:
1267 1273 print("\nKeyboardInterrupt")
1268 1274
1269 1275
1270 1276 #----------------------------------------------------------------------------
1271 1277 class FormattedTB(VerboseTB, ListTB):
1272 1278 """Subclass ListTB but allow calling with a traceback.
1273 1279
1274 1280 It can thus be used as a sys.excepthook for Python > 2.1.
1275 1281
1276 1282 Also adds 'Context' and 'Verbose' modes, not available in ListTB.
1277 1283
1278 1284 Allows a tb_offset to be specified. This is useful for situations where
1279 1285 one needs to remove a number of topmost frames from the traceback (such as
1280 1286 occurs with python programs that themselves execute other python code,
1281 1287 like Python shells). """
1282 1288
1283 1289 def __init__(self, mode='Plain', color_scheme='Linux', call_pdb=False,
1284 1290 ostream=None,
1285 1291 tb_offset=0, long_header=False, include_vars=False,
1286 1292 check_cache=None, debugger_cls=None,
1287 1293 parent=None, config=None):
1288 1294
1289 1295 # NEVER change the order of this list. Put new modes at the end:
1290 1296 self.valid_modes = ['Plain', 'Context', 'Verbose', 'Minimal']
1291 1297 self.verbose_modes = self.valid_modes[1:3]
1292 1298
1293 1299 VerboseTB.__init__(self, color_scheme=color_scheme, call_pdb=call_pdb,
1294 1300 ostream=ostream, tb_offset=tb_offset,
1295 1301 long_header=long_header, include_vars=include_vars,
1296 1302 check_cache=check_cache, debugger_cls=debugger_cls,
1297 1303 parent=parent, config=config)
1298 1304
1299 1305 # Different types of tracebacks are joined with different separators to
1300 1306 # form a single string. They are taken from this dict
1301 1307 self._join_chars = dict(Plain='', Context='\n', Verbose='\n',
1302 1308 Minimal='')
1303 1309 # set_mode also sets the tb_join_char attribute
1304 1310 self.set_mode(mode)
1305 1311
1306 def _extract_tb(self, tb):
1307 if tb:
1308 return traceback.extract_tb(tb)
1309 else:
1310 return None
1311
1312 1312 def structured_traceback(self, etype, value, tb, tb_offset=None, number_of_lines_of_context=5):
1313 1313 tb_offset = self.tb_offset if tb_offset is None else tb_offset
1314 1314 mode = self.mode
1315 1315 if mode in self.verbose_modes:
1316 1316 # Verbose modes need a full traceback
1317 1317 return VerboseTB.structured_traceback(
1318 1318 self, etype, value, tb, tb_offset, number_of_lines_of_context
1319 1319 )
1320 1320 elif mode == 'Minimal':
1321 1321 return ListTB.get_exception_only(self, etype, value)
1322 1322 else:
1323 1323 # We must check the source cache because otherwise we can print
1324 1324 # out-of-date source code.
1325 1325 self.check_cache()
1326 1326 # Now we can extract and format the exception
1327 1327 return ListTB.structured_traceback(
1328 1328 self, etype, value, tb, tb_offset, number_of_lines_of_context
1329 1329 )
1330 1330
1331 1331 def stb2text(self, stb):
1332 1332 """Convert a structured traceback (a list) to a string."""
1333 1333 return self.tb_join_char.join(stb)
1334 1334
1335 1335
1336 1336 def set_mode(self, mode=None):
1337 1337 """Switch to the desired mode.
1338 1338
1339 1339 If mode is not specified, cycles through the available modes."""
1340 1340
1341 1341 if not mode:
1342 1342 new_idx = (self.valid_modes.index(self.mode) + 1 ) % \
1343 1343 len(self.valid_modes)
1344 1344 self.mode = self.valid_modes[new_idx]
1345 1345 elif mode not in self.valid_modes:
1346 1346 raise ValueError('Unrecognized mode in FormattedTB: <' + mode + '>\n'
1347 1347 'Valid modes: ' + str(self.valid_modes))
1348 1348 else:
1349 1349 self.mode = mode
1350 1350 # include variable details only in 'Verbose' mode
1351 1351 self.include_vars = (self.mode == self.valid_modes[2])
1352 1352 # Set the join character for generating text tracebacks
1353 1353 self.tb_join_char = self._join_chars[self.mode]
1354 1354
1355 1355 # some convenient shortcuts
1356 1356 def plain(self):
1357 1357 self.set_mode(self.valid_modes[0])
1358 1358
1359 1359 def context(self):
1360 1360 self.set_mode(self.valid_modes[1])
1361 1361
1362 1362 def verbose(self):
1363 1363 self.set_mode(self.valid_modes[2])
1364 1364
1365 1365 def minimal(self):
1366 1366 self.set_mode(self.valid_modes[3])
1367 1367
1368 1368
1369 1369 #----------------------------------------------------------------------------
1370 1370 class AutoFormattedTB(FormattedTB):
1371 1371 """A traceback printer which can be called on the fly.
1372 1372
1373 1373 It will find out about exceptions by itself.
1374 1374
1375 1375 A brief example::
1376 1376
1377 1377 AutoTB = AutoFormattedTB(mode = 'Verbose',color_scheme='Linux')
1378 1378 try:
1379 1379 ...
1380 1380 except:
1381 1381 AutoTB() # or AutoTB(out=logfile) where logfile is an open file object
1382 1382 """
1383 1383
1384 1384 def __call__(self, etype=None, evalue=None, etb=None,
1385 1385 out=None, tb_offset=None):
1386 1386 """Print out a formatted exception traceback.
1387 1387
1388 1388 Optional arguments:
1389 1389 - out: an open file-like object to direct output to.
1390 1390
1391 1391 - tb_offset: the number of frames to skip over in the stack, on a
1392 1392 per-call basis (this overrides temporarily the instance's tb_offset
1393 1393 given at initialization time. """
1394 1394
1395 1395 if out is None:
1396 1396 out = self.ostream
1397 1397 out.flush()
1398 1398 out.write(self.text(etype, evalue, etb, tb_offset))
1399 1399 out.write('\n')
1400 1400 out.flush()
1401 1401 # FIXME: we should remove the auto pdb behavior from here and leave
1402 1402 # that to the clients.
1403 1403 try:
1404 1404 self.debugger()
1405 1405 except KeyboardInterrupt:
1406 1406 print("\nKeyboardInterrupt")
1407 1407
1408 1408 def structured_traceback(self, etype=None, value=None, tb=None,
1409 1409 tb_offset=None, number_of_lines_of_context=5):
1410 1410 if etype is None:
1411 1411 etype, value, tb = sys.exc_info()
1412 self.tb = tb
1412 if not isinstance(tb, tuple):
1413 # tb is a tuple if this is a chained exception.
1414 # We keep first traceback.
1415 self.tb = tb
1413 1416 return FormattedTB.structured_traceback(
1414 1417 self, etype, value, tb, tb_offset, number_of_lines_of_context)
1415 1418
1416 1419
1417 1420 #---------------------------------------------------------------------------
1418 1421
1419 1422 # A simple class to preserve Nathan's original functionality.
1420 1423 class ColorTB(FormattedTB):
1421 1424 """Shorthand to initialize a FormattedTB in Linux colors mode."""
1422 1425
1423 1426 def __init__(self, color_scheme='Linux', call_pdb=0, **kwargs):
1424 1427 FormattedTB.__init__(self, color_scheme=color_scheme,
1425 1428 call_pdb=call_pdb, **kwargs)
1426 1429
1427 1430
1428 1431 class SyntaxTB(ListTB):
1429 1432 """Extension which holds some state: the last exception value"""
1430 1433
1431 1434 def __init__(self, color_scheme='NoColor', parent=None, config=None):
1432 1435 ListTB.__init__(self, color_scheme, parent=parent, config=config)
1433 1436 self.last_syntax_error = None
1434 1437
1435 1438 def __call__(self, etype, value, elist):
1436 1439 self.last_syntax_error = value
1437 1440
1438 1441 ListTB.__call__(self, etype, value, elist)
1439 1442
1440 1443 def structured_traceback(self, etype, value, elist, tb_offset=None,
1441 1444 context=5):
1442 1445 # If the source file has been edited, the line in the syntax error can
1443 1446 # be wrong (retrieved from an outdated cache). This replaces it with
1444 1447 # the current value.
1445 1448 if isinstance(value, SyntaxError) \
1446 1449 and isinstance(value.filename, str) \
1447 1450 and isinstance(value.lineno, int):
1448 1451 linecache.checkcache(value.filename)
1449 1452 newtext = linecache.getline(value.filename, value.lineno)
1450 1453 if newtext:
1451 1454 value.text = newtext
1452 1455 self.last_syntax_error = value
1453 1456 return super(SyntaxTB, self).structured_traceback(etype, value, elist,
1454 1457 tb_offset=tb_offset, context=context)
1455 1458
1456 1459 def clear_err_state(self):
1457 1460 """Return the current error state and clear it"""
1458 1461 e = self.last_syntax_error
1459 1462 self.last_syntax_error = None
1460 1463 return e
1461 1464
1462 1465 def stb2text(self, stb):
1463 1466 """Convert a structured traceback (a list) to a string."""
1464 1467 return ''.join(stb)
1465 1468
1466 1469
1467 1470 # some internal-use functions
1468 1471 def text_repr(value):
1469 1472 """Hopefully pretty robust repr equivalent."""
1470 1473 # this is pretty horrible but should always return *something*
1471 1474 try:
1472 1475 return pydoc.text.repr(value)
1473 1476 except KeyboardInterrupt:
1474 1477 raise
1475 1478 except:
1476 1479 try:
1477 1480 return repr(value)
1478 1481 except KeyboardInterrupt:
1479 1482 raise
1480 1483 except:
1481 1484 try:
1482 1485 # all still in an except block so we catch
1483 1486 # getattr raising
1484 1487 name = getattr(value, '__name__', None)
1485 1488 if name:
1486 1489 # ick, recursion
1487 1490 return text_repr(name)
1488 1491 klass = getattr(value, '__class__', None)
1489 1492 if klass:
1490 1493 return '%s instance' % text_repr(klass)
1491 1494 except KeyboardInterrupt:
1492 1495 raise
1493 1496 except:
1494 1497 return 'UNRECOVERABLE REPR FAILURE'
1495 1498
1496 1499
1497 1500 def eqrepr(value, repr=text_repr):
1498 1501 return '=%s' % repr(value)
1499 1502
1500 1503
1501 1504 def nullrepr(value, repr=text_repr):
1502 1505 return ''
General Comments 0
You need to be logged in to leave comments. Login now