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