source: pyyaml/trunk/lib/yaml/constructor.py @ 198

Revision 198, 23.3 KB checked in by xi, 8 years ago (diff)

To make porting easier, rewrite Parser not using generators.

Fix handling of unexpected block mapping values, like

: foo

Remove obsolete and unused __iter__ functions.

Line 
1
2__all__ = ['BaseConstructor', 'SafeConstructor', 'Constructor',
3    'ConstructorError']
4
5from error import *
6from nodes import *
7
8try:
9    import datetime
10    datetime_available = True
11except ImportError:
12    datetime_available = False
13
14try:
15    set
16except NameError:
17    from sets import Set as set
18
19import binascii, re, sys
20
21class ConstructorError(MarkedYAMLError):
22    pass
23
24class BaseConstructor:
25
26    yaml_constructors = {}
27    yaml_multi_constructors = {}
28
29    def __init__(self):
30        self.constructed_objects = {}
31        self.recursive_objects = {}
32
33    def check_data(self):
34        # If there are more documents available?
35        return self.check_node()
36
37    def get_data(self):
38        # Construct and return the next document.
39        if self.check_node():
40            return self.construct_document(self.get_node())
41
42    def construct_document(self, node):
43        data = self.construct_object(node)
44        self.constructed_objects = {}
45        self.recursive_objects = {}
46        return data
47
48    def construct_object(self, node):
49        if node in self.constructed_objects:
50            return self.constructed_objects[node]
51        if node in self.recursive_objects:
52            raise ConstructorError(None, None,
53                    "found recursive node", node.start_mark)
54        self.recursive_objects[node] = None
55        constructor = None
56        if node.tag in self.yaml_constructors:
57            constructor = lambda node: self.yaml_constructors[node.tag](self, node)
58        else:
59            for tag_prefix in self.yaml_multi_constructors:
60                if node.tag.startswith(tag_prefix):
61                    tag_suffix = node.tag[len(tag_prefix):]
62                    constructor = lambda node:  \
63                            self.yaml_multi_constructors[tag_prefix](self, tag_suffix, node)
64                    break
65            else:
66                if None in self.yaml_multi_constructors:
67                    constructor = lambda node:  \
68                            self.yaml_multi_constructors[None](self, node.tag, node)
69                elif None in self.yaml_constructors:
70                    constructor = lambda node:  \
71                            self.yaml_constructors[None](self, node)
72                elif isinstance(node, ScalarNode):
73                    constructor = self.construct_scalar
74                elif isinstance(node, SequenceNode):
75                    constructor = self.construct_sequence
76                elif isinstance(node, MappingNode):
77                    constructor = self.construct_mapping
78                else:
79                    print node.tag
80        data = constructor(node)
81        self.constructed_objects[node] = data
82        del self.recursive_objects[node]
83        return data
84
85    def construct_scalar(self, node):
86        if not isinstance(node, ScalarNode):
87            if isinstance(node, MappingNode):
88                for key_node in node.value:
89                    if key_node.tag == u'tag:yaml.org,2002:value':
90                        return self.construct_scalar(node.value[key_node])
91            raise ConstructorError(None, None,
92                    "expected a scalar node, but found %s" % node.id,
93                    node.start_mark)
94        return node.value
95
96    def construct_sequence(self, node):
97        if not isinstance(node, SequenceNode):
98            raise ConstructorError(None, None,
99                    "expected a sequence node, but found %s" % node.id,
100                    node.start_mark)
101        return [self.construct_object(child) for child in node.value]
102
103    def construct_mapping(self, node):
104        if not isinstance(node, MappingNode):
105            raise ConstructorError(None, None,
106                    "expected a mapping node, but found %s" % node.id,
107                    node.start_mark)
108        mapping = {}
109        merge = None
110        for key_node in node.value:
111            if key_node.tag == u'tag:yaml.org,2002:merge':
112                if merge is not None:
113                    raise ConstructorError("while constructing a mapping", node.start_mark,
114                            "found duplicate merge key", key_node.start_mark)
115                value_node = node.value[key_node]
116                if isinstance(value_node, MappingNode):
117                    merge = [self.construct_mapping(value_node)]
118                elif isinstance(value_node, SequenceNode):
119                    merge = []
120                    for subnode in value_node.value:
121                        if not isinstance(subnode, MappingNode):
122                            raise ConstructorError("while constructing a mapping",
123                                    node.start_mark,
124                                    "expected a mapping for merging, but found %s"
125                                    % subnode.id, subnode.start_mark)
126                        merge.append(self.construct_mapping(subnode))
127                    merge.reverse()
128                else:
129                    raise ConstructorError("while constructing a mapping", node.start_mark,
130                            "expected a mapping or list of mappings for merging, but found %s"
131                            % value_node.id, value_node.start_mark)
132            elif key_node.tag == u'tag:yaml.org,2002:value':
133                if '=' in mapping:
134                    raise ConstructorError("while construction a mapping", node.start_mark,
135                            "found duplicate value key", key_node.start_mark)
136                value = self.construct_object(node.value[key_node])
137                mapping['='] = value
138            else:
139                key = self.construct_object(key_node)
140                try:
141                    duplicate_key = key in mapping
142                except TypeError, exc:
143                    raise ConstructorError("while constructing a mapping", node.start_mark,
144                            "found unacceptable key (%s)" % exc, key_node.start_mark)
145                if duplicate_key:
146                    raise ConstructorError("while constructing a mapping", node.start_mark,
147                            "found duplicate key", key_node.start_mark)
148                value = self.construct_object(node.value[key_node])
149                mapping[key] = value
150        if merge is not None:
151            merge.append(mapping)
152            mapping = {}
153            for submapping in merge:
154                mapping.update(submapping)
155        return mapping
156
157    def construct_pairs(self, node):
158        if not isinstance(node, MappingNode):
159            raise ConstructorError(None, None,
160                    "expected a mapping node, but found %s" % node.id,
161                    node.start_mark)
162        pairs = []
163        for key_node in node.value:
164            key = self.construct_object(key_node)
165            value = self.construct_object(node.value[key_node])
166            pairs.append((key, value))
167        return pairs
168
169    def add_constructor(cls, tag, constructor):
170        if not 'yaml_constructors' in cls.__dict__:
171            cls.yaml_constructors = cls.yaml_constructors.copy()
172        cls.yaml_constructors[tag] = constructor
173    add_constructor = classmethod(add_constructor)
174
175    def add_multi_constructor(cls, tag_prefix, multi_constructor):
176        if not 'yaml_multi_constructors' in cls.__dict__:
177            cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy()
178        cls.yaml_multi_constructors[tag_prefix] = multi_constructor
179    add_multi_constructor = classmethod(add_multi_constructor)
180
181class SafeConstructor(BaseConstructor):
182
183    def construct_yaml_null(self, node):
184        self.construct_scalar(node)
185        return None
186
187    bool_values = {
188        u'yes':     True,
189        u'no':      False,
190        u'true':    True,
191        u'false':   False,
192        u'on':      True,
193        u'off':     False,
194    }
195
196    def construct_yaml_bool(self, node):
197        value = self.construct_scalar(node)
198        return self.bool_values[value.lower()]
199
200    def construct_yaml_int(self, node):
201        value = str(self.construct_scalar(node))
202        value = value.replace('_', '')
203        sign = +1
204        if value[0] == '-':
205            sign = -1
206        if value[0] in '+-':
207            value = value[1:]
208        if value == '0':
209            return 0
210        elif value.startswith('0b'):
211            return sign*int(value[2:], 2)
212        elif value.startswith('0x'):
213            return sign*int(value[2:], 16)
214        elif value[0] == '0':
215            return sign*int(value, 8)
216        elif ':' in value:
217            digits = [int(part) for part in value.split(':')]
218            digits.reverse()
219            base = 1
220            value = 0
221            for digit in digits:
222                value += digit*base
223                base *= 60
224            return sign*value
225        else:
226            return sign*int(value)
227
228    inf_value = 1e300
229    while inf_value != inf_value*inf_value:
230        inf_value *= inf_value
231    nan_value = -inf_value/inf_value   # Trying to make a quiet NaN (like C99).
232
233    def construct_yaml_float(self, node):
234        value = str(self.construct_scalar(node))
235        value = value.replace('_', '').lower()
236        sign = +1
237        if value[0] == '-':
238            sign = -1
239        if value[0] in '+-':
240            value = value[1:]
241        if value == '.inf':
242            return sign*self.inf_value
243        elif value == '.nan':
244            return self.nan_value
245        elif ':' in value:
246            digits = [float(part) for part in value.split(':')]
247            digits.reverse()
248            base = 1
249            value = 0.0
250            for digit in digits:
251                value += digit*base
252                base *= 60
253            return sign*value
254        else:
255            return sign*float(value)
256
257    def construct_yaml_binary(self, node):
258        value = self.construct_scalar(node)
259        try:
260            return str(value).decode('base64')
261        except (binascii.Error, UnicodeEncodeError), exc:
262            raise ConstructorError(None, None,
263                    "failed to decode base64 data: %s" % exc, node.start_mark) 
264
265    timestamp_regexp = re.compile(
266            ur'''^(?P<year>[0-9][0-9][0-9][0-9])
267                -(?P<month>[0-9][0-9]?)
268                -(?P<day>[0-9][0-9]?)
269                (?:(?:[Tt]|[ \t]+)
270                (?P<hour>[0-9][0-9]?)
271                :(?P<minute>[0-9][0-9])
272                :(?P<second>[0-9][0-9])
273                (?:\.(?P<fraction>[0-9]*))?
274                (?:[ \t]*(?:Z|(?P<tz_hour>[-+][0-9][0-9]?)
275                (?::(?P<tz_minute>[0-9][0-9])?)?))?)?$''', re.X)
276
277    def construct_yaml_timestamp(self, node):
278        value = self.construct_scalar(node)
279        match = self.timestamp_regexp.match(node.value)
280        values = match.groupdict()
281        for key in values:
282            if values[key]:
283                values[key] = int(values[key])
284            else:
285                values[key] = 0
286        fraction = values['fraction']
287        if fraction:
288            while 10*fraction < 1000000:
289                fraction *= 10
290            values['fraction'] = fraction
291        stamp = datetime.datetime(values['year'], values['month'], values['day'],
292                values['hour'], values['minute'], values['second'], values['fraction'])
293        diff = datetime.timedelta(hours=values['tz_hour'], minutes=values['tz_minute'])
294        return stamp-diff
295
296    def construct_yaml_omap(self, node):
297        # Note: we do not check for duplicate keys, because it's too
298        # CPU-expensive.
299        if not isinstance(node, SequenceNode):
300            raise ConstructorError("while constructing an ordered map", node.start_mark,
301                    "expected a sequence, but found %s" % node.id, node.start_mark)
302        omap = []
303        for subnode in node.value:
304            if not isinstance(subnode, MappingNode):
305                raise ConstructorError("while constructing an ordered map", node.start_mark,
306                        "expected a mapping of length 1, but found %s" % subnode.id,
307                        subnode.start_mark)
308            if len(subnode.value) != 1:
309                raise ConstructorError("while constructing an ordered map", node.start_mark,
310                        "expected a single mapping item, but found %d items" % len(subnode.value),
311                        subnode.start_mark)
312            key_node = subnode.value.keys()[0]
313            key = self.construct_object(key_node)
314            value = self.construct_object(subnode.value[key_node])
315            omap.append((key, value))
316        return omap
317
318    def construct_yaml_pairs(self, node):
319        # Note: the same code as `construct_yaml_omap`.
320        if not isinstance(node, SequenceNode):
321            raise ConstructorError("while constructing pairs", node.start_mark,
322                    "expected a sequence, but found %s" % node.id, node.start_mark)
323        pairs = []
324        for subnode in node.value:
325            if not isinstance(subnode, MappingNode):
326                raise ConstructorError("while constructing pairs", node.start_mark,
327                        "expected a mapping of length 1, but found %s" % subnode.id,
328                        subnode.start_mark)
329            if len(subnode.value) != 1:
330                raise ConstructorError("while constructing pairs", node.start_mark,
331                        "expected a single mapping item, but found %d items" % len(subnode.value),
332                        subnode.start_mark)
333            key_node = subnode.value.keys()[0]
334            key = self.construct_object(key_node)
335            value = self.construct_object(subnode.value[key_node])
336            pairs.append((key, value))
337        return pairs
338
339    def construct_yaml_set(self, node):
340        value = self.construct_mapping(node)
341        return set(value)
342
343    def construct_yaml_str(self, node):
344        value = self.construct_scalar(node)
345        try:
346            return str(value)
347        except UnicodeEncodeError:
348            return value
349
350    def construct_yaml_seq(self, node):
351        return self.construct_sequence(node)
352
353    def construct_yaml_map(self, node):
354        return self.construct_mapping(node)
355
356    def construct_yaml_object(self, node, cls):
357        state = self.construct_mapping(node)
358        data = cls.__new__(cls)
359        if hasattr(data, '__setstate__'):
360            data.__setstate__(state)
361        else:
362            data.__dict__.update(state)
363        return data
364
365    def construct_undefined(self, node):
366        raise ConstructorError(None, None,
367                "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'),
368                node.start_mark)
369
370SafeConstructor.add_constructor(
371        u'tag:yaml.org,2002:null',
372        SafeConstructor.construct_yaml_null)
373
374SafeConstructor.add_constructor(
375        u'tag:yaml.org,2002:bool',
376        SafeConstructor.construct_yaml_bool)
377
378SafeConstructor.add_constructor(
379        u'tag:yaml.org,2002:int',
380        SafeConstructor.construct_yaml_int)
381
382SafeConstructor.add_constructor(
383        u'tag:yaml.org,2002:float',
384        SafeConstructor.construct_yaml_float)
385
386SafeConstructor.add_constructor(
387        u'tag:yaml.org,2002:binary',
388        SafeConstructor.construct_yaml_binary)
389
390if datetime_available:
391    SafeConstructor.add_constructor(
392            u'tag:yaml.org,2002:timestamp',
393            SafeConstructor.construct_yaml_timestamp)
394
395SafeConstructor.add_constructor(
396        u'tag:yaml.org,2002:omap',
397        SafeConstructor.construct_yaml_omap)
398
399SafeConstructor.add_constructor(
400        u'tag:yaml.org,2002:pairs',
401        SafeConstructor.construct_yaml_pairs)
402
403SafeConstructor.add_constructor(
404        u'tag:yaml.org,2002:set',
405        SafeConstructor.construct_yaml_set)
406
407SafeConstructor.add_constructor(
408        u'tag:yaml.org,2002:str',
409        SafeConstructor.construct_yaml_str)
410
411SafeConstructor.add_constructor(
412        u'tag:yaml.org,2002:seq',
413        SafeConstructor.construct_yaml_seq)
414
415SafeConstructor.add_constructor(
416        u'tag:yaml.org,2002:map',
417        SafeConstructor.construct_yaml_map)
418
419SafeConstructor.add_constructor(None,
420        SafeConstructor.construct_undefined)
421
422class Constructor(SafeConstructor):
423
424    def construct_python_str(self, node):
425        return self.construct_scalar(node).encode('utf-8')
426
427    def construct_python_unicode(self, node):
428        return self.construct_scalar(node)
429
430    def construct_python_long(self, node):
431        return long(self.construct_yaml_int(node))
432
433    def construct_python_complex(self, node):
434       return complex(self.construct_scalar(node))
435
436    def construct_python_tuple(self, node):
437        return tuple(self.construct_yaml_seq(node))
438
439    def find_python_module(self, name, mark):
440        if not name:
441            raise ConstructorError("while constructing a Python module", mark,
442                    "expected non-empty name appended to the tag", mark)
443        try:
444            __import__(name)
445        except ImportError, exc:
446            raise ConstructorError("while constructing a Python module", mark,
447                    "cannot find module %r (%s)" % (name.encode('utf-8'), exc), mark)
448        return sys.modules[name]
449
450    def find_python_name(self, name, mark):
451        if not name:
452            raise ConstructorError("while constructing a Python object", mark,
453                    "expected non-empty name appended to the tag", mark)
454        if u'.' in name:
455            # Python 2.4 only
456            #module_name, object_name = name.rsplit('.', 1)
457            items = name.split('.')
458            object_name = items.pop()
459            module_name = '.'.join(items)
460        else:
461            module_name = '__builtin__'
462            object_name = name
463        try:
464            __import__(module_name)
465        except ImportError, exc:
466            raise ConstructorError("while constructing a Python object", mark,
467                    "cannot find module %r (%s)" % (module_name.encode('utf-8'), exc), mark)
468        module = sys.modules[module_name]
469        if not hasattr(module, object_name):
470            raise ConstructorError("while constructing a Python object", mark,
471                    "cannot find %r in the module %r" % (object_name.encode('utf-8'),
472                        module.__name__), mark)
473        return getattr(module, object_name)
474
475    def construct_python_name(self, suffix, node):
476        value = self.construct_scalar(node)
477        if value:
478            raise ConstructorError("while constructing a Python name", node.start_mark,
479                    "expected the empty value, but found %r" % value.encode('utf-8'),
480                    node.start_mark)
481        return self.find_python_name(suffix, node.start_mark)
482
483    def construct_python_module(self, suffix, node):
484        value = self.construct_scalar(node)
485        if value:
486            raise ConstructorError("while constructing a Python module", node.start_mark,
487                    "expected the empty value, but found %r" % value.encode('utf-8'),
488                    node.start_mark)
489        return self.find_python_module(suffix, node.start_mark)
490
491    class classobj: pass
492
493    def make_python_instance(self, suffix, node,
494            args=None, kwds=None, newobj=False):
495        if not args:
496            args = []
497        if not kwds:
498            kwds = {}
499        cls = self.find_python_name(suffix, node.start_mark)
500        if newobj and isinstance(cls, type(self.classobj))  \
501                and not args and not kwds:
502            instance = self.classobj()
503            instance.__class__ = cls
504            return instance
505        elif newobj and isinstance(cls, type):
506            return cls.__new__(cls, *args, **kwds)
507        else:
508            return cls(*args, **kwds)
509
510    def set_python_instance_state(self, instance, state):
511        if hasattr(instance, '__setstate__'):
512            instance.__setstate__(state)
513        else:
514            slotstate = {}
515            if isinstance(state, tuple) and len(state) == 2:
516                state, slotstate = state
517            if hasattr(instance, '__dict__'):
518                instance.__dict__.update(state)
519            elif state:
520                slotstate.update(state)
521            for key, value in slotstate.items():
522                setattr(object, key, value)
523
524    def construct_python_object(self, suffix, node):
525        # Format:
526        #   !!python/object:module.name { ... state ... }
527        instance = self.make_python_instance(suffix, node, newobj=True)
528        state = self.construct_mapping(node)
529        self.set_python_instance_state(instance, state)
530        return instance
531
532    def construct_python_object_apply(self, suffix, node, newobj=False):
533        # Format:
534        #   !!python/object/apply       # (or !!python/object/new)
535        #   args: [ ... arguments ... ]
536        #   kwds: { ... keywords ... }
537        #   state: ... state ...
538        #   listitems: [ ... listitems ... ]
539        #   dictitems: { ... dictitems ... }
540        # or short format:
541        #   !!python/object/apply [ ... arguments ... ]
542        # The difference between !!python/object/apply and !!python/object/new
543        # is how an object is created, check make_python_instance for details.
544        if isinstance(node, SequenceNode):
545            args = self.construct_sequence(node)
546            kwds = {}
547            state = {}
548            listitems = []
549            dictitems = {}
550        else:
551            value = self.construct_mapping(node)
552            args = value.get('args', [])
553            kwds = value.get('kwds', {})
554            state = value.get('state', {})
555            listitems = value.get('listitems', [])
556            dictitems = value.get('dictitems', {})
557        instance = self.make_python_instance(suffix, node, args, kwds, newobj)
558        if state:
559            self.set_python_instance_state(instance, state)
560        if listitems:
561            instance.extend(listitems)
562        if dictitems:
563            for key in dictitems:
564                instance[key] = dictitems[key]
565        return instance
566
567    def construct_python_object_new(self, suffix, node):
568        return self.construct_python_object_apply(suffix, node, newobj=True)
569
570
571Constructor.add_constructor(
572    u'tag:yaml.org,2002:python/none',
573    Constructor.construct_yaml_null)
574
575Constructor.add_constructor(
576    u'tag:yaml.org,2002:python/bool',
577    Constructor.construct_yaml_bool)
578
579Constructor.add_constructor(
580    u'tag:yaml.org,2002:python/str',
581    Constructor.construct_python_str)
582
583Constructor.add_constructor(
584    u'tag:yaml.org,2002:python/unicode',
585    Constructor.construct_python_unicode)
586
587Constructor.add_constructor(
588    u'tag:yaml.org,2002:python/int',
589    Constructor.construct_yaml_int)
590
591Constructor.add_constructor(
592    u'tag:yaml.org,2002:python/long',
593    Constructor.construct_python_long)
594
595Constructor.add_constructor(
596    u'tag:yaml.org,2002:python/float',
597    Constructor.construct_yaml_float)
598
599Constructor.add_constructor(
600    u'tag:yaml.org,2002:python/complex',
601    Constructor.construct_python_complex)
602
603Constructor.add_constructor(
604    u'tag:yaml.org,2002:python/list',
605    Constructor.construct_yaml_seq)
606
607Constructor.add_constructor(
608    u'tag:yaml.org,2002:python/tuple',
609    Constructor.construct_python_tuple)
610
611Constructor.add_constructor(
612    u'tag:yaml.org,2002:python/dict',
613    Constructor.construct_yaml_map)
614
615Constructor.add_multi_constructor(
616    u'tag:yaml.org,2002:python/name:',
617    Constructor.construct_python_name)
618
619Constructor.add_multi_constructor(
620    u'tag:yaml.org,2002:python/module:',
621    Constructor.construct_python_module)
622
623Constructor.add_multi_constructor(
624    u'tag:yaml.org,2002:python/object:',
625    Constructor.construct_python_object)
626
627Constructor.add_multi_constructor(
628    u'tag:yaml.org,2002:python/object/apply:',
629    Constructor.construct_python_object_apply)
630
631Constructor.add_multi_constructor(
632    u'tag:yaml.org,2002:python/object/new:',
633    Constructor.construct_python_object_new)
634
Note: See TracBrowser for help on using the repository browser.