Project

General

Profile

1
# XML "function" nodes that transform their contents
2

    
3
import datetime
4
import re
5
import sre_constants
6

    
7
import dates
8
import exc
9
import maps
10
import strings
11
import term
12
import units
13
import util
14
import xml_dom
15
import xpath
16

    
17
##### Exceptions
18

    
19
class SyntaxException(Exception):
20
    def __init__(self, cause):
21
        Exception.__init__(self, 'Invalid XML function syntax: '
22
            +exc.str_(cause))
23

    
24
class FormatException(SyntaxException): pass
25

    
26
##### Functions
27

    
28
funcs = {}
29

    
30
def process(node, on_error=exc.raise_):
31
    for child in xml_dom.NodeElemIter(node): process(child, on_error)
32
    name = node.tagName
33
    if name.startswith('_') and name in funcs:
34
        try:
35
            value = funcs[name](xml_dom.NodeTextEntryIter(node))
36
            xml_dom.replace_with_text(node, value)
37
        except Exception, e: # also catch XML func internal errors
38
            # Save in case another exception raised, overwriting sys.exc_info()
39
            exc.add_traceback(e)
40
            str_ = str(node)
41
            exc.add_msg(e, 'function:\n'+str_)
42
            xml_dom.replace(node, node.ownerDocument.createComment(
43
                '\n'+term.emph_multiline(str_).replace('--','-')))
44
                # comments can't contain '--'
45
            on_error(e)
46

    
47
def map_items(func, items):
48
    return [(name, func(value)) for name, value in items]
49

    
50
def cast(type_, val):
51
    '''Throws SyntaxException if can't cast'''
52
    try: return type_(val)
53
    except ValueError, e: raise SyntaxException(e)
54

    
55
def conv_items(type_, items):
56
    return map_items(lambda val: cast(type_, val),
57
        xml_dom.TextEntryOnlyIter(items))
58

    
59
##### XML functions
60

    
61
# Function names must start with _ to avoid collisions with real tags
62
# Functions take arguments (items)
63

    
64
#### General
65

    
66
def _ignore(items):
67
    '''Used to "comment out" an XML subtree'''
68
    return None
69
funcs['_ignore'] = _ignore
70

    
71
#### Conditionals
72

    
73
def _eq(items):
74
    items = dict(items)
75
    try:
76
        left = items['left']
77
        right = items['right']
78
    except KeyError: return '' # a value was None
79
    return util.bool2str(left == right)
80
funcs['_eq'] = _eq
81

    
82
def _if(items):
83
    items = dict(items)
84
    try:
85
        cond = items['cond']
86
        then = items['then']
87
    except KeyError, e: raise SyntaxException(e)
88
    else_ = items.get('else', None)
89
    cond = bool(cast(str, cond))
90
    if cond: return then
91
    else: return else_
92
funcs['_if'] = _if
93

    
94
#### Combining values
95

    
96
def _alt(items):
97
    items = list(items)
98
    items.sort()
99
    try: return items[0][1] # value of lowest-numbered item
100
    except IndexError: return None # input got removed by e.g. SyntaxException
101
funcs['_alt'] = _alt
102

    
103
def _merge(items):
104
    items = list(conv_items(strings.ustr, items))
105
        # get *once* from iter and check types
106
    items.sort()
107
    return maps.merge_values(*[v for k, v in items])
108
funcs['_merge'] = _merge
109

    
110
def _label(items):
111
    items = dict(conv_items(strings.ustr, items))
112
        # get *once* from iter and check types
113
    try:
114
        label = items['label']
115
        value = items['value']
116
    except KeyError, e: raise SyntaxException(e)
117
    return label+': '+value
118
funcs['_label'] = _label
119

    
120
#### Transforming values
121

    
122
types_by_name = {None: strings.ustr, 'str': strings.ustr, 'float': float}
123

    
124
def _nullIf(items):
125
    items = dict(conv_items(str, items))
126
    try: null = items['null']
127
    except KeyError, e: raise SyntaxException(e)
128
    value = items.get('value', None)
129
    type_str = items.get('type', None)
130
    
131
    try: type_ = types_by_name[type_str]
132
    except KeyError, e: raise SyntaxException(e)
133
    null = type_(null)
134
    
135
    try: return util.none_if(value, null)
136
    except ValueError: return value # value not convertible, so can't equal null
137
funcs['_nullIf'] = _nullIf
138

    
139
def _map(items):
140
    items = conv_items(str, items) # get *once* from iter and check types
141
    try: value = items.pop()[1] # last entry contains value
142
    except IndexError, e: raise SyntaxException(e)
143
    map_ = dict(items)
144
    closed = bool(map_.pop('_closed', False))
145
    try: value = map_[value]
146
    except KeyError, e:
147
        if closed: raise SyntaxException(e)
148
        else: return value
149
    return util.none_if(value, u'') # empty map entry means None
150
funcs['_map'] = _map
151

    
152
def _replace(items):
153
    items = conv_items(str, items) # get *once* from iter and check types
154
    try: value = items.pop()[1] # last entry contains value
155
    except IndexError, e: raise SyntaxException(e)
156
    try:
157
        for repl, with_ in items:
158
            if re.match(r'^\w+$', repl):
159
                repl = r'(?<![^\W_])'+repl+r'(?![^\W_])' # match whole word
160
            value = re.sub(repl, with_, value)
161
    except sre_constants.error, e: raise SyntaxException(e)
162
    return util.none_if(value, u'') # empty strings always mean None
163
funcs['_replace'] = _replace
164

    
165
#### Quantities
166

    
167
def _units(items):
168
    items = conv_items(str, items) # get *once* from iter and check types
169
    try: last = items.pop() # last entry contains value
170
    except IndexError: return None # input is empty and no actions
171
    if last[0] != 'value': return None # input is empty
172
    str_ = last[1]
173
    
174
    quantity = units.str2quantity(str_)
175
    try:
176
        for action, units_ in items:
177
            units_ = util.none_if(units_, u'')
178
            if action == 'default': units.set_default_units(quantity, units_)
179
            elif action == 'to': quantity = units.convert(quantity, units_)
180
            else: raise SyntaxException(ValueError('Invalid action: '+action))
181
    except units.MissingUnitsException, e: raise SyntaxException(e)
182
    return units.quantity2str(quantity)
183
funcs['_units'] = _units
184

    
185
def parse_range(str_, range_sep='-'):
186
    default = (str_, None)
187
    start, sep, end = str_.partition(range_sep)
188
    if sep == '': return default # not a range
189
    if start == '' and range_sep == '-': return default # negative number
190
    return tuple(d.strip() for d in (start, end))
191

    
192
def _rangeStart(items):
193
    items = dict(conv_items(str, items))
194
    try: value = items['value']
195
    except KeyError: return None # input is empty
196
    return parse_range(value)[0]
197
funcs['_rangeStart'] = _rangeStart
198

    
199
def _rangeEnd(items):
200
    items = dict(conv_items(str, items))
201
    try: value = items['value']
202
    except KeyError: return None # input is empty
203
    return parse_range(value)[1]
204
funcs['_rangeEnd'] = _rangeEnd
205

    
206
def _range(items):
207
    items = dict(conv_items(float, items))
208
    from_ = items.get('from', None)
209
    to = items.get('to', None)
210
    if from_ == None or to == None: return None
211
    return str(to - from_)
212
funcs['_range'] = _range
213

    
214
def _avg(items):
215
    count = 0
216
    sum_ = 0.
217
    for name, value in conv_items(float, items):
218
        count += 1
219
        sum_ += value
220
    if count == 0: return None # input is empty
221
    else: return str(sum_/count)
222
funcs['_avg'] = _avg
223

    
224
class CvException(Exception):
225
    def __init__(self):
226
        Exception.__init__(self, 'CV (coefficient of variation) values are only'
227
            ' allowed for ratio scale data '
228
            '(see <http://en.wikipedia.org/wiki/Coefficient_of_variation>)')
229

    
230
def _noCV(items):
231
    try: name, value = items.next()
232
    except StopIteration: return None
233
    if re.match('^(?i)CV *\d+$', value): raise SyntaxException(CvException())
234
    return value
235
funcs['_noCV'] = _noCV
236

    
237
#### Dates
238

    
239
def _date(items):
240
    items = dict(conv_items(str, items)) # get *once* from iter and check types
241
    try: str_ = items['date']
242
    except KeyError:
243
        items = dict(conv_items(int, items.iteritems()))
244
        try: items['year'] # year is required
245
        except KeyError, e:
246
            if items == {}: return None # entire date is empty
247
            else: raise SyntaxException(e)
248
        items.setdefault('month', 1)
249
        items.setdefault('day', 1)
250
        try: date = datetime.date(**items)
251
        except ValueError, e: raise SyntaxException(e)
252
    else:
253
        try: year = float(str_)
254
        except ValueError:
255
            try: date = dates.strtotime(str_)
256
            except ImportError: return str_
257
            except ValueError, e: raise SyntaxException(e)
258
        else: date = (datetime.date(int(year), 1, 1) +
259
            datetime.timedelta(round((year % 1.)*365)))
260
    try: return dates.strftime('%Y-%m-%d', date)
261
    except ValueError, e: raise FormatException(e)
262
funcs['_date'] = _date
263

    
264
def _dateRangeStart(items):
265
    items = dict(conv_items(str, items))
266
    try: value = items['value']
267
    except KeyError: return None # input is empty
268
    return dates.parse_date_range(value)[0]
269
funcs['_dateRangeStart'] = _dateRangeStart
270

    
271
def _dateRangeEnd(items):
272
    items = dict(conv_items(str, items))
273
    try: value = items['value']
274
    except KeyError: return None # input is empty
275
    return dates.parse_date_range(value)[1]
276
funcs['_dateRangeEnd'] = _dateRangeEnd
277

    
278
#### Names
279

    
280
_name_parts_slices_items = [
281
    ('first', slice(None, 1)),
282
    ('middle', slice(1, -1)),
283
    ('last', slice(-1, None)),
284
]
285
name_parts_slices = dict(_name_parts_slices_items)
286
name_parts = [name for name, slice_ in _name_parts_slices_items]
287

    
288
def _name(items):
289
    items = dict(items)
290
    parts = []
291
    for part in name_parts:
292
        if part in items: parts.append(items[part])
293
    return ' '.join(parts)
294
funcs['_name'] = _name
295

    
296
def _namePart(items):
297
    out_items = []
298
    for part, value in items:
299
        try: slice_ = name_parts_slices[part]
300
        except KeyError, e: raise SyntaxException(e)
301
        out_items.append((part, ' '.join(value.split(' ')[slice_])))
302
    return _name(out_items)
303
funcs['_namePart'] = _namePart
304

    
305
#### Paths
306

    
307
def _simplifyPath(items):
308
    items = dict(items)
309
    try:
310
        next = cast(str, items['next'])
311
        require = cast(str, items['require'])
312
        root = items['path']
313
    except KeyError, e: raise SyntaxException(e)
314
    
315
    node = root
316
    while node != None:
317
        new_node = xpath.get_1(node, next, allow_rooted=False)
318
        if xpath.get_1(node, require, allow_rooted=False) == None: # empty elem
319
            xml_dom.replace(node, new_node) # remove current elem
320
            if node is root: root = new_node # also update root
321
        node = new_node
322
    return root
323
funcs['_simplifyPath'] = _simplifyPath
(17-17/19)