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

Revision 133, 14.1 KB checked in by xi, 8 years ago (diff)

Implement yaml.dump().

RevLine 
[55]1
[133]2__all__ = ['BaseConstructor', 'SafeConstructor', 'Constructor',
3    'ConstructorError']
[57]4
[55]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
[56]19import binascii, re
[55]20
21class ConstructorError(MarkedYAMLError):
22    pass
23
24class BaseConstructor:
25
26    def __init__(self, resolver):
27        self.resolver = resolver
28        self.constructed_objects = {}
29
30    def check(self):
31        # If there are more documents available?
32        return self.resolver.check()
33
34    def get(self):
35        # Construct and return the next document.
36        if self.resolver.check():
37            return self.construct_document(self.resolver.get())
38
39    def __iter__(self):
40        # Iterator protocol.
41        while self.resolver.check():
42            yield self.construct_document(self.resolver.get())
43
44    def construct_document(self, node):
45        native = self.construct_object(node)
46        self.constructed_objects = {}
47        return native
48
49    def construct_object(self, node):
50        if node in self.constructed_objects:
51            return self.constructed_objects[node]
52        if node.tag in self.yaml_constructors:
53            native = self.yaml_constructors[node.tag](self, node)
54        elif None in self.yaml_constructors:
55            native = self.yaml_constructors[None](self, node)
56        elif isinstance(node, ScalarNode):
57            native = self.construct_scalar(node)
58        elif isinstance(node, SequenceNode):
59            native = self.construct_sequence(node)
60        elif isinstance(node, MappingNode):
61            native = self.construct_mapping(node)
62        self.constructed_objects[node] = native
63        return native
64
65    def construct_scalar(self, node):
66        if not isinstance(node, ScalarNode):
67            if isinstance(node, MappingNode):
68                for key_node in node.value:
69                    if key_node.tag == u'tag:yaml.org,2002:value':
70                        return self.construct_scalar(node.value[key_node])
71            raise ConstructorError(None, None,
72                    "expected a scalar node, but found %s" % node.id,
[116]73                    node.start_mark)
[55]74        return node.value
75
76    def construct_sequence(self, node):
77        if not isinstance(node, SequenceNode):
78            raise ConstructorError(None, None,
79                    "expected a sequence node, but found %s" % node.id,
[116]80                    node.start_mark)
[55]81        return [self.construct_object(child) for child in node.value]
82
83    def construct_mapping(self, node):
84        if not isinstance(node, MappingNode):
85            raise ConstructorError(None, None,
86                    "expected a mapping node, but found %s" % node.id,
[116]87                    node.start_mark)
[55]88        mapping = {}
[56]89        merge = None
[55]90        for key_node in node.value:
[56]91            if key_node.tag == u'tag:yaml.org,2002:merge':
92                if merge is not None:
[116]93                    raise ConstructorError("while constructing a mapping", node.start_mark,
94                            "found duplicate merge key", key_node.start_mark)
[58]95                value_node = node.value[key_node]
96                if isinstance(value_node, MappingNode):
97                    merge = [self.construct_mapping(value_node)]
98                elif isinstance(value_node, SequenceNode):
99                    merge = []
100                    for subnode in value_node.value:
101                        if not isinstance(subnode, MappingNode):
102                            raise ConstructorError("while constructing a mapping",
[116]103                                    node.start_mark,
[58]104                                    "expected a mapping for merging, but found %s"
[116]105                                    % subnode.id, subnode.start_mark)
[58]106                        merge.append(self.construct_mapping(subnode))
107                    merge.reverse()
108                else:
[116]109                    raise ConstructorError("while constructing a mapping", node.start_mark,
[58]110                            "expected a mapping or list of mappings for merging, but found %s"
[116]111                            % value_node.id, value_node.start_mark)
[56]112            elif key_node.tag == u'tag:yaml.org,2002:value':
113                if '=' in mapping:
[116]114                    raise ConstructorError("while construction a mapping", node.start_mark,
115                            "found duplicate value key", key_node.start_mark)
[56]116                value = self.construct_object(node.value[key_node])
117                mapping['='] = value
118            else:
119                key = self.construct_object(key_node)
120                try:
121                    duplicate_key = key in mapping
122                except TypeError, exc:
[116]123                    raise ConstructorError("while constructing a mapping", node.start_mark,
124                            "found unacceptable key (%s)" % exc, key_node.start_mark)
[56]125                if duplicate_key:
[116]126                    raise ConstructorError("while constructing a mapping", node.start_mark,
127                            "found duplicate key", key_node.start_mark)
[56]128                value = self.construct_object(node.value[key_node])
129                mapping[key] = value
130        if merge is not None:
131            merge.append(mapping)
132            mapping = {}
133            for submapping in merge:
134                mapping.update(submapping)
[55]135        return mapping
136
137    def construct_pairs(self, node):
138        if not isinstance(node, MappingNode):
139            raise ConstructorError(None, None,
140                    "expected a mapping node, but found %s" % node.id,
[116]141                    node.start_mark)
[55]142        pairs = []
143        for key_node in node.value:
144            key = self.construct_object(key_node)
145            value = self.construct_object(node.value[key_node])
146            pairs.append((key, value))
147        return pairs
148
149    def add_constructor(cls, tag, constructor):
150        if not 'yaml_constructors' in cls.__dict__:
151            cls.yaml_constructors = cls.yaml_constructors.copy()
152        cls.yaml_constructors[tag] = constructor
153    add_constructor = classmethod(add_constructor)
154
155    yaml_constructors = {}
156
[133]157class SafeConstructor(BaseConstructor):
[55]158
159    def construct_yaml_null(self, node):
160        self.construct_scalar(node)
161        return None
162
163    bool_values = {
164        u'yes':     True,
165        u'no':      False,
166        u'true':    True,
167        u'false':   False,
168        u'on':      True,
169        u'off':     False,
170    }
171
172    def construct_yaml_bool(self, node):
173        value = self.construct_scalar(node)
174        return self.bool_values[value.lower()]
175
176    def construct_yaml_int(self, node):
177        value = str(self.construct_scalar(node))
178        value = value.replace('_', '')
179        sign = +1
180        if value[0] == '-':
181            sign = -1
182        if value[0] in '+-':
183            value = value[1:]
184        if value == '0':
185            return 0
186        elif value.startswith('0b'):
187            return sign*int(value[2:], 2)
188        elif value.startswith('0x'):
189            return sign*int(value[2:], 16)
190        elif value[0] == '0':
191            return sign*int(value, 8)
192        elif ':' in value:
193            digits = [int(part) for part in value.split(':')]
194            digits.reverse()
195            base = 1
196            value = 0
197            for digit in digits:
198                value += digit*base
199                base *= 60
200            return sign*value
201        else:
202            return sign*int(value)
203
204    inf_value = 1e300000
205    nan_value = inf_value/inf_value
206
207    def construct_yaml_float(self, node):
208        value = str(self.construct_scalar(node))
209        value = value.replace('_', '')
210        sign = +1
211        if value[0] == '-':
[58]212            sign = -1
[55]213        if value[0] in '+-':
214            value = value[1:]
215        if value.lower() == '.inf':
216            return sign*self.inf_value
217        elif value.lower() == '.nan':
218            return self.nan_value
219        elif ':' in value:
220            digits = [float(part) for part in value.split(':')]
221            digits.reverse()
222            base = 1
223            value = 0.0
224            for digit in digits:
225                value += digit*base
226                base *= 60
227            return sign*value
228        else:
229            return float(value)
230
231    def construct_yaml_binary(self, node):
232        value = self.construct_scalar(node)
233        try:
234            return str(value).decode('base64')
235        except (binascii.Error, UnicodeEncodeError), exc:
236            raise ConstructorError(None, None,
[116]237                    "failed to decode base64 data: %s" % exc, node.start_mark) 
[55]238
[56]239    timestamp_regexp = re.compile(
240            ur'''^(?P<year>[0-9][0-9][0-9][0-9])
241                -(?P<month>[0-9][0-9]?)
242                -(?P<day>[0-9][0-9]?)
[58]243                (?:(?:[Tt]|[ \t]+)
[56]244                (?P<hour>[0-9][0-9]?)
245                :(?P<minute>[0-9][0-9])
246                :(?P<second>[0-9][0-9])
247                (?:\.(?P<fraction>[0-9]*))?
248                (?:[ \t]*(?:Z|(?P<tz_hour>[-+][0-9][0-9]?)
[58]249                (?::(?P<tz_minute>[0-9][0-9])?)?))?)?$''', re.X)
[56]250
251    def construct_yaml_timestamp(self, node):
252        value = self.construct_scalar(node)
[58]253        match = self.timestamp_regexp.match(node.value)
[56]254        values = match.groupdict()
255        for key in values:
256            if values[key]:
257                values[key] = int(values[key])
258            else:
259                values[key] = 0
260        fraction = values['fraction']
[58]261        if fraction:
[56]262            while 10*fraction < 1000000:
263                fraction *= 10
264            values['fraction'] = fraction
265        stamp = datetime.datetime(values['year'], values['month'], values['day'],
266                values['hour'], values['minute'], values['second'], values['fraction'])
267        diff = datetime.timedelta(hours=values['tz_hour'], minutes=values['tz_minute'])
268        return stamp-diff
269
270    def construct_yaml_omap(self, node):
271        # Note: we do not check for duplicate keys, because it's too
272        # CPU-expensive.
273        if not isinstance(node, SequenceNode):
[116]274            raise ConstructorError("while constructing an ordered map", node.start_mark,
275                    "expected a sequence, but found %s" % node.id, node.start_mark)
[56]276        omap = []
277        for subnode in node.value:
278            if not isinstance(subnode, MappingNode):
[116]279                raise ConstructorError("while constructing an ordered map", node.start_mark,
[56]280                        "expected a mapping of length 1, but found %s" % subnode.id,
[116]281                        subnode.start_mark)
[58]282            if len(subnode.value) != 1:
[116]283                raise ConstructorError("while constructing an ordered map", node.start_mark,
[58]284                        "expected a single mapping item, but found %d items" % len(subnode.value),
[116]285                        subnode.start_mark)
[58]286            key_node = subnode.value.keys()[0]
287            key = self.construct_object(key_node)
288            value = self.construct_object(subnode.value[key_node])
289            omap.append((key, value))
290        return omap
[56]291
292    def construct_yaml_pairs(self, node):
293        # Note: the same code as `construct_yaml_omap`.
294        if not isinstance(node, SequenceNode):
[116]295            raise ConstructorError("while constructing pairs", node.start_mark,
296                    "expected a sequence, but found %s" % node.id, node.start_mark)
[58]297        pairs = []
[56]298        for subnode in node.value:
299            if not isinstance(subnode, MappingNode):
[116]300                raise ConstructorError("while constructing pairs", node.start_mark,
[56]301                        "expected a mapping of length 1, but found %s" % subnode.id,
[116]302                        subnode.start_mark)
[58]303            if len(subnode.value) != 1:
[116]304                raise ConstructorError("while constructing pairs", node.start_mark,
[58]305                        "expected a single mapping item, but found %d items" % len(subnode.value),
[116]306                        subnode.start_mark)
[58]307            key_node = subnode.value.keys()[0]
308            key = self.construct_object(key_node)
309            value = self.construct_object(subnode.value[key_node])
310            pairs.append((key, value))
311        return pairs
[56]312
313    def construct_yaml_set(self, node):
314        value = self.construct_mapping(node)
315        return set(value)
316
[55]317    def construct_yaml_str(self, node):
318        value = self.construct_scalar(node)
319        try:
320            return str(value)
321        except UnicodeEncodeError:
322            return value
323
[56]324    def construct_yaml_seq(self, node):
325        return self.construct_sequence(node)
326
327    def construct_yaml_map(self, node):
328        return self.construct_mapping(node)
329
[57]330    def construct_undefined(self, node):
331        raise ConstructorError(None, None,
332                "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'),
[116]333                node.start_mark)
[57]334
[133]335SafeConstructor.add_constructor(
[55]336        u'tag:yaml.org,2002:null',
[133]337        SafeConstructor.construct_yaml_null)
[55]338
[133]339SafeConstructor.add_constructor(
[55]340        u'tag:yaml.org,2002:bool',
[133]341        SafeConstructor.construct_yaml_bool)
[55]342
[133]343SafeConstructor.add_constructor(
[55]344        u'tag:yaml.org,2002:int',
[133]345        SafeConstructor.construct_yaml_int)
[55]346
[133]347SafeConstructor.add_constructor(
[55]348        u'tag:yaml.org,2002:float',
[133]349        SafeConstructor.construct_yaml_float)
[55]350
[133]351SafeConstructor.add_constructor(
[58]352        u'tag:yaml.org,2002:binary',
[133]353        SafeConstructor.construct_yaml_binary)
[56]354
[58]355if datetime_available:
[133]356    SafeConstructor.add_constructor(
[58]357            u'tag:yaml.org,2002:timestamp',
[133]358            SafeConstructor.construct_yaml_timestamp)
[58]359
[133]360SafeConstructor.add_constructor(
[56]361        u'tag:yaml.org,2002:omap',
[133]362        SafeConstructor.construct_yaml_omap)
[56]363
[133]364SafeConstructor.add_constructor(
[56]365        u'tag:yaml.org,2002:pairs',
[133]366        SafeConstructor.construct_yaml_pairs)
[56]367
[133]368SafeConstructor.add_constructor(
[56]369        u'tag:yaml.org,2002:set',
[133]370        SafeConstructor.construct_yaml_set)
[56]371
[133]372SafeConstructor.add_constructor(
[55]373        u'tag:yaml.org,2002:str',
[133]374        SafeConstructor.construct_yaml_str)
[55]375
[133]376SafeConstructor.add_constructor(
[56]377        u'tag:yaml.org,2002:seq',
[133]378        SafeConstructor.construct_yaml_seq)
[56]379
[133]380SafeConstructor.add_constructor(
[56]381        u'tag:yaml.org,2002:map',
[133]382        SafeConstructor.construct_yaml_map)
[56]383
[133]384SafeConstructor.add_constructor(None,
385        SafeConstructor.construct_undefined)
[57]386
[133]387class Constructor(SafeConstructor):
388    pass
[55]389
Note: See TracBrowser for help on using the repository browser.