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

Revision 175, 23.5 KB checked in by xi, 8 years ago (diff)

Optimize slightly the float constructor.

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