Project

General

Profile

1
# Exception handling
2

    
3
import copy
4
import atexit
5
import sys
6
import traceback
7

    
8
import format
9
import strings
10
import term
11
import util
12

    
13
def raise_(e): raise e
14

    
15
def sys_traceback():
16
    '''Note that Python tracebacks seems to have a bug that truncates them to
17
    only a few stack frames. See <http://bugs.python.org/issue7378>.'''
18
    return sys.exc_info()[2]
19
        # can't just return pointer to traceback because it will change :-(
20

    
21
def has_tracebacks(e): return hasattr(e, 'tracebacks')
22

    
23
def add_traceback(e):
24
    '''Adds current traceback to an exception if it doesn't already have one'''
25
    traceback_ = sys_traceback() # get first in case later code throws exception
26
    if not has_tracebacks(e): e.tracebacks = []
27
    if util.list_get(e.tracebacks, 0) == traceback_: return
28
    e.tracebacks.insert(0, traceback_) # tracebacks have most recent call last
29

    
30
def get_traceback_str(traceback_):
31
    return ''.join(traceback.format_exception(None, None, traceback_)[:-1])
32
        # remove final "None" line ("exception name")
33

    
34
def get_e_tracebacks_str(e):
35
    try: tracebacks = e.tracebacks
36
    except AttributeError: return ''
37
    return ''.join(get_traceback_str(t) for t in tracebacks)
38

    
39
def add_msg(e, msg):
40
    e.args = (strings.ensure_newl(strings.ustr(e))+strings.ustr(msg),)
41

    
42
def repl_msg(e, **repls): e.args = (strings.ustr(e) % repls,)
43

    
44
def e_ct_exit_status(e_ct): return min(e_ct, 255)
45

    
46
class ExceptionWithCause(Exception):
47
    def __init__(self, msg, cause=None, cause_newline=False):
48
        add_traceback(self)
49
        
50
        if cause != None:
51
            if cause_newline: msg += '\ncause'
52
            msg += ': '+str_(cause)
53
        
54
        Exception.__init__(self, msg)
55
        
56
        self.cause = cause
57

    
58
def str_(e, first_line_only=False):
59
    if isinstance(e, SyntaxError):
60
        # format_exception_only() provides special formatting for SyntaxErrors.
61
        msg = u''.join(traceback.format_exception_only(type(e), e))
62
    else:
63
        # Avoid traceback exception-formatting functions because they escape
64
        # non-ASCII characters with \x, causing exception parsers to read an
65
        # incorrect, escaped value.
66
        msg = util.class_name(e)+': '+strings.ustr(e.args[0])
67
    
68
    if first_line_only: msg = msg.partition('\n')[0]
69
    return msg.rstrip()
70

    
71
def print_ex(e, emph=True, detail=True, plain=False):
72
    if plain:
73
        emph = False
74
        detail = False
75
    
76
    msg = str_(e)+'\n'
77
    if detail: msg += get_e_tracebacks_str(e)
78
    if emph:
79
        first_line, nl, rest = msg.partition('\n')
80
        msg = term.error(first_line)+nl+rest
81
    sys.stderr.write(strings.to_raw_str(msg))
82

    
83
class ExTracker:
84
    def __init__(self):
85
        self.e_ct = 0
86
    
87
    def msg(self): return 'Encountered '+str(self.e_ct)+' error(s)'
88
    
89
    def track(self, e, **format):
90
        self.e_ct += 1
91
        print_ex(e, **format)
92
    
93
    def exit(self):
94
        if self.e_ct > 0: raise SystemExit(e_ct_exit_status(self.e_ct))
95

    
96
class ExPercentTracker(ExTracker):
97
    def __init__(self, iter_text='iteration'):
98
        ExTracker.__init__(self)
99
        self.iter_text = iter_text
100
        self.iter_ct = None
101
        self.err_iter_ct = None
102
        self.last_iter_num = None
103
    
104
    def add_iters(self, iter_ct):
105
        if self.iter_ct == None: self.iter_ct = 0
106
        self.iter_ct += iter_ct
107
    
108
    def track(self, e, iter_num=None, **format):
109
        if iter_num != None:
110
            if iter_num != self.last_iter_num: # a new iter produced an error
111
                if self.err_iter_ct == None: self.err_iter_ct = 0
112
                self.err_iter_ct += 1
113
                self.last_iter_num = iter_num
114
        ExTracker.track(self, e, **format)
115
    
116
    def msg(self):
117
        msg = ExTracker.msg(self)
118
        iter_text_plural = self.iter_text+'(s)'
119
        numerator = self.e_ct
120
        if self.err_iter_ct != None:
121
            msg += ' in '+format.int2str(self.err_iter_ct)
122
            numerator = self.err_iter_ct
123
        if self.iter_ct != None and self.iter_ct > 0:
124
            msg += ('/'+format.int2str(self.iter_ct)+' '+iter_text_plural+' = '
125
            +format.to_percent(float(numerator)/self.iter_ct))
126
        return msg
(13-13/36)