##// END OF EJS Templates
Make the formatting of a code block name extendable...
Jason Grout -
Show More
@@ -1,199 +1,214 b''
1 """Compiler tools with improved interactive support.
1 """Compiler tools with improved interactive support.
2
2
3 Provides compilation machinery similar to codeop, but with caching support so
3 Provides compilation machinery similar to codeop, but with caching support so
4 we can provide interactive tracebacks.
4 we can provide interactive tracebacks.
5
5
6 Authors
6 Authors
7 -------
7 -------
8 * Robert Kern
8 * Robert Kern
9 * Fernando Perez
9 * Fernando Perez
10 * Thomas Kluyver
10 * Thomas Kluyver
11 """
11 """
12
12
13 # Note: though it might be more natural to name this module 'compiler', that
13 # Note: though it might be more natural to name this module 'compiler', that
14 # name is in the stdlib and name collisions with the stdlib tend to produce
14 # name is in the stdlib and name collisions with the stdlib tend to produce
15 # weird problems (often with third-party tools).
15 # weird problems (often with third-party tools).
16
16
17 #-----------------------------------------------------------------------------
17 #-----------------------------------------------------------------------------
18 # Copyright (C) 2010-2011 The IPython Development Team.
18 # Copyright (C) 2010-2011 The IPython Development Team.
19 #
19 #
20 # Distributed under the terms of the BSD License.
20 # Distributed under the terms of the BSD License.
21 #
21 #
22 # The full license is in the file COPYING.txt, distributed with this software.
22 # The full license is in the file COPYING.txt, distributed with this software.
23 #-----------------------------------------------------------------------------
23 #-----------------------------------------------------------------------------
24
24
25 #-----------------------------------------------------------------------------
25 #-----------------------------------------------------------------------------
26 # Imports
26 # Imports
27 #-----------------------------------------------------------------------------
27 #-----------------------------------------------------------------------------
28
28
29 # Stdlib imports
29 # Stdlib imports
30 import __future__
30 import __future__
31 from ast import PyCF_ONLY_AST
31 from ast import PyCF_ONLY_AST
32 import codeop
32 import codeop
33 import functools
33 import functools
34 import hashlib
34 import hashlib
35 import linecache
35 import linecache
36 import operator
36 import operator
37 import time
37 import time
38 from contextlib import contextmanager
38 from contextlib import contextmanager
39
39
40 #-----------------------------------------------------------------------------
40 #-----------------------------------------------------------------------------
41 # Constants
41 # Constants
42 #-----------------------------------------------------------------------------
42 #-----------------------------------------------------------------------------
43
43
44 # Roughly equal to PyCF_MASK | PyCF_MASK_OBSOLETE as defined in pythonrun.h,
44 # Roughly equal to PyCF_MASK | PyCF_MASK_OBSOLETE as defined in pythonrun.h,
45 # this is used as a bitmask to extract future-related code flags.
45 # this is used as a bitmask to extract future-related code flags.
46 PyCF_MASK = functools.reduce(operator.or_,
46 PyCF_MASK = functools.reduce(operator.or_,
47 (getattr(__future__, fname).compiler_flag
47 (getattr(__future__, fname).compiler_flag
48 for fname in __future__.all_feature_names))
48 for fname in __future__.all_feature_names))
49
49
50 #-----------------------------------------------------------------------------
50 #-----------------------------------------------------------------------------
51 # Local utilities
51 # Local utilities
52 #-----------------------------------------------------------------------------
52 #-----------------------------------------------------------------------------
53
53
54 def code_name(code, number=0):
54 def code_name(code, number=0):
55 """ Compute a (probably) unique name for code for caching.
55 """ Compute a (probably) unique name for code for caching.
56
56
57 This now expects code to be unicode.
57 This now expects code to be unicode.
58 """
58 """
59 hash_digest = hashlib.sha1(code.encode("utf-8")).hexdigest()
59 hash_digest = hashlib.sha1(code.encode("utf-8")).hexdigest()
60 # Include the number and 12 characters of the hash in the name. It's
60 # Include the number and 12 characters of the hash in the name. It's
61 # pretty much impossible that in a single session we'll have collisions
61 # pretty much impossible that in a single session we'll have collisions
62 # even with truncated hashes, and the full one makes tracebacks too long
62 # even with truncated hashes, and the full one makes tracebacks too long
63 return '<ipython-input-{0}-{1}>'.format(number, hash_digest[:12])
63 return '<ipython-input-{0}-{1}>'.format(number, hash_digest[:12])
64
64
65 #-----------------------------------------------------------------------------
65 #-----------------------------------------------------------------------------
66 # Classes and functions
66 # Classes and functions
67 #-----------------------------------------------------------------------------
67 #-----------------------------------------------------------------------------
68
68
69 class CachingCompiler(codeop.Compile):
69 class CachingCompiler(codeop.Compile):
70 """A compiler that caches code compiled from interactive statements.
70 """A compiler that caches code compiled from interactive statements.
71 """
71 """
72
72
73 def __init__(self):
73 def __init__(self):
74 codeop.Compile.__init__(self)
74 codeop.Compile.__init__(self)
75
75
76 # Caching a dictionary { filename: execution_count } for nicely
76 # Caching a dictionary { filename: execution_count } for nicely
77 # rendered tracebacks. The filename corresponds to the filename
77 # rendered tracebacks. The filename corresponds to the filename
78 # argument used for the builtins.compile function.
78 # argument used for the builtins.compile function.
79 self._filename_map = {}
79 self._filename_map = {}
80
80
81 def ast_parse(self, source, filename='<unknown>', symbol='exec'):
81 def ast_parse(self, source, filename='<unknown>', symbol='exec'):
82 """Parse code to an AST with the current compiler flags active.
82 """Parse code to an AST with the current compiler flags active.
83
83
84 Arguments are exactly the same as ast.parse (in the standard library),
84 Arguments are exactly the same as ast.parse (in the standard library),
85 and are passed to the built-in compile function."""
85 and are passed to the built-in compile function."""
86 return compile(source, filename, symbol, self.flags | PyCF_ONLY_AST, 1)
86 return compile(source, filename, symbol, self.flags | PyCF_ONLY_AST, 1)
87
87
88 def reset_compiler_flags(self):
88 def reset_compiler_flags(self):
89 """Reset compiler flags to default state."""
89 """Reset compiler flags to default state."""
90 # This value is copied from codeop.Compile.__init__, so if that ever
90 # This value is copied from codeop.Compile.__init__, so if that ever
91 # changes, it will need to be updated.
91 # changes, it will need to be updated.
92 self.flags = codeop.PyCF_DONT_IMPLY_DEDENT
92 self.flags = codeop.PyCF_DONT_IMPLY_DEDENT
93
93
94 @property
94 @property
95 def compiler_flags(self):
95 def compiler_flags(self):
96 """Flags currently active in the compilation process.
96 """Flags currently active in the compilation process.
97 """
97 """
98 return self.flags
98 return self.flags
99
99
100 def get_code_name(self, raw_code, transformed_code, number):
100 def get_code_name(self, raw_code, transformed_code, number):
101 """Compute filename given the code, and the cell number.
101 """Compute filename given the code, and the cell number.
102
102
103 Parameters
103 Parameters
104 ----------
104 ----------
105 raw_code : str
105 raw_code : str
106 The raw cell code.
106 The raw cell code.
107 transformed_code : str
107 transformed_code : str
108 The executable Python source code to cache and compile.
108 The executable Python source code to cache and compile.
109 number : int
109 number : int
110 A number which forms part of the code's name. Used for the execution
110 A number which forms part of the code's name. Used for the execution
111 counter.
111 counter.
112
112
113 Returns
113 Returns
114 -------
114 -------
115 The computed filename.
115 The computed filename.
116 """
116 """
117 return code_name(transformed_code, number)
117 return code_name(transformed_code, number)
118
118
119 def format_code_name(self, name):
120 """Return a user-friendly label and name for a code block.
121
122 Parameters
123 ----------
124 name : str
125 The name for the code block returned from get_code_name
126
127 Returns
128 -------
129 A (label, name) pair that can be used in tracebacks, or None if the default formatting should be used.
130 """
131 if name in self._filename_map:
132 return "Cell", "In[%s]" % self._filename_map[name]
133
119 def cache(self, transformed_code, number=0, raw_code=None):
134 def cache(self, transformed_code, number=0, raw_code=None):
120 """Make a name for a block of code, and cache the code.
135 """Make a name for a block of code, and cache the code.
121
136
122 Parameters
137 Parameters
123 ----------
138 ----------
124 transformed_code : str
139 transformed_code : str
125 The executable Python source code to cache and compile.
140 The executable Python source code to cache and compile.
126 number : int
141 number : int
127 A number which forms part of the code's name. Used for the execution
142 A number which forms part of the code's name. Used for the execution
128 counter.
143 counter.
129 raw_code : str
144 raw_code : str
130 The raw code before transformation, if None, set to `transformed_code`.
145 The raw code before transformation, if None, set to `transformed_code`.
131
146
132 Returns
147 Returns
133 -------
148 -------
134 The name of the cached code (as a string). Pass this as the filename
149 The name of the cached code (as a string). Pass this as the filename
135 argument to compilation, so that tracebacks are correctly hooked up.
150 argument to compilation, so that tracebacks are correctly hooked up.
136 """
151 """
137 if raw_code is None:
152 if raw_code is None:
138 raw_code = transformed_code
153 raw_code = transformed_code
139
154
140 name = self.get_code_name(raw_code, transformed_code, number)
155 name = self.get_code_name(raw_code, transformed_code, number)
141
156
142 # Save the execution count
157 # Save the execution count
143 self._filename_map[name] = number
158 self._filename_map[name] = number
144
159
145 # Since Python 2.5, setting mtime to `None` means the lines will
160 # Since Python 2.5, setting mtime to `None` means the lines will
146 # never be removed by `linecache.checkcache`. This means all the
161 # never be removed by `linecache.checkcache`. This means all the
147 # monkeypatching has *never* been necessary, since this code was
162 # monkeypatching has *never* been necessary, since this code was
148 # only added in 2010, at which point IPython had already stopped
163 # only added in 2010, at which point IPython had already stopped
149 # supporting Python 2.4.
164 # supporting Python 2.4.
150 #
165 #
151 # Note that `linecache.clearcache` and `linecache.updatecache` may
166 # Note that `linecache.clearcache` and `linecache.updatecache` may
152 # still remove our code from the cache, but those show explicit
167 # still remove our code from the cache, but those show explicit
153 # intent, and we should not try to interfere. Normally the former
168 # intent, and we should not try to interfere. Normally the former
154 # is never called except when out of memory, and the latter is only
169 # is never called except when out of memory, and the latter is only
155 # called for lines *not* in the cache.
170 # called for lines *not* in the cache.
156 entry = (
171 entry = (
157 len(transformed_code),
172 len(transformed_code),
158 None,
173 None,
159 [line + "\n" for line in transformed_code.splitlines()],
174 [line + "\n" for line in transformed_code.splitlines()],
160 name,
175 name,
161 )
176 )
162 linecache.cache[name] = entry
177 linecache.cache[name] = entry
163 return name
178 return name
164
179
165 @contextmanager
180 @contextmanager
166 def extra_flags(self, flags):
181 def extra_flags(self, flags):
167 ## bits that we'll set to 1
182 ## bits that we'll set to 1
168 turn_on_bits = ~self.flags & flags
183 turn_on_bits = ~self.flags & flags
169
184
170
185
171 self.flags = self.flags | flags
186 self.flags = self.flags | flags
172 try:
187 try:
173 yield
188 yield
174 finally:
189 finally:
175 # turn off only the bits we turned on so that something like
190 # turn off only the bits we turned on so that something like
176 # __future__ that set flags stays.
191 # __future__ that set flags stays.
177 self.flags &= ~turn_on_bits
192 self.flags &= ~turn_on_bits
178
193
179
194
180 def check_linecache_ipython(*args):
195 def check_linecache_ipython(*args):
181 """Deprecated since IPython 8.6. Call linecache.checkcache() directly.
196 """Deprecated since IPython 8.6. Call linecache.checkcache() directly.
182
197
183 It was already not necessary to call this function directly. If no
198 It was already not necessary to call this function directly. If no
184 CachingCompiler had been created, this function would fail badly. If
199 CachingCompiler had been created, this function would fail badly. If
185 an instance had been created, this function would've been monkeypatched
200 an instance had been created, this function would've been monkeypatched
186 into place.
201 into place.
187
202
188 As of IPython 8.6, the monkeypatching has gone away entirely. But there
203 As of IPython 8.6, the monkeypatching has gone away entirely. But there
189 were still internal callers of this function, so maybe external callers
204 were still internal callers of this function, so maybe external callers
190 also existed?
205 also existed?
191 """
206 """
192 import warnings
207 import warnings
193
208
194 warnings.warn(
209 warnings.warn(
195 "Deprecated Since IPython 8.6, Just call linecache.checkcache() directly.",
210 "Deprecated Since IPython 8.6, Just call linecache.checkcache() directly.",
196 DeprecationWarning,
211 DeprecationWarning,
197 stacklevel=2,
212 stacklevel=2,
198 )
213 )
199 linecache.checkcache()
214 linecache.checkcache()
@@ -1,1201 +1,1207 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 inspect
92 import inspect
93 import linecache
93 import linecache
94 import pydoc
94 import pydoc
95 import sys
95 import sys
96 import time
96 import time
97 import traceback
97 import traceback
98 from types import TracebackType
98 from types import TracebackType
99 from typing import Tuple, List, Any, Optional
99 from typing import Tuple, List, Any, Optional
100
100
101 import stack_data
101 import stack_data
102 from pygments.formatters.terminal256 import Terminal256Formatter
102 from pygments.formatters.terminal256 import Terminal256Formatter
103 from pygments.styles import get_style_by_name
103 from pygments.styles import get_style_by_name
104
104
105 # IPython's own modules
105 # IPython's own modules
106 from IPython import get_ipython
106 from IPython import get_ipython
107 from IPython.core import debugger
107 from IPython.core import debugger
108 from IPython.core.display_trap import DisplayTrap
108 from IPython.core.display_trap import DisplayTrap
109 from IPython.core.excolors import exception_colors
109 from IPython.core.excolors import exception_colors
110 from IPython.utils import path as util_path
110 from IPython.utils import path as util_path
111 from IPython.utils import py3compat
111 from IPython.utils import py3compat
112 from IPython.utils.terminal import get_terminal_size
112 from IPython.utils.terminal import get_terminal_size
113
113
114 import IPython.utils.colorable as colorable
114 import IPython.utils.colorable as colorable
115
115
116 # Globals
116 # Globals
117 # amount of space to put line numbers before verbose tracebacks
117 # amount of space to put line numbers before verbose tracebacks
118 INDENT_SIZE = 8
118 INDENT_SIZE = 8
119
119
120 # Default color scheme. This is used, for example, by the traceback
120 # Default color scheme. This is used, for example, by the traceback
121 # formatter. When running in an actual IPython instance, the user's rc.colors
121 # formatter. When running in an actual IPython instance, the user's rc.colors
122 # value is used, but having a module global makes this functionality available
122 # value is used, but having a module global makes this functionality available
123 # to users of ultratb who are NOT running inside ipython.
123 # to users of ultratb who are NOT running inside ipython.
124 DEFAULT_SCHEME = 'NoColor'
124 DEFAULT_SCHEME = 'NoColor'
125
125
126 # ---------------------------------------------------------------------------
126 # ---------------------------------------------------------------------------
127 # Code begins
127 # Code begins
128
128
129 # Helper function -- largely belongs to VerboseTB, but we need the same
129 # Helper function -- largely belongs to VerboseTB, but we need the same
130 # functionality to produce a pseudo verbose TB for SyntaxErrors, so that they
130 # functionality to produce a pseudo verbose TB for SyntaxErrors, so that they
131 # can be recognized properly by ipython.el's py-traceback-line-re
131 # can be recognized properly by ipython.el's py-traceback-line-re
132 # (SyntaxErrors have to be treated specially because they have no traceback)
132 # (SyntaxErrors have to be treated specially because they have no traceback)
133
133
134
134
135 def _format_traceback_lines(lines, Colors, has_colors: bool, lvals):
135 def _format_traceback_lines(lines, Colors, has_colors: bool, lvals):
136 """
136 """
137 Format tracebacks lines with pointing arrow, leading numbers...
137 Format tracebacks lines with pointing arrow, leading numbers...
138
138
139 Parameters
139 Parameters
140 ----------
140 ----------
141 lines : list[Line]
141 lines : list[Line]
142 Colors
142 Colors
143 ColorScheme used.
143 ColorScheme used.
144 lvals : str
144 lvals : str
145 Values of local variables, already colored, to inject just after the error line.
145 Values of local variables, already colored, to inject just after the error line.
146 """
146 """
147 numbers_width = INDENT_SIZE - 1
147 numbers_width = INDENT_SIZE - 1
148 res = []
148 res = []
149
149
150 for stack_line in lines:
150 for stack_line in lines:
151 if stack_line is stack_data.LINE_GAP:
151 if stack_line is stack_data.LINE_GAP:
152 res.append('%s (...)%s\n' % (Colors.linenoEm, Colors.Normal))
152 res.append('%s (...)%s\n' % (Colors.linenoEm, Colors.Normal))
153 continue
153 continue
154
154
155 line = stack_line.render(pygmented=has_colors).rstrip('\n') + '\n'
155 line = stack_line.render(pygmented=has_colors).rstrip('\n') + '\n'
156 lineno = stack_line.lineno
156 lineno = stack_line.lineno
157 if stack_line.is_current:
157 if stack_line.is_current:
158 # This is the line with the error
158 # This is the line with the error
159 pad = numbers_width - len(str(lineno))
159 pad = numbers_width - len(str(lineno))
160 num = '%s%s' % (debugger.make_arrow(pad), str(lineno))
160 num = '%s%s' % (debugger.make_arrow(pad), str(lineno))
161 start_color = Colors.linenoEm
161 start_color = Colors.linenoEm
162 else:
162 else:
163 num = '%*s' % (numbers_width, lineno)
163 num = '%*s' % (numbers_width, lineno)
164 start_color = Colors.lineno
164 start_color = Colors.lineno
165
165
166 line = '%s%s%s %s' % (start_color, num, Colors.Normal, line)
166 line = '%s%s%s %s' % (start_color, num, Colors.Normal, line)
167
167
168 res.append(line)
168 res.append(line)
169 if lvals and stack_line.is_current:
169 if lvals and stack_line.is_current:
170 res.append(lvals + '\n')
170 res.append(lvals + '\n')
171 return res
171 return res
172
172
173
173
174 def _format_filename(file, ColorFilename, ColorNormal, *, lineno=None):
174 def _format_filename(file, ColorFilename, ColorNormal, *, lineno=None):
175 """
175 """
176 Format filename lines with `In [n]` if it's the nth code cell or `File *.py` if it's a module.
176 Format filename lines with custom formatting from caching compiler or `File *.py` by default
177
177
178 Parameters
178 Parameters
179 ----------
179 ----------
180 file : str
180 file : str
181 ColorFilename
181 ColorFilename
182 ColorScheme's filename coloring to be used.
182 ColorScheme's filename coloring to be used.
183 ColorNormal
183 ColorNormal
184 ColorScheme's normal coloring to be used.
184 ColorScheme's normal coloring to be used.
185 """
185 """
186 ipinst = get_ipython()
186 ipinst = get_ipython()
187
187 if (
188 if ipinst is not None and file in ipinst.compile._filename_map:
188 ipinst is not None
189 file = "[%s]" % ipinst.compile._filename_map[file]
189 and (data := ipinst.compile.format_code_name(file)) is not None
190 ):
191 label, name = data
190 if lineno is None:
192 if lineno is None:
191 tpl_link = f"Cell {ColorFilename}In {{file}}{ColorNormal}"
193 tpl_link = f"{{label}} {ColorFilename}{{name}}{ColorNormal}"
192 else:
194 else:
193 tpl_link = f"Cell {ColorFilename}In {{file}}, line {{lineno}}{ColorNormal}"
195 tpl_link = (
196 f"{{label}} {ColorFilename}{{name}}, line {{lineno}}{ColorNormal}"
197 )
194 else:
198 else:
195 file = util_path.compress_user(
199 label = "File"
200 name = util_path.compress_user(
196 py3compat.cast_unicode(file, util_path.fs_encoding)
201 py3compat.cast_unicode(file, util_path.fs_encoding)
197 )
202 )
198 if lineno is None:
203 if lineno is None:
199 tpl_link = f"File {ColorFilename}{{file}}{ColorNormal}"
204 tpl_link = f"{{label}} {ColorFilename}{{name}}{ColorNormal}"
200 else:
205 else:
201 tpl_link = f"File {ColorFilename}{{file}}:{{lineno}}{ColorNormal}"
206 # can we make this the more friendly ", line {{lineno}}", or do we need to preserve the formatting with the colon?
207 tpl_link = f"{{label}} {ColorFilename}{{name}}:{{lineno}}{ColorNormal}"
202
208
203 return tpl_link.format(file=file, lineno=lineno)
209 return tpl_link.format(label=label, name=name, lineno=lineno)
204
210
205 #---------------------------------------------------------------------------
211 #---------------------------------------------------------------------------
206 # Module classes
212 # Module classes
207 class TBTools(colorable.Colorable):
213 class TBTools(colorable.Colorable):
208 """Basic tools used by all traceback printer classes."""
214 """Basic tools used by all traceback printer classes."""
209
215
210 # Number of frames to skip when reporting tracebacks
216 # Number of frames to skip when reporting tracebacks
211 tb_offset = 0
217 tb_offset = 0
212
218
213 def __init__(
219 def __init__(
214 self,
220 self,
215 color_scheme="NoColor",
221 color_scheme="NoColor",
216 call_pdb=False,
222 call_pdb=False,
217 ostream=None,
223 ostream=None,
218 parent=None,
224 parent=None,
219 config=None,
225 config=None,
220 *,
226 *,
221 debugger_cls=None,
227 debugger_cls=None,
222 ):
228 ):
223 # Whether to call the interactive pdb debugger after printing
229 # Whether to call the interactive pdb debugger after printing
224 # tracebacks or not
230 # tracebacks or not
225 super(TBTools, self).__init__(parent=parent, config=config)
231 super(TBTools, self).__init__(parent=parent, config=config)
226 self.call_pdb = call_pdb
232 self.call_pdb = call_pdb
227
233
228 # Output stream to write to. Note that we store the original value in
234 # Output stream to write to. Note that we store the original value in
229 # a private attribute and then make the public ostream a property, so
235 # a private attribute and then make the public ostream a property, so
230 # that we can delay accessing sys.stdout until runtime. The way
236 # that we can delay accessing sys.stdout until runtime. The way
231 # things are written now, the sys.stdout object is dynamically managed
237 # things are written now, the sys.stdout object is dynamically managed
232 # so a reference to it should NEVER be stored statically. This
238 # so a reference to it should NEVER be stored statically. This
233 # property approach confines this detail to a single location, and all
239 # property approach confines this detail to a single location, and all
234 # subclasses can simply access self.ostream for writing.
240 # subclasses can simply access self.ostream for writing.
235 self._ostream = ostream
241 self._ostream = ostream
236
242
237 # Create color table
243 # Create color table
238 self.color_scheme_table = exception_colors()
244 self.color_scheme_table = exception_colors()
239
245
240 self.set_colors(color_scheme)
246 self.set_colors(color_scheme)
241 self.old_scheme = color_scheme # save initial value for toggles
247 self.old_scheme = color_scheme # save initial value for toggles
242 self.debugger_cls = debugger_cls or debugger.Pdb
248 self.debugger_cls = debugger_cls or debugger.Pdb
243
249
244 if call_pdb:
250 if call_pdb:
245 self.pdb = self.debugger_cls()
251 self.pdb = self.debugger_cls()
246 else:
252 else:
247 self.pdb = None
253 self.pdb = None
248
254
249 def _get_ostream(self):
255 def _get_ostream(self):
250 """Output stream that exceptions are written to.
256 """Output stream that exceptions are written to.
251
257
252 Valid values are:
258 Valid values are:
253
259
254 - None: the default, which means that IPython will dynamically resolve
260 - None: the default, which means that IPython will dynamically resolve
255 to sys.stdout. This ensures compatibility with most tools, including
261 to sys.stdout. This ensures compatibility with most tools, including
256 Windows (where plain stdout doesn't recognize ANSI escapes).
262 Windows (where plain stdout doesn't recognize ANSI escapes).
257
263
258 - Any object with 'write' and 'flush' attributes.
264 - Any object with 'write' and 'flush' attributes.
259 """
265 """
260 return sys.stdout if self._ostream is None else self._ostream
266 return sys.stdout if self._ostream is None else self._ostream
261
267
262 def _set_ostream(self, val):
268 def _set_ostream(self, val):
263 assert val is None or (hasattr(val, 'write') and hasattr(val, 'flush'))
269 assert val is None or (hasattr(val, 'write') and hasattr(val, 'flush'))
264 self._ostream = val
270 self._ostream = val
265
271
266 ostream = property(_get_ostream, _set_ostream)
272 ostream = property(_get_ostream, _set_ostream)
267
273
268 @staticmethod
274 @staticmethod
269 def _get_chained_exception(exception_value):
275 def _get_chained_exception(exception_value):
270 cause = getattr(exception_value, "__cause__", None)
276 cause = getattr(exception_value, "__cause__", None)
271 if cause:
277 if cause:
272 return cause
278 return cause
273 if getattr(exception_value, "__suppress_context__", False):
279 if getattr(exception_value, "__suppress_context__", False):
274 return None
280 return None
275 return getattr(exception_value, "__context__", None)
281 return getattr(exception_value, "__context__", None)
276
282
277 def get_parts_of_chained_exception(
283 def get_parts_of_chained_exception(
278 self, evalue
284 self, evalue
279 ) -> Optional[Tuple[type, BaseException, TracebackType]]:
285 ) -> Optional[Tuple[type, BaseException, TracebackType]]:
280
286
281 chained_evalue = self._get_chained_exception(evalue)
287 chained_evalue = self._get_chained_exception(evalue)
282
288
283 if chained_evalue:
289 if chained_evalue:
284 return chained_evalue.__class__, chained_evalue, chained_evalue.__traceback__
290 return chained_evalue.__class__, chained_evalue, chained_evalue.__traceback__
285 return None
291 return None
286
292
287 def prepare_chained_exception_message(self, cause) -> List[Any]:
293 def prepare_chained_exception_message(self, cause) -> List[Any]:
288 direct_cause = "\nThe above exception was the direct cause of the following exception:\n"
294 direct_cause = "\nThe above exception was the direct cause of the following exception:\n"
289 exception_during_handling = "\nDuring handling of the above exception, another exception occurred:\n"
295 exception_during_handling = "\nDuring handling of the above exception, another exception occurred:\n"
290
296
291 if cause:
297 if cause:
292 message = [[direct_cause]]
298 message = [[direct_cause]]
293 else:
299 else:
294 message = [[exception_during_handling]]
300 message = [[exception_during_handling]]
295 return message
301 return message
296
302
297 @property
303 @property
298 def has_colors(self) -> bool:
304 def has_colors(self) -> bool:
299 return self.color_scheme_table.active_scheme_name.lower() != "nocolor"
305 return self.color_scheme_table.active_scheme_name.lower() != "nocolor"
300
306
301 def set_colors(self, *args, **kw):
307 def set_colors(self, *args, **kw):
302 """Shorthand access to the color table scheme selector method."""
308 """Shorthand access to the color table scheme selector method."""
303
309
304 # Set own color table
310 # Set own color table
305 self.color_scheme_table.set_active_scheme(*args, **kw)
311 self.color_scheme_table.set_active_scheme(*args, **kw)
306 # for convenience, set Colors to the active scheme
312 # for convenience, set Colors to the active scheme
307 self.Colors = self.color_scheme_table.active_colors
313 self.Colors = self.color_scheme_table.active_colors
308 # Also set colors of debugger
314 # Also set colors of debugger
309 if hasattr(self, 'pdb') and self.pdb is not None:
315 if hasattr(self, 'pdb') and self.pdb is not None:
310 self.pdb.set_colors(*args, **kw)
316 self.pdb.set_colors(*args, **kw)
311
317
312 def color_toggle(self):
318 def color_toggle(self):
313 """Toggle between the currently active color scheme and NoColor."""
319 """Toggle between the currently active color scheme and NoColor."""
314
320
315 if self.color_scheme_table.active_scheme_name == 'NoColor':
321 if self.color_scheme_table.active_scheme_name == 'NoColor':
316 self.color_scheme_table.set_active_scheme(self.old_scheme)
322 self.color_scheme_table.set_active_scheme(self.old_scheme)
317 self.Colors = self.color_scheme_table.active_colors
323 self.Colors = self.color_scheme_table.active_colors
318 else:
324 else:
319 self.old_scheme = self.color_scheme_table.active_scheme_name
325 self.old_scheme = self.color_scheme_table.active_scheme_name
320 self.color_scheme_table.set_active_scheme('NoColor')
326 self.color_scheme_table.set_active_scheme('NoColor')
321 self.Colors = self.color_scheme_table.active_colors
327 self.Colors = self.color_scheme_table.active_colors
322
328
323 def stb2text(self, stb):
329 def stb2text(self, stb):
324 """Convert a structured traceback (a list) to a string."""
330 """Convert a structured traceback (a list) to a string."""
325 return '\n'.join(stb)
331 return '\n'.join(stb)
326
332
327 def text(self, etype, value, tb, tb_offset: Optional[int] = None, context=5):
333 def text(self, etype, value, tb, tb_offset: Optional[int] = None, context=5):
328 """Return formatted traceback.
334 """Return formatted traceback.
329
335
330 Subclasses may override this if they add extra arguments.
336 Subclasses may override this if they add extra arguments.
331 """
337 """
332 tb_list = self.structured_traceback(etype, value, tb,
338 tb_list = self.structured_traceback(etype, value, tb,
333 tb_offset, context)
339 tb_offset, context)
334 return self.stb2text(tb_list)
340 return self.stb2text(tb_list)
335
341
336 def structured_traceback(
342 def structured_traceback(
337 self, etype, evalue, tb, tb_offset: Optional[int] = None, context=5, mode=None
343 self, etype, evalue, tb, tb_offset: Optional[int] = None, context=5, mode=None
338 ):
344 ):
339 """Return a list of traceback frames.
345 """Return a list of traceback frames.
340
346
341 Must be implemented by each class.
347 Must be implemented by each class.
342 """
348 """
343 raise NotImplementedError()
349 raise NotImplementedError()
344
350
345
351
346 #---------------------------------------------------------------------------
352 #---------------------------------------------------------------------------
347 class ListTB(TBTools):
353 class ListTB(TBTools):
348 """Print traceback information from a traceback list, with optional color.
354 """Print traceback information from a traceback list, with optional color.
349
355
350 Calling requires 3 arguments: (etype, evalue, elist)
356 Calling requires 3 arguments: (etype, evalue, elist)
351 as would be obtained by::
357 as would be obtained by::
352
358
353 etype, evalue, tb = sys.exc_info()
359 etype, evalue, tb = sys.exc_info()
354 if tb:
360 if tb:
355 elist = traceback.extract_tb(tb)
361 elist = traceback.extract_tb(tb)
356 else:
362 else:
357 elist = None
363 elist = None
358
364
359 It can thus be used by programs which need to process the traceback before
365 It can thus be used by programs which need to process the traceback before
360 printing (such as console replacements based on the code module from the
366 printing (such as console replacements based on the code module from the
361 standard library).
367 standard library).
362
368
363 Because they are meant to be called without a full traceback (only a
369 Because they are meant to be called without a full traceback (only a
364 list), instances of this class can't call the interactive pdb debugger."""
370 list), instances of this class can't call the interactive pdb debugger."""
365
371
366
372
367 def __call__(self, etype, value, elist):
373 def __call__(self, etype, value, elist):
368 self.ostream.flush()
374 self.ostream.flush()
369 self.ostream.write(self.text(etype, value, elist))
375 self.ostream.write(self.text(etype, value, elist))
370 self.ostream.write('\n')
376 self.ostream.write('\n')
371
377
372 def _extract_tb(self, tb):
378 def _extract_tb(self, tb):
373 if tb:
379 if tb:
374 return traceback.extract_tb(tb)
380 return traceback.extract_tb(tb)
375 else:
381 else:
376 return None
382 return None
377
383
378 def structured_traceback(
384 def structured_traceback(
379 self,
385 self,
380 etype: type,
386 etype: type,
381 evalue: BaseException,
387 evalue: BaseException,
382 etb: Optional[TracebackType] = None,
388 etb: Optional[TracebackType] = None,
383 tb_offset: Optional[int] = None,
389 tb_offset: Optional[int] = None,
384 context=5,
390 context=5,
385 ):
391 ):
386 """Return a color formatted string with the traceback info.
392 """Return a color formatted string with the traceback info.
387
393
388 Parameters
394 Parameters
389 ----------
395 ----------
390 etype : exception type
396 etype : exception type
391 Type of the exception raised.
397 Type of the exception raised.
392 evalue : object
398 evalue : object
393 Data stored in the exception
399 Data stored in the exception
394 etb : list | TracebackType | None
400 etb : list | TracebackType | None
395 If list: List of frames, see class docstring for details.
401 If list: List of frames, see class docstring for details.
396 If Traceback: Traceback of the exception.
402 If Traceback: Traceback of the exception.
397 tb_offset : int, optional
403 tb_offset : int, optional
398 Number of frames in the traceback to skip. If not given, the
404 Number of frames in the traceback to skip. If not given, the
399 instance evalue is used (set in constructor).
405 instance evalue is used (set in constructor).
400 context : int, optional
406 context : int, optional
401 Number of lines of context information to print.
407 Number of lines of context information to print.
402
408
403 Returns
409 Returns
404 -------
410 -------
405 String with formatted exception.
411 String with formatted exception.
406 """
412 """
407 # This is a workaround to get chained_exc_ids in recursive calls
413 # This is a workaround to get chained_exc_ids in recursive calls
408 # etb should not be a tuple if structured_traceback is not recursive
414 # etb should not be a tuple if structured_traceback is not recursive
409 if isinstance(etb, tuple):
415 if isinstance(etb, tuple):
410 etb, chained_exc_ids = etb
416 etb, chained_exc_ids = etb
411 else:
417 else:
412 chained_exc_ids = set()
418 chained_exc_ids = set()
413
419
414 if isinstance(etb, list):
420 if isinstance(etb, list):
415 elist = etb
421 elist = etb
416 elif etb is not None:
422 elif etb is not None:
417 elist = self._extract_tb(etb)
423 elist = self._extract_tb(etb)
418 else:
424 else:
419 elist = []
425 elist = []
420 tb_offset = self.tb_offset if tb_offset is None else tb_offset
426 tb_offset = self.tb_offset if tb_offset is None else tb_offset
421 assert isinstance(tb_offset, int)
427 assert isinstance(tb_offset, int)
422 Colors = self.Colors
428 Colors = self.Colors
423 out_list = []
429 out_list = []
424 if elist:
430 if elist:
425
431
426 if tb_offset and len(elist) > tb_offset:
432 if tb_offset and len(elist) > tb_offset:
427 elist = elist[tb_offset:]
433 elist = elist[tb_offset:]
428
434
429 out_list.append('Traceback %s(most recent call last)%s:' %
435 out_list.append('Traceback %s(most recent call last)%s:' %
430 (Colors.normalEm, Colors.Normal) + '\n')
436 (Colors.normalEm, Colors.Normal) + '\n')
431 out_list.extend(self._format_list(elist))
437 out_list.extend(self._format_list(elist))
432 # The exception info should be a single entry in the list.
438 # The exception info should be a single entry in the list.
433 lines = ''.join(self._format_exception_only(etype, evalue))
439 lines = ''.join(self._format_exception_only(etype, evalue))
434 out_list.append(lines)
440 out_list.append(lines)
435
441
436 exception = self.get_parts_of_chained_exception(evalue)
442 exception = self.get_parts_of_chained_exception(evalue)
437
443
438 if exception and not id(exception[1]) in chained_exc_ids:
444 if exception and not id(exception[1]) in chained_exc_ids:
439 chained_exception_message = self.prepare_chained_exception_message(
445 chained_exception_message = self.prepare_chained_exception_message(
440 evalue.__cause__)[0]
446 evalue.__cause__)[0]
441 etype, evalue, etb = exception
447 etype, evalue, etb = exception
442 # Trace exception to avoid infinite 'cause' loop
448 # Trace exception to avoid infinite 'cause' loop
443 chained_exc_ids.add(id(exception[1]))
449 chained_exc_ids.add(id(exception[1]))
444 chained_exceptions_tb_offset = 0
450 chained_exceptions_tb_offset = 0
445 out_list = (
451 out_list = (
446 self.structured_traceback(
452 self.structured_traceback(
447 etype, evalue, (etb, chained_exc_ids),
453 etype, evalue, (etb, chained_exc_ids),
448 chained_exceptions_tb_offset, context)
454 chained_exceptions_tb_offset, context)
449 + chained_exception_message
455 + chained_exception_message
450 + out_list)
456 + out_list)
451
457
452 return out_list
458 return out_list
453
459
454 def _format_list(self, extracted_list):
460 def _format_list(self, extracted_list):
455 """Format a list of traceback entry tuples for printing.
461 """Format a list of traceback entry tuples for printing.
456
462
457 Given a list of tuples as returned by extract_tb() or
463 Given a list of tuples as returned by extract_tb() or
458 extract_stack(), return a list of strings ready for printing.
464 extract_stack(), return a list of strings ready for printing.
459 Each string in the resulting list corresponds to the item with the
465 Each string in the resulting list corresponds to the item with the
460 same index in the argument list. Each string ends in a newline;
466 same index in the argument list. Each string ends in a newline;
461 the strings may contain internal newlines as well, for those items
467 the strings may contain internal newlines as well, for those items
462 whose source text line is not None.
468 whose source text line is not None.
463
469
464 Lifted almost verbatim from traceback.py
470 Lifted almost verbatim from traceback.py
465 """
471 """
466
472
467 Colors = self.Colors
473 Colors = self.Colors
468 list = []
474 list = []
469 for ind, (filename, lineno, name, line) in enumerate(extracted_list):
475 for ind, (filename, lineno, name, line) in enumerate(extracted_list):
470 normalCol, nameCol, fileCol, lineCol = (
476 normalCol, nameCol, fileCol, lineCol = (
471 # Emphasize the last entry
477 # Emphasize the last entry
472 (Colors.normalEm, Colors.nameEm, Colors.filenameEm, Colors.line)
478 (Colors.normalEm, Colors.nameEm, Colors.filenameEm, Colors.line)
473 if ind == len(extracted_list) - 1
479 if ind == len(extracted_list) - 1
474 else (Colors.Normal, Colors.name, Colors.filename, "")
480 else (Colors.Normal, Colors.name, Colors.filename, "")
475 )
481 )
476
482
477 fns = _format_filename(filename, fileCol, normalCol, lineno=lineno)
483 fns = _format_filename(filename, fileCol, normalCol, lineno=lineno)
478 item = f"{normalCol} {fns}"
484 item = f"{normalCol} {fns}"
479
485
480 if name != "<module>":
486 if name != "<module>":
481 item += f" in {nameCol}{name}{normalCol}\n"
487 item += f" in {nameCol}{name}{normalCol}\n"
482 else:
488 else:
483 item += "\n"
489 item += "\n"
484 if line:
490 if line:
485 item += f"{lineCol} {line.strip()}{normalCol}\n"
491 item += f"{lineCol} {line.strip()}{normalCol}\n"
486 list.append(item)
492 list.append(item)
487
493
488 return list
494 return list
489
495
490 def _format_exception_only(self, etype, value):
496 def _format_exception_only(self, etype, value):
491 """Format the exception part of a traceback.
497 """Format the exception part of a traceback.
492
498
493 The arguments are the exception type and value such as given by
499 The arguments are the exception type and value such as given by
494 sys.exc_info()[:2]. The return value is a list of strings, each ending
500 sys.exc_info()[:2]. The return value is a list of strings, each ending
495 in a newline. Normally, the list contains a single string; however,
501 in a newline. Normally, the list contains a single string; however,
496 for SyntaxError exceptions, it contains several lines that (when
502 for SyntaxError exceptions, it contains several lines that (when
497 printed) display detailed information about where the syntax error
503 printed) display detailed information about where the syntax error
498 occurred. The message indicating which exception occurred is the
504 occurred. The message indicating which exception occurred is the
499 always last string in the list.
505 always last string in the list.
500
506
501 Also lifted nearly verbatim from traceback.py
507 Also lifted nearly verbatim from traceback.py
502 """
508 """
503 have_filedata = False
509 have_filedata = False
504 Colors = self.Colors
510 Colors = self.Colors
505 list = []
511 list = []
506 stype = py3compat.cast_unicode(Colors.excName + etype.__name__ + Colors.Normal)
512 stype = py3compat.cast_unicode(Colors.excName + etype.__name__ + Colors.Normal)
507 if value is None:
513 if value is None:
508 # Not sure if this can still happen in Python 2.6 and above
514 # Not sure if this can still happen in Python 2.6 and above
509 list.append(stype + '\n')
515 list.append(stype + '\n')
510 else:
516 else:
511 if issubclass(etype, SyntaxError):
517 if issubclass(etype, SyntaxError):
512 have_filedata = True
518 have_filedata = True
513 if not value.filename: value.filename = "<string>"
519 if not value.filename: value.filename = "<string>"
514 if value.lineno:
520 if value.lineno:
515 lineno = value.lineno
521 lineno = value.lineno
516 textline = linecache.getline(value.filename, value.lineno)
522 textline = linecache.getline(value.filename, value.lineno)
517 else:
523 else:
518 lineno = "unknown"
524 lineno = "unknown"
519 textline = ""
525 textline = ""
520 list.append(
526 list.append(
521 "%s %s%s\n"
527 "%s %s%s\n"
522 % (
528 % (
523 Colors.normalEm,
529 Colors.normalEm,
524 _format_filename(
530 _format_filename(
525 value.filename,
531 value.filename,
526 Colors.filenameEm,
532 Colors.filenameEm,
527 Colors.normalEm,
533 Colors.normalEm,
528 lineno=(None if lineno == "unknown" else lineno),
534 lineno=(None if lineno == "unknown" else lineno),
529 ),
535 ),
530 Colors.Normal,
536 Colors.Normal,
531 )
537 )
532 )
538 )
533 if textline == "":
539 if textline == "":
534 textline = py3compat.cast_unicode(value.text, "utf-8")
540 textline = py3compat.cast_unicode(value.text, "utf-8")
535
541
536 if textline is not None:
542 if textline is not None:
537 i = 0
543 i = 0
538 while i < len(textline) and textline[i].isspace():
544 while i < len(textline) and textline[i].isspace():
539 i += 1
545 i += 1
540 list.append('%s %s%s\n' % (Colors.line,
546 list.append('%s %s%s\n' % (Colors.line,
541 textline.strip(),
547 textline.strip(),
542 Colors.Normal))
548 Colors.Normal))
543 if value.offset is not None:
549 if value.offset is not None:
544 s = ' '
550 s = ' '
545 for c in textline[i:value.offset - 1]:
551 for c in textline[i:value.offset - 1]:
546 if c.isspace():
552 if c.isspace():
547 s += c
553 s += c
548 else:
554 else:
549 s += ' '
555 s += ' '
550 list.append('%s%s^%s\n' % (Colors.caret, s,
556 list.append('%s%s^%s\n' % (Colors.caret, s,
551 Colors.Normal))
557 Colors.Normal))
552
558
553 try:
559 try:
554 s = value.msg
560 s = value.msg
555 except Exception:
561 except Exception:
556 s = self._some_str(value)
562 s = self._some_str(value)
557 if s:
563 if s:
558 list.append('%s%s:%s %s\n' % (stype, Colors.excName,
564 list.append('%s%s:%s %s\n' % (stype, Colors.excName,
559 Colors.Normal, s))
565 Colors.Normal, s))
560 else:
566 else:
561 list.append('%s\n' % stype)
567 list.append('%s\n' % stype)
562
568
563 # sync with user hooks
569 # sync with user hooks
564 if have_filedata:
570 if have_filedata:
565 ipinst = get_ipython()
571 ipinst = get_ipython()
566 if ipinst is not None:
572 if ipinst is not None:
567 ipinst.hooks.synchronize_with_editor(value.filename, value.lineno, 0)
573 ipinst.hooks.synchronize_with_editor(value.filename, value.lineno, 0)
568
574
569 return list
575 return list
570
576
571 def get_exception_only(self, etype, value):
577 def get_exception_only(self, etype, value):
572 """Only print the exception type and message, without a traceback.
578 """Only print the exception type and message, without a traceback.
573
579
574 Parameters
580 Parameters
575 ----------
581 ----------
576 etype : exception type
582 etype : exception type
577 value : exception value
583 value : exception value
578 """
584 """
579 return ListTB.structured_traceback(self, etype, value)
585 return ListTB.structured_traceback(self, etype, value)
580
586
581 def show_exception_only(self, etype, evalue):
587 def show_exception_only(self, etype, evalue):
582 """Only print the exception type and message, without a traceback.
588 """Only print the exception type and message, without a traceback.
583
589
584 Parameters
590 Parameters
585 ----------
591 ----------
586 etype : exception type
592 etype : exception type
587 evalue : exception value
593 evalue : exception value
588 """
594 """
589 # This method needs to use __call__ from *this* class, not the one from
595 # This method needs to use __call__ from *this* class, not the one from
590 # a subclass whose signature or behavior may be different
596 # a subclass whose signature or behavior may be different
591 ostream = self.ostream
597 ostream = self.ostream
592 ostream.flush()
598 ostream.flush()
593 ostream.write('\n'.join(self.get_exception_only(etype, evalue)))
599 ostream.write('\n'.join(self.get_exception_only(etype, evalue)))
594 ostream.flush()
600 ostream.flush()
595
601
596 def _some_str(self, value):
602 def _some_str(self, value):
597 # Lifted from traceback.py
603 # Lifted from traceback.py
598 try:
604 try:
599 return py3compat.cast_unicode(str(value))
605 return py3compat.cast_unicode(str(value))
600 except:
606 except:
601 return u'<unprintable %s object>' % type(value).__name__
607 return u'<unprintable %s object>' % type(value).__name__
602
608
603
609
604 #----------------------------------------------------------------------------
610 #----------------------------------------------------------------------------
605 class VerboseTB(TBTools):
611 class VerboseTB(TBTools):
606 """A port of Ka-Ping Yee's cgitb.py module that outputs color text instead
612 """A port of Ka-Ping Yee's cgitb.py module that outputs color text instead
607 of HTML. Requires inspect and pydoc. Crazy, man.
613 of HTML. Requires inspect and pydoc. Crazy, man.
608
614
609 Modified version which optionally strips the topmost entries from the
615 Modified version which optionally strips the topmost entries from the
610 traceback, to be used with alternate interpreters (because their own code
616 traceback, to be used with alternate interpreters (because their own code
611 would appear in the traceback)."""
617 would appear in the traceback)."""
612
618
613 _tb_highlight = "bg:ansiyellow"
619 _tb_highlight = "bg:ansiyellow"
614
620
615 def __init__(
621 def __init__(
616 self,
622 self,
617 color_scheme: str = "Linux",
623 color_scheme: str = "Linux",
618 call_pdb: bool = False,
624 call_pdb: bool = False,
619 ostream=None,
625 ostream=None,
620 tb_offset: int = 0,
626 tb_offset: int = 0,
621 long_header: bool = False,
627 long_header: bool = False,
622 include_vars: bool = True,
628 include_vars: bool = True,
623 check_cache=None,
629 check_cache=None,
624 debugger_cls=None,
630 debugger_cls=None,
625 parent=None,
631 parent=None,
626 config=None,
632 config=None,
627 ):
633 ):
628 """Specify traceback offset, headers and color scheme.
634 """Specify traceback offset, headers and color scheme.
629
635
630 Define how many frames to drop from the tracebacks. Calling it with
636 Define how many frames to drop from the tracebacks. Calling it with
631 tb_offset=1 allows use of this handler in interpreters which will have
637 tb_offset=1 allows use of this handler in interpreters which will have
632 their own code at the top of the traceback (VerboseTB will first
638 their own code at the top of the traceback (VerboseTB will first
633 remove that frame before printing the traceback info)."""
639 remove that frame before printing the traceback info)."""
634 TBTools.__init__(
640 TBTools.__init__(
635 self,
641 self,
636 color_scheme=color_scheme,
642 color_scheme=color_scheme,
637 call_pdb=call_pdb,
643 call_pdb=call_pdb,
638 ostream=ostream,
644 ostream=ostream,
639 parent=parent,
645 parent=parent,
640 config=config,
646 config=config,
641 debugger_cls=debugger_cls,
647 debugger_cls=debugger_cls,
642 )
648 )
643 self.tb_offset = tb_offset
649 self.tb_offset = tb_offset
644 self.long_header = long_header
650 self.long_header = long_header
645 self.include_vars = include_vars
651 self.include_vars = include_vars
646 # By default we use linecache.checkcache, but the user can provide a
652 # By default we use linecache.checkcache, but the user can provide a
647 # different check_cache implementation. This was formerly used by the
653 # different check_cache implementation. This was formerly used by the
648 # IPython kernel for interactive code, but is no longer necessary.
654 # IPython kernel for interactive code, but is no longer necessary.
649 if check_cache is None:
655 if check_cache is None:
650 check_cache = linecache.checkcache
656 check_cache = linecache.checkcache
651 self.check_cache = check_cache
657 self.check_cache = check_cache
652
658
653 self.skip_hidden = True
659 self.skip_hidden = True
654
660
655 def format_record(self, frame_info):
661 def format_record(self, frame_info):
656 """Format a single stack frame"""
662 """Format a single stack frame"""
657 Colors = self.Colors # just a shorthand + quicker name lookup
663 Colors = self.Colors # just a shorthand + quicker name lookup
658 ColorsNormal = Colors.Normal # used a lot
664 ColorsNormal = Colors.Normal # used a lot
659
665
660 if isinstance(frame_info, stack_data.RepeatedFrames):
666 if isinstance(frame_info, stack_data.RepeatedFrames):
661 return ' %s[... skipping similar frames: %s]%s\n' % (
667 return ' %s[... skipping similar frames: %s]%s\n' % (
662 Colors.excName, frame_info.description, ColorsNormal)
668 Colors.excName, frame_info.description, ColorsNormal)
663
669
664 indent = " " * INDENT_SIZE
670 indent = " " * INDENT_SIZE
665 em_normal = "%s\n%s%s" % (Colors.valEm, indent, ColorsNormal)
671 em_normal = "%s\n%s%s" % (Colors.valEm, indent, ColorsNormal)
666 tpl_call = f"in {Colors.vName}{{file}}{Colors.valEm}{{scope}}{ColorsNormal}"
672 tpl_call = f"in {Colors.vName}{{file}}{Colors.valEm}{{scope}}{ColorsNormal}"
667 tpl_call_fail = "in %s%%s%s(***failed resolving arguments***)%s" % (
673 tpl_call_fail = "in %s%%s%s(***failed resolving arguments***)%s" % (
668 Colors.vName,
674 Colors.vName,
669 Colors.valEm,
675 Colors.valEm,
670 ColorsNormal,
676 ColorsNormal,
671 )
677 )
672 tpl_name_val = "%%s %s= %%s%s" % (Colors.valEm, ColorsNormal)
678 tpl_name_val = "%%s %s= %%s%s" % (Colors.valEm, ColorsNormal)
673
679
674 link = _format_filename(
680 link = _format_filename(
675 frame_info.filename,
681 frame_info.filename,
676 Colors.filenameEm,
682 Colors.filenameEm,
677 ColorsNormal,
683 ColorsNormal,
678 lineno=frame_info.lineno,
684 lineno=frame_info.lineno,
679 )
685 )
680 args, varargs, varkw, locals_ = inspect.getargvalues(frame_info.frame)
686 args, varargs, varkw, locals_ = inspect.getargvalues(frame_info.frame)
681
687
682 func = frame_info.executing.code_qualname()
688 func = frame_info.executing.code_qualname()
683 if func == "<module>":
689 if func == "<module>":
684 call = ""
690 call = ""
685 else:
691 else:
686 # Decide whether to include variable details or not
692 # Decide whether to include variable details or not
687 var_repr = eqrepr if self.include_vars else nullrepr
693 var_repr = eqrepr if self.include_vars else nullrepr
688 try:
694 try:
689 scope = inspect.formatargvalues(
695 scope = inspect.formatargvalues(
690 args, varargs, varkw, locals_, formatvalue=var_repr
696 args, varargs, varkw, locals_, formatvalue=var_repr
691 )
697 )
692 call = tpl_call.format(file=func, scope=scope)
698 call = tpl_call.format(file=func, scope=scope)
693 except KeyError:
699 except KeyError:
694 # This happens in situations like errors inside generator
700 # This happens in situations like errors inside generator
695 # expressions, where local variables are listed in the
701 # expressions, where local variables are listed in the
696 # line, but can't be extracted from the frame. I'm not
702 # line, but can't be extracted from the frame. I'm not
697 # 100% sure this isn't actually a bug in inspect itself,
703 # 100% sure this isn't actually a bug in inspect itself,
698 # but since there's no info for us to compute with, the
704 # but since there's no info for us to compute with, the
699 # best we can do is report the failure and move on. Here
705 # best we can do is report the failure and move on. Here
700 # we must *not* call any traceback construction again,
706 # we must *not* call any traceback construction again,
701 # because that would mess up use of %debug later on. So we
707 # because that would mess up use of %debug later on. So we
702 # simply report the failure and move on. The only
708 # simply report the failure and move on. The only
703 # limitation will be that this frame won't have locals
709 # limitation will be that this frame won't have locals
704 # listed in the call signature. Quite subtle problem...
710 # listed in the call signature. Quite subtle problem...
705 # I can't think of a good way to validate this in a unit
711 # I can't think of a good way to validate this in a unit
706 # test, but running a script consisting of:
712 # test, but running a script consisting of:
707 # dict( (k,v.strip()) for (k,v) in range(10) )
713 # dict( (k,v.strip()) for (k,v) in range(10) )
708 # will illustrate the error, if this exception catch is
714 # will illustrate the error, if this exception catch is
709 # disabled.
715 # disabled.
710 call = tpl_call_fail % func
716 call = tpl_call_fail % func
711
717
712 lvals = ''
718 lvals = ''
713 lvals_list = []
719 lvals_list = []
714 if self.include_vars:
720 if self.include_vars:
715 try:
721 try:
716 # we likely want to fix stackdata at some point, but
722 # we likely want to fix stackdata at some point, but
717 # still need a workaround.
723 # still need a workaround.
718 fibp = frame_info.variables_in_executing_piece
724 fibp = frame_info.variables_in_executing_piece
719 for var in fibp:
725 for var in fibp:
720 lvals_list.append(tpl_name_val % (var.name, repr(var.value)))
726 lvals_list.append(tpl_name_val % (var.name, repr(var.value)))
721 except Exception:
727 except Exception:
722 lvals_list.append(
728 lvals_list.append(
723 "Exception trying to inspect frame. No more locals available."
729 "Exception trying to inspect frame. No more locals available."
724 )
730 )
725 if lvals_list:
731 if lvals_list:
726 lvals = '%s%s' % (indent, em_normal.join(lvals_list))
732 lvals = '%s%s' % (indent, em_normal.join(lvals_list))
727
733
728 result = f'{link}{", " if call else ""}{call}\n'
734 result = f'{link}{", " if call else ""}{call}\n'
729
735
730 result += ''.join(_format_traceback_lines(frame_info.lines, Colors, self.has_colors, lvals))
736 result += ''.join(_format_traceback_lines(frame_info.lines, Colors, self.has_colors, lvals))
731 return result
737 return result
732
738
733 def prepare_header(self, etype, long_version=False):
739 def prepare_header(self, etype, long_version=False):
734 colors = self.Colors # just a shorthand + quicker name lookup
740 colors = self.Colors # just a shorthand + quicker name lookup
735 colorsnormal = colors.Normal # used a lot
741 colorsnormal = colors.Normal # used a lot
736 exc = '%s%s%s' % (colors.excName, etype, colorsnormal)
742 exc = '%s%s%s' % (colors.excName, etype, colorsnormal)
737 width = min(75, get_terminal_size()[0])
743 width = min(75, get_terminal_size()[0])
738 if long_version:
744 if long_version:
739 # Header with the exception type, python version, and date
745 # Header with the exception type, python version, and date
740 pyver = 'Python ' + sys.version.split()[0] + ': ' + sys.executable
746 pyver = 'Python ' + sys.version.split()[0] + ': ' + sys.executable
741 date = time.ctime(time.time())
747 date = time.ctime(time.time())
742
748
743 head = '%s%s%s\n%s%s%s\n%s' % (colors.topline, '-' * width, colorsnormal,
749 head = '%s%s%s\n%s%s%s\n%s' % (colors.topline, '-' * width, colorsnormal,
744 exc, ' ' * (width - len(str(etype)) - len(pyver)),
750 exc, ' ' * (width - len(str(etype)) - len(pyver)),
745 pyver, date.rjust(width) )
751 pyver, date.rjust(width) )
746 head += "\nA problem occurred executing Python code. Here is the sequence of function" \
752 head += "\nA problem occurred executing Python code. Here is the sequence of function" \
747 "\ncalls leading up to the error, with the most recent (innermost) call last."
753 "\ncalls leading up to the error, with the most recent (innermost) call last."
748 else:
754 else:
749 # Simplified header
755 # Simplified header
750 head = '%s%s' % (exc, 'Traceback (most recent call last)'. \
756 head = '%s%s' % (exc, 'Traceback (most recent call last)'. \
751 rjust(width - len(str(etype))) )
757 rjust(width - len(str(etype))) )
752
758
753 return head
759 return head
754
760
755 def format_exception(self, etype, evalue):
761 def format_exception(self, etype, evalue):
756 colors = self.Colors # just a shorthand + quicker name lookup
762 colors = self.Colors # just a shorthand + quicker name lookup
757 colorsnormal = colors.Normal # used a lot
763 colorsnormal = colors.Normal # used a lot
758 # Get (safely) a string form of the exception info
764 # Get (safely) a string form of the exception info
759 try:
765 try:
760 etype_str, evalue_str = map(str, (etype, evalue))
766 etype_str, evalue_str = map(str, (etype, evalue))
761 except:
767 except:
762 # User exception is improperly defined.
768 # User exception is improperly defined.
763 etype, evalue = str, sys.exc_info()[:2]
769 etype, evalue = str, sys.exc_info()[:2]
764 etype_str, evalue_str = map(str, (etype, evalue))
770 etype_str, evalue_str = map(str, (etype, evalue))
765 # ... and format it
771 # ... and format it
766 return ['%s%s%s: %s' % (colors.excName, etype_str,
772 return ['%s%s%s: %s' % (colors.excName, etype_str,
767 colorsnormal, py3compat.cast_unicode(evalue_str))]
773 colorsnormal, py3compat.cast_unicode(evalue_str))]
768
774
769 def format_exception_as_a_whole(
775 def format_exception_as_a_whole(
770 self,
776 self,
771 etype: type,
777 etype: type,
772 evalue: BaseException,
778 evalue: BaseException,
773 etb: Optional[TracebackType],
779 etb: Optional[TracebackType],
774 number_of_lines_of_context,
780 number_of_lines_of_context,
775 tb_offset: Optional[int],
781 tb_offset: Optional[int],
776 ):
782 ):
777 """Formats the header, traceback and exception message for a single exception.
783 """Formats the header, traceback and exception message for a single exception.
778
784
779 This may be called multiple times by Python 3 exception chaining
785 This may be called multiple times by Python 3 exception chaining
780 (PEP 3134).
786 (PEP 3134).
781 """
787 """
782 # some locals
788 # some locals
783 orig_etype = etype
789 orig_etype = etype
784 try:
790 try:
785 etype = etype.__name__
791 etype = etype.__name__
786 except AttributeError:
792 except AttributeError:
787 pass
793 pass
788
794
789 tb_offset = self.tb_offset if tb_offset is None else tb_offset
795 tb_offset = self.tb_offset if tb_offset is None else tb_offset
790 assert isinstance(tb_offset, int)
796 assert isinstance(tb_offset, int)
791 head = self.prepare_header(etype, self.long_header)
797 head = self.prepare_header(etype, self.long_header)
792 records = (
798 records = (
793 self.get_records(etb, number_of_lines_of_context, tb_offset) if etb else []
799 self.get_records(etb, number_of_lines_of_context, tb_offset) if etb else []
794 )
800 )
795
801
796 frames = []
802 frames = []
797 skipped = 0
803 skipped = 0
798 lastrecord = len(records) - 1
804 lastrecord = len(records) - 1
799 for i, r in enumerate(records):
805 for i, r in enumerate(records):
800 if not isinstance(r, stack_data.RepeatedFrames) and self.skip_hidden:
806 if not isinstance(r, stack_data.RepeatedFrames) and self.skip_hidden:
801 if r.frame.f_locals.get("__tracebackhide__", 0) and i != lastrecord:
807 if r.frame.f_locals.get("__tracebackhide__", 0) and i != lastrecord:
802 skipped += 1
808 skipped += 1
803 continue
809 continue
804 if skipped:
810 if skipped:
805 Colors = self.Colors # just a shorthand + quicker name lookup
811 Colors = self.Colors # just a shorthand + quicker name lookup
806 ColorsNormal = Colors.Normal # used a lot
812 ColorsNormal = Colors.Normal # used a lot
807 frames.append(
813 frames.append(
808 " %s[... skipping hidden %s frame]%s\n"
814 " %s[... skipping hidden %s frame]%s\n"
809 % (Colors.excName, skipped, ColorsNormal)
815 % (Colors.excName, skipped, ColorsNormal)
810 )
816 )
811 skipped = 0
817 skipped = 0
812 frames.append(self.format_record(r))
818 frames.append(self.format_record(r))
813 if skipped:
819 if skipped:
814 Colors = self.Colors # just a shorthand + quicker name lookup
820 Colors = self.Colors # just a shorthand + quicker name lookup
815 ColorsNormal = Colors.Normal # used a lot
821 ColorsNormal = Colors.Normal # used a lot
816 frames.append(
822 frames.append(
817 " %s[... skipping hidden %s frame]%s\n"
823 " %s[... skipping hidden %s frame]%s\n"
818 % (Colors.excName, skipped, ColorsNormal)
824 % (Colors.excName, skipped, ColorsNormal)
819 )
825 )
820
826
821 formatted_exception = self.format_exception(etype, evalue)
827 formatted_exception = self.format_exception(etype, evalue)
822 if records:
828 if records:
823 frame_info = records[-1]
829 frame_info = records[-1]
824 ipinst = get_ipython()
830 ipinst = get_ipython()
825 if ipinst is not None:
831 if ipinst is not None:
826 ipinst.hooks.synchronize_with_editor(frame_info.filename, frame_info.lineno, 0)
832 ipinst.hooks.synchronize_with_editor(frame_info.filename, frame_info.lineno, 0)
827
833
828 return [[head] + frames + [''.join(formatted_exception[0])]]
834 return [[head] + frames + [''.join(formatted_exception[0])]]
829
835
830 def get_records(
836 def get_records(
831 self, etb: TracebackType, number_of_lines_of_context: int, tb_offset: int
837 self, etb: TracebackType, number_of_lines_of_context: int, tb_offset: int
832 ):
838 ):
833 assert etb is not None
839 assert etb is not None
834 context = number_of_lines_of_context - 1
840 context = number_of_lines_of_context - 1
835 after = context // 2
841 after = context // 2
836 before = context - after
842 before = context - after
837 if self.has_colors:
843 if self.has_colors:
838 style = get_style_by_name("default")
844 style = get_style_by_name("default")
839 style = stack_data.style_with_executing_node(style, self._tb_highlight)
845 style = stack_data.style_with_executing_node(style, self._tb_highlight)
840 formatter = Terminal256Formatter(style=style)
846 formatter = Terminal256Formatter(style=style)
841 else:
847 else:
842 formatter = None
848 formatter = None
843 options = stack_data.Options(
849 options = stack_data.Options(
844 before=before,
850 before=before,
845 after=after,
851 after=after,
846 pygments_formatter=formatter,
852 pygments_formatter=formatter,
847 )
853 )
848 return list(stack_data.FrameInfo.stack_data(etb, options=options))[tb_offset:]
854 return list(stack_data.FrameInfo.stack_data(etb, options=options))[tb_offset:]
849
855
850 def structured_traceback(
856 def structured_traceback(
851 self,
857 self,
852 etype: type,
858 etype: type,
853 evalue: Optional[BaseException],
859 evalue: Optional[BaseException],
854 etb: Optional[TracebackType],
860 etb: Optional[TracebackType],
855 tb_offset: Optional[int] = None,
861 tb_offset: Optional[int] = None,
856 number_of_lines_of_context: int = 5,
862 number_of_lines_of_context: int = 5,
857 ):
863 ):
858 """Return a nice text document describing the traceback."""
864 """Return a nice text document describing the traceback."""
859 formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,
865 formatted_exception = self.format_exception_as_a_whole(etype, evalue, etb, number_of_lines_of_context,
860 tb_offset)
866 tb_offset)
861
867
862 colors = self.Colors # just a shorthand + quicker name lookup
868 colors = self.Colors # just a shorthand + quicker name lookup
863 colorsnormal = colors.Normal # used a lot
869 colorsnormal = colors.Normal # used a lot
864 head = '%s%s%s' % (colors.topline, '-' * min(75, get_terminal_size()[0]), colorsnormal)
870 head = '%s%s%s' % (colors.topline, '-' * min(75, get_terminal_size()[0]), colorsnormal)
865 structured_traceback_parts = [head]
871 structured_traceback_parts = [head]
866 chained_exceptions_tb_offset = 0
872 chained_exceptions_tb_offset = 0
867 lines_of_context = 3
873 lines_of_context = 3
868 formatted_exceptions = formatted_exception
874 formatted_exceptions = formatted_exception
869 exception = self.get_parts_of_chained_exception(evalue)
875 exception = self.get_parts_of_chained_exception(evalue)
870 if exception:
876 if exception:
871 assert evalue is not None
877 assert evalue is not None
872 formatted_exceptions += self.prepare_chained_exception_message(evalue.__cause__)
878 formatted_exceptions += self.prepare_chained_exception_message(evalue.__cause__)
873 etype, evalue, etb = exception
879 etype, evalue, etb = exception
874 else:
880 else:
875 evalue = None
881 evalue = None
876 chained_exc_ids = set()
882 chained_exc_ids = set()
877 while evalue:
883 while evalue:
878 formatted_exceptions += self.format_exception_as_a_whole(etype, evalue, etb, lines_of_context,
884 formatted_exceptions += self.format_exception_as_a_whole(etype, evalue, etb, lines_of_context,
879 chained_exceptions_tb_offset)
885 chained_exceptions_tb_offset)
880 exception = self.get_parts_of_chained_exception(evalue)
886 exception = self.get_parts_of_chained_exception(evalue)
881
887
882 if exception and not id(exception[1]) in chained_exc_ids:
888 if exception and not id(exception[1]) in chained_exc_ids:
883 chained_exc_ids.add(id(exception[1])) # trace exception to avoid infinite 'cause' loop
889 chained_exc_ids.add(id(exception[1])) # trace exception to avoid infinite 'cause' loop
884 formatted_exceptions += self.prepare_chained_exception_message(evalue.__cause__)
890 formatted_exceptions += self.prepare_chained_exception_message(evalue.__cause__)
885 etype, evalue, etb = exception
891 etype, evalue, etb = exception
886 else:
892 else:
887 evalue = None
893 evalue = None
888
894
889 # we want to see exceptions in a reversed order:
895 # we want to see exceptions in a reversed order:
890 # the first exception should be on top
896 # the first exception should be on top
891 for formatted_exception in reversed(formatted_exceptions):
897 for formatted_exception in reversed(formatted_exceptions):
892 structured_traceback_parts += formatted_exception
898 structured_traceback_parts += formatted_exception
893
899
894 return structured_traceback_parts
900 return structured_traceback_parts
895
901
896 def debugger(self, force: bool = False):
902 def debugger(self, force: bool = False):
897 """Call up the pdb debugger if desired, always clean up the tb
903 """Call up the pdb debugger if desired, always clean up the tb
898 reference.
904 reference.
899
905
900 Keywords:
906 Keywords:
901
907
902 - force(False): by default, this routine checks the instance call_pdb
908 - force(False): by default, this routine checks the instance call_pdb
903 flag and does not actually invoke the debugger if the flag is false.
909 flag and does not actually invoke the debugger if the flag is false.
904 The 'force' option forces the debugger to activate even if the flag
910 The 'force' option forces the debugger to activate even if the flag
905 is false.
911 is false.
906
912
907 If the call_pdb flag is set, the pdb interactive debugger is
913 If the call_pdb flag is set, the pdb interactive debugger is
908 invoked. In all cases, the self.tb reference to the current traceback
914 invoked. In all cases, the self.tb reference to the current traceback
909 is deleted to prevent lingering references which hamper memory
915 is deleted to prevent lingering references which hamper memory
910 management.
916 management.
911
917
912 Note that each call to pdb() does an 'import readline', so if your app
918 Note that each call to pdb() does an 'import readline', so if your app
913 requires a special setup for the readline completers, you'll have to
919 requires a special setup for the readline completers, you'll have to
914 fix that by hand after invoking the exception handler."""
920 fix that by hand after invoking the exception handler."""
915
921
916 if force or self.call_pdb:
922 if force or self.call_pdb:
917 if self.pdb is None:
923 if self.pdb is None:
918 self.pdb = self.debugger_cls()
924 self.pdb = self.debugger_cls()
919 # the system displayhook may have changed, restore the original
925 # the system displayhook may have changed, restore the original
920 # for pdb
926 # for pdb
921 display_trap = DisplayTrap(hook=sys.__displayhook__)
927 display_trap = DisplayTrap(hook=sys.__displayhook__)
922 with display_trap:
928 with display_trap:
923 self.pdb.reset()
929 self.pdb.reset()
924 # Find the right frame so we don't pop up inside ipython itself
930 # Find the right frame so we don't pop up inside ipython itself
925 if hasattr(self, 'tb') and self.tb is not None:
931 if hasattr(self, 'tb') and self.tb is not None:
926 etb = self.tb
932 etb = self.tb
927 else:
933 else:
928 etb = self.tb = sys.last_traceback
934 etb = self.tb = sys.last_traceback
929 while self.tb is not None and self.tb.tb_next is not None:
935 while self.tb is not None and self.tb.tb_next is not None:
930 assert self.tb.tb_next is not None
936 assert self.tb.tb_next is not None
931 self.tb = self.tb.tb_next
937 self.tb = self.tb.tb_next
932 if etb and etb.tb_next:
938 if etb and etb.tb_next:
933 etb = etb.tb_next
939 etb = etb.tb_next
934 self.pdb.botframe = etb.tb_frame
940 self.pdb.botframe = etb.tb_frame
935 self.pdb.interaction(None, etb)
941 self.pdb.interaction(None, etb)
936
942
937 if hasattr(self, 'tb'):
943 if hasattr(self, 'tb'):
938 del self.tb
944 del self.tb
939
945
940 def handler(self, info=None):
946 def handler(self, info=None):
941 (etype, evalue, etb) = info or sys.exc_info()
947 (etype, evalue, etb) = info or sys.exc_info()
942 self.tb = etb
948 self.tb = etb
943 ostream = self.ostream
949 ostream = self.ostream
944 ostream.flush()
950 ostream.flush()
945 ostream.write(self.text(etype, evalue, etb))
951 ostream.write(self.text(etype, evalue, etb))
946 ostream.write('\n')
952 ostream.write('\n')
947 ostream.flush()
953 ostream.flush()
948
954
949 # Changed so an instance can just be called as VerboseTB_inst() and print
955 # Changed so an instance can just be called as VerboseTB_inst() and print
950 # out the right info on its own.
956 # out the right info on its own.
951 def __call__(self, etype=None, evalue=None, etb=None):
957 def __call__(self, etype=None, evalue=None, etb=None):
952 """This hook can replace sys.excepthook (for Python 2.1 or higher)."""
958 """This hook can replace sys.excepthook (for Python 2.1 or higher)."""
953 if etb is None:
959 if etb is None:
954 self.handler()
960 self.handler()
955 else:
961 else:
956 self.handler((etype, evalue, etb))
962 self.handler((etype, evalue, etb))
957 try:
963 try:
958 self.debugger()
964 self.debugger()
959 except KeyboardInterrupt:
965 except KeyboardInterrupt:
960 print("\nKeyboardInterrupt")
966 print("\nKeyboardInterrupt")
961
967
962
968
963 #----------------------------------------------------------------------------
969 #----------------------------------------------------------------------------
964 class FormattedTB(VerboseTB, ListTB):
970 class FormattedTB(VerboseTB, ListTB):
965 """Subclass ListTB but allow calling with a traceback.
971 """Subclass ListTB but allow calling with a traceback.
966
972
967 It can thus be used as a sys.excepthook for Python > 2.1.
973 It can thus be used as a sys.excepthook for Python > 2.1.
968
974
969 Also adds 'Context' and 'Verbose' modes, not available in ListTB.
975 Also adds 'Context' and 'Verbose' modes, not available in ListTB.
970
976
971 Allows a tb_offset to be specified. This is useful for situations where
977 Allows a tb_offset to be specified. This is useful for situations where
972 one needs to remove a number of topmost frames from the traceback (such as
978 one needs to remove a number of topmost frames from the traceback (such as
973 occurs with python programs that themselves execute other python code,
979 occurs with python programs that themselves execute other python code,
974 like Python shells). """
980 like Python shells). """
975
981
976 mode: str
982 mode: str
977
983
978 def __init__(self, mode='Plain', color_scheme='Linux', call_pdb=False,
984 def __init__(self, mode='Plain', color_scheme='Linux', call_pdb=False,
979 ostream=None,
985 ostream=None,
980 tb_offset=0, long_header=False, include_vars=False,
986 tb_offset=0, long_header=False, include_vars=False,
981 check_cache=None, debugger_cls=None,
987 check_cache=None, debugger_cls=None,
982 parent=None, config=None):
988 parent=None, config=None):
983
989
984 # NEVER change the order of this list. Put new modes at the end:
990 # NEVER change the order of this list. Put new modes at the end:
985 self.valid_modes = ['Plain', 'Context', 'Verbose', 'Minimal']
991 self.valid_modes = ['Plain', 'Context', 'Verbose', 'Minimal']
986 self.verbose_modes = self.valid_modes[1:3]
992 self.verbose_modes = self.valid_modes[1:3]
987
993
988 VerboseTB.__init__(self, color_scheme=color_scheme, call_pdb=call_pdb,
994 VerboseTB.__init__(self, color_scheme=color_scheme, call_pdb=call_pdb,
989 ostream=ostream, tb_offset=tb_offset,
995 ostream=ostream, tb_offset=tb_offset,
990 long_header=long_header, include_vars=include_vars,
996 long_header=long_header, include_vars=include_vars,
991 check_cache=check_cache, debugger_cls=debugger_cls,
997 check_cache=check_cache, debugger_cls=debugger_cls,
992 parent=parent, config=config)
998 parent=parent, config=config)
993
999
994 # Different types of tracebacks are joined with different separators to
1000 # Different types of tracebacks are joined with different separators to
995 # form a single string. They are taken from this dict
1001 # form a single string. They are taken from this dict
996 self._join_chars = dict(Plain='', Context='\n', Verbose='\n',
1002 self._join_chars = dict(Plain='', Context='\n', Verbose='\n',
997 Minimal='')
1003 Minimal='')
998 # set_mode also sets the tb_join_char attribute
1004 # set_mode also sets the tb_join_char attribute
999 self.set_mode(mode)
1005 self.set_mode(mode)
1000
1006
1001 def structured_traceback(self, etype, value, tb, tb_offset=None, number_of_lines_of_context=5):
1007 def structured_traceback(self, etype, value, tb, tb_offset=None, number_of_lines_of_context=5):
1002 tb_offset = self.tb_offset if tb_offset is None else tb_offset
1008 tb_offset = self.tb_offset if tb_offset is None else tb_offset
1003 mode = self.mode
1009 mode = self.mode
1004 if mode in self.verbose_modes:
1010 if mode in self.verbose_modes:
1005 # Verbose modes need a full traceback
1011 # Verbose modes need a full traceback
1006 return VerboseTB.structured_traceback(
1012 return VerboseTB.structured_traceback(
1007 self, etype, value, tb, tb_offset, number_of_lines_of_context
1013 self, etype, value, tb, tb_offset, number_of_lines_of_context
1008 )
1014 )
1009 elif mode == 'Minimal':
1015 elif mode == 'Minimal':
1010 return ListTB.get_exception_only(self, etype, value)
1016 return ListTB.get_exception_only(self, etype, value)
1011 else:
1017 else:
1012 # We must check the source cache because otherwise we can print
1018 # We must check the source cache because otherwise we can print
1013 # out-of-date source code.
1019 # out-of-date source code.
1014 self.check_cache()
1020 self.check_cache()
1015 # Now we can extract and format the exception
1021 # Now we can extract and format the exception
1016 return ListTB.structured_traceback(
1022 return ListTB.structured_traceback(
1017 self, etype, value, tb, tb_offset, number_of_lines_of_context
1023 self, etype, value, tb, tb_offset, number_of_lines_of_context
1018 )
1024 )
1019
1025
1020 def stb2text(self, stb):
1026 def stb2text(self, stb):
1021 """Convert a structured traceback (a list) to a string."""
1027 """Convert a structured traceback (a list) to a string."""
1022 return self.tb_join_char.join(stb)
1028 return self.tb_join_char.join(stb)
1023
1029
1024 def set_mode(self, mode: Optional[str] = None):
1030 def set_mode(self, mode: Optional[str] = None):
1025 """Switch to the desired mode.
1031 """Switch to the desired mode.
1026
1032
1027 If mode is not specified, cycles through the available modes."""
1033 If mode is not specified, cycles through the available modes."""
1028
1034
1029 if not mode:
1035 if not mode:
1030 new_idx = (self.valid_modes.index(self.mode) + 1 ) % \
1036 new_idx = (self.valid_modes.index(self.mode) + 1 ) % \
1031 len(self.valid_modes)
1037 len(self.valid_modes)
1032 self.mode = self.valid_modes[new_idx]
1038 self.mode = self.valid_modes[new_idx]
1033 elif mode not in self.valid_modes:
1039 elif mode not in self.valid_modes:
1034 raise ValueError(
1040 raise ValueError(
1035 "Unrecognized mode in FormattedTB: <" + mode + ">\n"
1041 "Unrecognized mode in FormattedTB: <" + mode + ">\n"
1036 "Valid modes: " + str(self.valid_modes)
1042 "Valid modes: " + str(self.valid_modes)
1037 )
1043 )
1038 else:
1044 else:
1039 assert isinstance(mode, str)
1045 assert isinstance(mode, str)
1040 self.mode = mode
1046 self.mode = mode
1041 # include variable details only in 'Verbose' mode
1047 # include variable details only in 'Verbose' mode
1042 self.include_vars = (self.mode == self.valid_modes[2])
1048 self.include_vars = (self.mode == self.valid_modes[2])
1043 # Set the join character for generating text tracebacks
1049 # Set the join character for generating text tracebacks
1044 self.tb_join_char = self._join_chars[self.mode]
1050 self.tb_join_char = self._join_chars[self.mode]
1045
1051
1046 # some convenient shortcuts
1052 # some convenient shortcuts
1047 def plain(self):
1053 def plain(self):
1048 self.set_mode(self.valid_modes[0])
1054 self.set_mode(self.valid_modes[0])
1049
1055
1050 def context(self):
1056 def context(self):
1051 self.set_mode(self.valid_modes[1])
1057 self.set_mode(self.valid_modes[1])
1052
1058
1053 def verbose(self):
1059 def verbose(self):
1054 self.set_mode(self.valid_modes[2])
1060 self.set_mode(self.valid_modes[2])
1055
1061
1056 def minimal(self):
1062 def minimal(self):
1057 self.set_mode(self.valid_modes[3])
1063 self.set_mode(self.valid_modes[3])
1058
1064
1059
1065
1060 #----------------------------------------------------------------------------
1066 #----------------------------------------------------------------------------
1061 class AutoFormattedTB(FormattedTB):
1067 class AutoFormattedTB(FormattedTB):
1062 """A traceback printer which can be called on the fly.
1068 """A traceback printer which can be called on the fly.
1063
1069
1064 It will find out about exceptions by itself.
1070 It will find out about exceptions by itself.
1065
1071
1066 A brief example::
1072 A brief example::
1067
1073
1068 AutoTB = AutoFormattedTB(mode = 'Verbose',color_scheme='Linux')
1074 AutoTB = AutoFormattedTB(mode = 'Verbose',color_scheme='Linux')
1069 try:
1075 try:
1070 ...
1076 ...
1071 except:
1077 except:
1072 AutoTB() # or AutoTB(out=logfile) where logfile is an open file object
1078 AutoTB() # or AutoTB(out=logfile) where logfile is an open file object
1073 """
1079 """
1074
1080
1075 def __call__(self, etype=None, evalue=None, etb=None,
1081 def __call__(self, etype=None, evalue=None, etb=None,
1076 out=None, tb_offset=None):
1082 out=None, tb_offset=None):
1077 """Print out a formatted exception traceback.
1083 """Print out a formatted exception traceback.
1078
1084
1079 Optional arguments:
1085 Optional arguments:
1080 - out: an open file-like object to direct output to.
1086 - out: an open file-like object to direct output to.
1081
1087
1082 - tb_offset: the number of frames to skip over in the stack, on a
1088 - tb_offset: the number of frames to skip over in the stack, on a
1083 per-call basis (this overrides temporarily the instance's tb_offset
1089 per-call basis (this overrides temporarily the instance's tb_offset
1084 given at initialization time."""
1090 given at initialization time."""
1085
1091
1086 if out is None:
1092 if out is None:
1087 out = self.ostream
1093 out = self.ostream
1088 out.flush()
1094 out.flush()
1089 out.write(self.text(etype, evalue, etb, tb_offset))
1095 out.write(self.text(etype, evalue, etb, tb_offset))
1090 out.write('\n')
1096 out.write('\n')
1091 out.flush()
1097 out.flush()
1092 # FIXME: we should remove the auto pdb behavior from here and leave
1098 # FIXME: we should remove the auto pdb behavior from here and leave
1093 # that to the clients.
1099 # that to the clients.
1094 try:
1100 try:
1095 self.debugger()
1101 self.debugger()
1096 except KeyboardInterrupt:
1102 except KeyboardInterrupt:
1097 print("\nKeyboardInterrupt")
1103 print("\nKeyboardInterrupt")
1098
1104
1099 def structured_traceback(self, etype=None, value=None, tb=None,
1105 def structured_traceback(self, etype=None, value=None, tb=None,
1100 tb_offset=None, number_of_lines_of_context=5):
1106 tb_offset=None, number_of_lines_of_context=5):
1101
1107
1102 etype: type
1108 etype: type
1103 value: BaseException
1109 value: BaseException
1104 # tb: TracebackType or tupleof tb types ?
1110 # tb: TracebackType or tupleof tb types ?
1105 if etype is None:
1111 if etype is None:
1106 etype, value, tb = sys.exc_info()
1112 etype, value, tb = sys.exc_info()
1107 if isinstance(tb, tuple):
1113 if isinstance(tb, tuple):
1108 # tb is a tuple if this is a chained exception.
1114 # tb is a tuple if this is a chained exception.
1109 self.tb = tb[0]
1115 self.tb = tb[0]
1110 else:
1116 else:
1111 self.tb = tb
1117 self.tb = tb
1112 return FormattedTB.structured_traceback(
1118 return FormattedTB.structured_traceback(
1113 self, etype, value, tb, tb_offset, number_of_lines_of_context)
1119 self, etype, value, tb, tb_offset, number_of_lines_of_context)
1114
1120
1115
1121
1116 #---------------------------------------------------------------------------
1122 #---------------------------------------------------------------------------
1117
1123
1118 # A simple class to preserve Nathan's original functionality.
1124 # A simple class to preserve Nathan's original functionality.
1119 class ColorTB(FormattedTB):
1125 class ColorTB(FormattedTB):
1120 """Shorthand to initialize a FormattedTB in Linux colors mode."""
1126 """Shorthand to initialize a FormattedTB in Linux colors mode."""
1121
1127
1122 def __init__(self, color_scheme='Linux', call_pdb=0, **kwargs):
1128 def __init__(self, color_scheme='Linux', call_pdb=0, **kwargs):
1123 FormattedTB.__init__(self, color_scheme=color_scheme,
1129 FormattedTB.__init__(self, color_scheme=color_scheme,
1124 call_pdb=call_pdb, **kwargs)
1130 call_pdb=call_pdb, **kwargs)
1125
1131
1126
1132
1127 class SyntaxTB(ListTB):
1133 class SyntaxTB(ListTB):
1128 """Extension which holds some state: the last exception value"""
1134 """Extension which holds some state: the last exception value"""
1129
1135
1130 def __init__(self, color_scheme='NoColor', parent=None, config=None):
1136 def __init__(self, color_scheme='NoColor', parent=None, config=None):
1131 ListTB.__init__(self, color_scheme, parent=parent, config=config)
1137 ListTB.__init__(self, color_scheme, parent=parent, config=config)
1132 self.last_syntax_error = None
1138 self.last_syntax_error = None
1133
1139
1134 def __call__(self, etype, value, elist):
1140 def __call__(self, etype, value, elist):
1135 self.last_syntax_error = value
1141 self.last_syntax_error = value
1136
1142
1137 ListTB.__call__(self, etype, value, elist)
1143 ListTB.__call__(self, etype, value, elist)
1138
1144
1139 def structured_traceback(self, etype, value, elist, tb_offset=None,
1145 def structured_traceback(self, etype, value, elist, tb_offset=None,
1140 context=5):
1146 context=5):
1141 # If the source file has been edited, the line in the syntax error can
1147 # If the source file has been edited, the line in the syntax error can
1142 # be wrong (retrieved from an outdated cache). This replaces it with
1148 # be wrong (retrieved from an outdated cache). This replaces it with
1143 # the current value.
1149 # the current value.
1144 if isinstance(value, SyntaxError) \
1150 if isinstance(value, SyntaxError) \
1145 and isinstance(value.filename, str) \
1151 and isinstance(value.filename, str) \
1146 and isinstance(value.lineno, int):
1152 and isinstance(value.lineno, int):
1147 linecache.checkcache(value.filename)
1153 linecache.checkcache(value.filename)
1148 newtext = linecache.getline(value.filename, value.lineno)
1154 newtext = linecache.getline(value.filename, value.lineno)
1149 if newtext:
1155 if newtext:
1150 value.text = newtext
1156 value.text = newtext
1151 self.last_syntax_error = value
1157 self.last_syntax_error = value
1152 return super(SyntaxTB, self).structured_traceback(etype, value, elist,
1158 return super(SyntaxTB, self).structured_traceback(etype, value, elist,
1153 tb_offset=tb_offset, context=context)
1159 tb_offset=tb_offset, context=context)
1154
1160
1155 def clear_err_state(self):
1161 def clear_err_state(self):
1156 """Return the current error state and clear it"""
1162 """Return the current error state and clear it"""
1157 e = self.last_syntax_error
1163 e = self.last_syntax_error
1158 self.last_syntax_error = None
1164 self.last_syntax_error = None
1159 return e
1165 return e
1160
1166
1161 def stb2text(self, stb):
1167 def stb2text(self, stb):
1162 """Convert a structured traceback (a list) to a string."""
1168 """Convert a structured traceback (a list) to a string."""
1163 return ''.join(stb)
1169 return ''.join(stb)
1164
1170
1165
1171
1166 # some internal-use functions
1172 # some internal-use functions
1167 def text_repr(value):
1173 def text_repr(value):
1168 """Hopefully pretty robust repr equivalent."""
1174 """Hopefully pretty robust repr equivalent."""
1169 # this is pretty horrible but should always return *something*
1175 # this is pretty horrible but should always return *something*
1170 try:
1176 try:
1171 return pydoc.text.repr(value)
1177 return pydoc.text.repr(value)
1172 except KeyboardInterrupt:
1178 except KeyboardInterrupt:
1173 raise
1179 raise
1174 except:
1180 except:
1175 try:
1181 try:
1176 return repr(value)
1182 return repr(value)
1177 except KeyboardInterrupt:
1183 except KeyboardInterrupt:
1178 raise
1184 raise
1179 except:
1185 except:
1180 try:
1186 try:
1181 # all still in an except block so we catch
1187 # all still in an except block so we catch
1182 # getattr raising
1188 # getattr raising
1183 name = getattr(value, '__name__', None)
1189 name = getattr(value, '__name__', None)
1184 if name:
1190 if name:
1185 # ick, recursion
1191 # ick, recursion
1186 return text_repr(name)
1192 return text_repr(name)
1187 klass = getattr(value, '__class__', None)
1193 klass = getattr(value, '__class__', None)
1188 if klass:
1194 if klass:
1189 return '%s instance' % text_repr(klass)
1195 return '%s instance' % text_repr(klass)
1190 except KeyboardInterrupt:
1196 except KeyboardInterrupt:
1191 raise
1197 raise
1192 except:
1198 except:
1193 return 'UNRECOVERABLE REPR FAILURE'
1199 return 'UNRECOVERABLE REPR FAILURE'
1194
1200
1195
1201
1196 def eqrepr(value, repr=text_repr):
1202 def eqrepr(value, repr=text_repr):
1197 return '=%s' % repr(value)
1203 return '=%s' % repr(value)
1198
1204
1199
1205
1200 def nullrepr(value, repr=text_repr):
1206 def nullrepr(value, repr=text_repr):
1201 return ''
1207 return ''
General Comments 0
You need to be logged in to leave comments. Login now