diff --git a/jc/cli.py b/jc/cli.py index e7b4a401..7a42fb47 100644 --- a/jc/cli.py +++ b/jc/cli.py @@ -16,7 +16,6 @@ from pygments.style import Style from pygments.token import (Name, Number, String, Keyword) from pygments.lexers import JsonLexer from pygments.formatters import Terminal256Formatter -import jc.utils import jc.appdirs as appdirs @@ -401,12 +400,13 @@ def main(): except Exception: if debug: if verbose_debug: - import cgitb - cgitb.enable(display=1, logdir=None, context=5, format="text") + import jc.tracebackplus + jc.tracebackplus.enable(context=11) raise else: + import jc.utils jc.utils.error_message( f'{parser_name} parser could not parse the input data. Did you use the correct parser?\n' ' For details use the -d or -dd option.') diff --git a/jc/tracebackplus.py b/jc/tracebackplus.py new file mode 100644 index 00000000..98f1ad3b --- /dev/null +++ b/jc/tracebackplus.py @@ -0,0 +1,186 @@ +"""More comprehensive traceback formatting for Python scripts. +To enable this module, do: + import tracebackplus; tracebackplus.enable() +at the top of your script. The optional arguments to enable() are: + logdir - if set, tracebacks are written to files in this directory + context - number of lines of source code to show for each stack frame +By default, tracebacks are displayed but not saved and the context is 5 lines. +Alternatively, if you have caught an exception and want tracebackplus to display it +for you, call tracebackplus.handler(). The optional argument to handler() is a +3-item tuple (etype, evalue, etb) just like the value of sys.exc_info(). +""" +import inspect +import keyword +import linecache +import os +import pydoc +import sys +import tempfile +import time +import tokenize +import traceback + + +__UNDEF__ = [] # a special sentinel object + + +def lookup(name, frame, locals): + """Find the value for a given name in the given environment.""" + if name in locals: + return 'local', locals[name] + if name in frame.f_globals: + return 'global', frame.f_globals[name] + if '__builtins__' in frame.f_globals: + builtins = frame.f_globals['__builtins__'] + if type(builtins) is type({}): + if name in builtins: + return 'builtin', builtins[name] + else: + if hasattr(builtins, name): + return 'builtin', getattr(builtins, name) + return None, __UNDEF__ + + +def scanvars(reader, frame, locals): + """Scan one logical line of Python and look up values of variables used.""" + vars, lasttoken, parent, prefix, value = [], None, None, '', __UNDEF__ + for ttype, token, start, end, line in tokenize.generate_tokens(reader): + if ttype == tokenize.NEWLINE: + break + if ttype == tokenize.NAME and token not in keyword.kwlist: + if lasttoken == '.': + if parent is not __UNDEF__: + value = getattr(parent, token, __UNDEF__) + vars.append((prefix + token, prefix, value)) + else: + where, value = lookup(token, frame, locals) + vars.append((token, where, value)) + elif token == '.': + prefix += lasttoken + '.' + parent = value + else: + parent, prefix = None, '' + lasttoken = token + return vars + + +def text(einfo, context=5): + """Return a plain text document describing a given traceback.""" + etype, evalue, etb = einfo + if isinstance(etype, type): + etype = etype.__name__ + pyver = 'Python ' + sys.version.split()[0] + ': ' + sys.executable + date = time.ctime(time.time()) + head = '%s\n%s\n%s\n' % (str(etype), pyver, date) + ''' +A problem occurred in a Python script. Here is the sequence of +function calls leading up to the error, in the order they occurred. +''' + + frames = [] + records = inspect.getinnerframes(etb, context) + for frame, file, lnum, func, lines, index in records: + file = file and os.path.abspath(file) or '?' + args, varargs, varkw, locals = inspect.getargvalues(frame) + call = '' + if func != '?': + call = 'in ' + func + \ + inspect.formatargvalues(args, varargs, varkw, locals, + formatvalue=lambda value: '=' + pydoc.text.repr(value)) + + highlight = {} + + def reader(lnum=[lnum]): + highlight[lnum[0]] = 1 + try: + return linecache.getline(file, lnum[0]) + finally: + lnum[0] += 1 + vars = scanvars(reader, frame, locals) + + rows = [' %s %s' % (file, call)] + if index is not None: + i = lnum - index + for line in lines: + num = '%5d ' % i + rows.append(num + line.rstrip()) + i += 1 + + done, dump = {}, [] + for name, where, value in vars: + if name in done: + continue + done[name] = 1 + if value is not __UNDEF__: + if where == 'global': + name = 'global ' + name + elif where != 'local': + name = where + name.split('.')[-1] + dump.append('%s = %s' % (name, pydoc.text.repr(value))) + else: + dump.append(name + ' undefined') + + rows.append('\n'.join(dump)) + frames.append('\n%s\n' % '\n'.join(rows)) + + exception = ['%s: %s' % (str(etype), str(evalue))] + for name in dir(evalue): + value = pydoc.text.repr(getattr(evalue, name)) + exception.append('\n%s%s = %s' % (' ' * 4, name, value)) + + return head + ''.join(frames) + ''.join(exception) + ''' + +The above is a description of an error in a Python program. Here is +the original traceback: + +%s +''' % ''.join(traceback.format_exception(etype, evalue, etb)) + + +class Hook: + """A hook to replace sys.excepthook""" + + def __init__(self, logdir=None, context=5, file=None): + self.logdir = logdir # log tracebacks to files if not None + self.context = context # number of source code lines per frame + self.file = file or sys.stdout # place to send the output + + def __call__(self, etype, evalue, etb): + self.handle((etype, evalue, etb)) + + def handle(self, info=None): + info = info or sys.exc_info() + + formatter = text + + try: + doc = formatter(info, self.context) + except: # just in case something goes wrong + doc = ''.join(traceback.format_exception(*info)) + + self.file.write(doc + '\n') + + if self.logdir is not None: + suffix = '.txt' + (fd, path) = tempfile.mkstemp(suffix=suffix, dir=self.logdir) + + try: + with os.fdopen(fd, 'w') as file: + file.write(doc) + msg = '%s contains the description of this error.' % path + except: + msg = 'Tried to save traceback to %s, but failed.' % path + + self.file.write(msg + '\n') + + try: + self.file.flush() + except: + pass + + +handler = Hook().handle + + +def enable(logdir=None, context=5): + """Install an exception handler that sends verbose tracebacks to STDOUT.""" + sys.excepthook = Hook(logdir=logdir, context=context)