Restoring authorship annotation for Mikhail Borisov <borisov.mikhail@gmail.com>. Commit 1 of 2.

1 files changed, 612 insertions, 612 deletions

diff --git a/contrib/python/PyYAML/py2/yaml/constructor.py b/contrib/python/PyYAML/py2/yaml/constructor.py
index ff4e36828e..f4dd7b0054 100644
--- a/contrib/python/PyYAML/py2/yaml/constructor.py
+++ b/contrib/python/PyYAML/py2/yaml/constructor.py
@@ -1,4 +1,4 @@
-
+ 
 __all__ = [
     'BaseConstructor',
     'SafeConstructor',
@@ -7,17 +7,17 @@ __all__ = [
     'Constructor',
     'ConstructorError'
 ]
-
-from error import *
-from nodes import *
-
-import datetime
-
-import binascii, re, sys, types
-
-class ConstructorError(MarkedYAMLError):
-    pass
-
+ 
+from error import * 
+from nodes import * 
+ 
+import datetime 
+ 
+import binascii, re, sys, types 
+ 
+class ConstructorError(MarkedYAMLError): 
+    pass 
+ 
 
 class timezone(datetime.tzinfo):
     def __init__(self, offset):
@@ -47,21 +47,21 @@ class timezone(datetime.tzinfo):
     __repr__ = __str__ = tzname
 
 
-class BaseConstructor(object):
-
-    yaml_constructors = {}
-    yaml_multi_constructors = {}
-
-    def __init__(self):
-        self.constructed_objects = {}
-        self.recursive_objects = {}
-        self.state_generators = []
-        self.deep_construct = False
-
-    def check_data(self):
-        # If there are more documents available?
-        return self.check_node()
-
+class BaseConstructor(object): 
+ 
+    yaml_constructors = {} 
+    yaml_multi_constructors = {} 
+ 
+    def __init__(self): 
+        self.constructed_objects = {} 
+        self.recursive_objects = {} 
+        self.state_generators = [] 
+        self.deep_construct = False 
+ 
+    def check_data(self): 
+        # If there are more documents available? 
+        return self.check_node() 
+ 
     def check_state_key(self, key):
         """Block special attributes/methods from being set in a newly created
         object, to prevent user-controlled methods from being called during
@@ -70,475 +70,475 @@ class BaseConstructor(object):
             raise ConstructorError(None, None,
                 "blacklisted key '%s' in instance state found" % (key,), None)
 
-    def get_data(self):
-        # Construct and return the next document.
-        if self.check_node():
-            return self.construct_document(self.get_node())
-
-    def get_single_data(self):
-        # Ensure that the stream contains a single document and construct it.
-        node = self.get_single_node()
-        if node is not None:
-            return self.construct_document(node)
-        return None
-
-    def construct_document(self, node):
-        data = self.construct_object(node)
-        while self.state_generators:
-            state_generators = self.state_generators
-            self.state_generators = []
-            for generator in state_generators:
-                for dummy in generator:
-                    pass
-        self.constructed_objects = {}
-        self.recursive_objects = {}
-        self.deep_construct = False
-        return data
-
-    def construct_object(self, node, deep=False):
-        if node in self.constructed_objects:
-            return self.constructed_objects[node]
-        if deep:
-            old_deep = self.deep_construct
-            self.deep_construct = True
-        if node in self.recursive_objects:
-            raise ConstructorError(None, None,
-                    "found unconstructable recursive node", node.start_mark)
-        self.recursive_objects[node] = None
-        constructor = None
-        tag_suffix = None
-        if node.tag in self.yaml_constructors:
-            constructor = self.yaml_constructors[node.tag]
-        else:
-            for tag_prefix in self.yaml_multi_constructors:
+    def get_data(self): 
+        # Construct and return the next document. 
+        if self.check_node(): 
+            return self.construct_document(self.get_node()) 
+ 
+    def get_single_data(self): 
+        # Ensure that the stream contains a single document and construct it. 
+        node = self.get_single_node() 
+        if node is not None: 
+            return self.construct_document(node) 
+        return None 
+ 
+    def construct_document(self, node): 
+        data = self.construct_object(node) 
+        while self.state_generators: 
+            state_generators = self.state_generators 
+            self.state_generators = [] 
+            for generator in state_generators: 
+                for dummy in generator: 
+                    pass 
+        self.constructed_objects = {} 
+        self.recursive_objects = {} 
+        self.deep_construct = False 
+        return data 
+ 
+    def construct_object(self, node, deep=False): 
+        if node in self.constructed_objects: 
+            return self.constructed_objects[node] 
+        if deep: 
+            old_deep = self.deep_construct 
+            self.deep_construct = True 
+        if node in self.recursive_objects: 
+            raise ConstructorError(None, None, 
+                    "found unconstructable recursive node", node.start_mark) 
+        self.recursive_objects[node] = None 
+        constructor = None 
+        tag_suffix = None 
+        if node.tag in self.yaml_constructors: 
+            constructor = self.yaml_constructors[node.tag] 
+        else: 
+            for tag_prefix in self.yaml_multi_constructors: 
                 if tag_prefix is not None and node.tag.startswith(tag_prefix):
-                    tag_suffix = node.tag[len(tag_prefix):]
-                    constructor = self.yaml_multi_constructors[tag_prefix]
-                    break
-            else:
-                if None in self.yaml_multi_constructors:
-                    tag_suffix = node.tag
-                    constructor = self.yaml_multi_constructors[None]
-                elif None in self.yaml_constructors:
-                    constructor = self.yaml_constructors[None]
-                elif isinstance(node, ScalarNode):
-                    constructor = self.__class__.construct_scalar
-                elif isinstance(node, SequenceNode):
-                    constructor = self.__class__.construct_sequence
-                elif isinstance(node, MappingNode):
-                    constructor = self.__class__.construct_mapping
-        if tag_suffix is None:
-            data = constructor(self, node)
-        else:
-            data = constructor(self, tag_suffix, node)
-        if isinstance(data, types.GeneratorType):
-            generator = data
-            data = generator.next()
-            if self.deep_construct:
-                for dummy in generator:
-                    pass
-            else:
-                self.state_generators.append(generator)
-        self.constructed_objects[node] = data
-        del self.recursive_objects[node]
-        if deep:
-            self.deep_construct = old_deep
-        return data
-
-    def construct_scalar(self, node):
-        if not isinstance(node, ScalarNode):
-            raise ConstructorError(None, None,
-                    "expected a scalar node, but found %s" % node.id,
-                    node.start_mark)
-        return node.value
-
-    def construct_sequence(self, node, deep=False):
-        if not isinstance(node, SequenceNode):
-            raise ConstructorError(None, None,
-                    "expected a sequence node, but found %s" % node.id,
-                    node.start_mark)
-        return [self.construct_object(child, deep=deep)
-                for child in node.value]
-
-    def construct_mapping(self, node, deep=False):
-        if not isinstance(node, MappingNode):
-            raise ConstructorError(None, None,
-                    "expected a mapping node, but found %s" % node.id,
-                    node.start_mark)
-        mapping = {}
-        for key_node, value_node in node.value:
-            key = self.construct_object(key_node, deep=deep)
-            try:
-                hash(key)
-            except TypeError, exc:
-                raise ConstructorError("while constructing a mapping", node.start_mark,
-                        "found unacceptable key (%s)" % exc, key_node.start_mark)
-            value = self.construct_object(value_node, deep=deep)
-            mapping[key] = value
-        return mapping
-
-    def construct_pairs(self, node, deep=False):
-        if not isinstance(node, MappingNode):
-            raise ConstructorError(None, None,
-                    "expected a mapping node, but found %s" % node.id,
-                    node.start_mark)
-        pairs = []
-        for key_node, value_node in node.value:
-            key = self.construct_object(key_node, deep=deep)
-            value = self.construct_object(value_node, deep=deep)
-            pairs.append((key, value))
-        return pairs
-
-    def add_constructor(cls, tag, constructor):
-        if not 'yaml_constructors' in cls.__dict__:
-            cls.yaml_constructors = cls.yaml_constructors.copy()
-        cls.yaml_constructors[tag] = constructor
-    add_constructor = classmethod(add_constructor)
-
-    def add_multi_constructor(cls, tag_prefix, multi_constructor):
-        if not 'yaml_multi_constructors' in cls.__dict__:
-            cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy()
-        cls.yaml_multi_constructors[tag_prefix] = multi_constructor
-    add_multi_constructor = classmethod(add_multi_constructor)
-
-class SafeConstructor(BaseConstructor):
-
-    def construct_scalar(self, node):
-        if isinstance(node, MappingNode):
-            for key_node, value_node in node.value:
-                if key_node.tag == u'tag:yaml.org,2002:value':
-                    return self.construct_scalar(value_node)
-        return BaseConstructor.construct_scalar(self, node)
-
-    def flatten_mapping(self, node):
-        merge = []
-        index = 0
-        while index < len(node.value):
-            key_node, value_node = node.value[index]
-            if key_node.tag == u'tag:yaml.org,2002:merge':
-                del node.value[index]
-                if isinstance(value_node, MappingNode):
-                    self.flatten_mapping(value_node)
-                    merge.extend(value_node.value)
-                elif isinstance(value_node, SequenceNode):
-                    submerge = []
-                    for subnode in value_node.value:
-                        if not isinstance(subnode, MappingNode):
-                            raise ConstructorError("while constructing a mapping",
-                                    node.start_mark,
-                                    "expected a mapping for merging, but found %s"
-                                    % subnode.id, subnode.start_mark)
-                        self.flatten_mapping(subnode)
-                        submerge.append(subnode.value)
-                    submerge.reverse()
-                    for value in submerge:
-                        merge.extend(value)
-                else:
-                    raise ConstructorError("while constructing a mapping", node.start_mark,
-                            "expected a mapping or list of mappings for merging, but found %s"
-                            % value_node.id, value_node.start_mark)
-            elif key_node.tag == u'tag:yaml.org,2002:value':
-                key_node.tag = u'tag:yaml.org,2002:str'
-                index += 1
-            else:
-                index += 1
-        if merge:
-            node.value = merge + node.value
-
-    def construct_mapping(self, node, deep=False):
-        if isinstance(node, MappingNode):
-            self.flatten_mapping(node)
-        return BaseConstructor.construct_mapping(self, node, deep=deep)
-
-    def construct_yaml_null(self, node):
-        self.construct_scalar(node)
-        return None
-
-    bool_values = {
-        u'yes':     True,
-        u'no':      False,
-        u'true':    True,
-        u'false':   False,
-        u'on':      True,
-        u'off':     False,
-    }
-
-    def construct_yaml_bool(self, node):
-        value = self.construct_scalar(node)
-        return self.bool_values[value.lower()]
-
-    def construct_yaml_int(self, node):
-        value = str(self.construct_scalar(node))
-        value = value.replace('_', '')
-        sign = +1
-        if value[0] == '-':
-            sign = -1
-        if value[0] in '+-':
-            value = value[1:]
-        if value == '0':
-            return 0
-        elif value.startswith('0b'):
-            return sign*int(value[2:], 2)
-        elif value.startswith('0x'):
-            return sign*int(value[2:], 16)
-        elif value[0] == '0':
-            return sign*int(value, 8)
-        elif ':' in value:
-            digits = [int(part) for part in value.split(':')]
-            digits.reverse()
-            base = 1
-            value = 0
-            for digit in digits:
-                value += digit*base
-                base *= 60
-            return sign*value
-        else:
-            return sign*int(value)
-
-    inf_value = 1e300
-    while inf_value != inf_value*inf_value:
-        inf_value *= inf_value
-    nan_value = -inf_value/inf_value   # Trying to make a quiet NaN (like C99).
-
-    def construct_yaml_float(self, node):
-        value = str(self.construct_scalar(node))
-        value = value.replace('_', '').lower()
-        sign = +1
-        if value[0] == '-':
-            sign = -1
-        if value[0] in '+-':
-            value = value[1:]
-        if value == '.inf':
-            return sign*self.inf_value
-        elif value == '.nan':
-            return self.nan_value
-        elif ':' in value:
-            digits = [float(part) for part in value.split(':')]
-            digits.reverse()
-            base = 1
-            value = 0.0
-            for digit in digits:
-                value += digit*base
-                base *= 60
-            return sign*value
-        else:
-            return sign*float(value)
-
-    def construct_yaml_binary(self, node):
-        value = self.construct_scalar(node)
-        try:
-            return str(value).decode('base64')
-        except (binascii.Error, UnicodeEncodeError), exc:
-            raise ConstructorError(None, None,
+                    tag_suffix = node.tag[len(tag_prefix):] 
+                    constructor = self.yaml_multi_constructors[tag_prefix] 
+                    break 
+            else: 
+                if None in self.yaml_multi_constructors: 
+                    tag_suffix = node.tag 
+                    constructor = self.yaml_multi_constructors[None] 
+                elif None in self.yaml_constructors: 
+                    constructor = self.yaml_constructors[None] 
+                elif isinstance(node, ScalarNode): 
+                    constructor = self.__class__.construct_scalar 
+                elif isinstance(node, SequenceNode): 
+                    constructor = self.__class__.construct_sequence 
+                elif isinstance(node, MappingNode): 
+                    constructor = self.__class__.construct_mapping 
+        if tag_suffix is None: 
+            data = constructor(self, node) 
+        else: 
+            data = constructor(self, tag_suffix, node) 
+        if isinstance(data, types.GeneratorType): 
+            generator = data 
+            data = generator.next() 
+            if self.deep_construct: 
+                for dummy in generator: 
+                    pass 
+            else: 
+                self.state_generators.append(generator) 
+        self.constructed_objects[node] = data 
+        del self.recursive_objects[node] 
+        if deep: 
+            self.deep_construct = old_deep 
+        return data 
+ 
+    def construct_scalar(self, node): 
+        if not isinstance(node, ScalarNode): 
+            raise ConstructorError(None, None, 
+                    "expected a scalar node, but found %s" % node.id, 
+                    node.start_mark) 
+        return node.value 
+ 
+    def construct_sequence(self, node, deep=False): 
+        if not isinstance(node, SequenceNode): 
+            raise ConstructorError(None, None, 
+                    "expected a sequence node, but found %s" % node.id, 
+                    node.start_mark) 
+        return [self.construct_object(child, deep=deep) 
+                for child in node.value] 
+ 
+    def construct_mapping(self, node, deep=False): 
+        if not isinstance(node, MappingNode): 
+            raise ConstructorError(None, None, 
+                    "expected a mapping node, but found %s" % node.id, 
+                    node.start_mark) 
+        mapping = {} 
+        for key_node, value_node in node.value: 
+            key = self.construct_object(key_node, deep=deep) 
+            try: 
+                hash(key) 
+            except TypeError, exc: 
+                raise ConstructorError("while constructing a mapping", node.start_mark, 
+                        "found unacceptable key (%s)" % exc, key_node.start_mark) 
+            value = self.construct_object(value_node, deep=deep) 
+            mapping[key] = value 
+        return mapping 
+ 
+    def construct_pairs(self, node, deep=False): 
+        if not isinstance(node, MappingNode): 
+            raise ConstructorError(None, None, 
+                    "expected a mapping node, but found %s" % node.id, 
+                    node.start_mark) 
+        pairs = [] 
+        for key_node, value_node in node.value: 
+            key = self.construct_object(key_node, deep=deep) 
+            value = self.construct_object(value_node, deep=deep) 
+            pairs.append((key, value)) 
+        return pairs 
+ 
+    def add_constructor(cls, tag, constructor): 
+        if not 'yaml_constructors' in cls.__dict__: 
+            cls.yaml_constructors = cls.yaml_constructors.copy() 
+        cls.yaml_constructors[tag] = constructor 
+    add_constructor = classmethod(add_constructor) 
+ 
+    def add_multi_constructor(cls, tag_prefix, multi_constructor): 
+        if not 'yaml_multi_constructors' in cls.__dict__: 
+            cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy() 
+        cls.yaml_multi_constructors[tag_prefix] = multi_constructor 
+    add_multi_constructor = classmethod(add_multi_constructor) 
+ 
+class SafeConstructor(BaseConstructor): 
+ 
+    def construct_scalar(self, node): 
+        if isinstance(node, MappingNode): 
+            for key_node, value_node in node.value: 
+                if key_node.tag == u'tag:yaml.org,2002:value': 
+                    return self.construct_scalar(value_node) 
+        return BaseConstructor.construct_scalar(self, node) 
+ 
+    def flatten_mapping(self, node): 
+        merge = [] 
+        index = 0 
+        while index < len(node.value): 
+            key_node, value_node = node.value[index] 
+            if key_node.tag == u'tag:yaml.org,2002:merge': 
+                del node.value[index] 
+                if isinstance(value_node, MappingNode): 
+                    self.flatten_mapping(value_node) 
+                    merge.extend(value_node.value) 
+                elif isinstance(value_node, SequenceNode): 
+                    submerge = [] 
+                    for subnode in value_node.value: 
+                        if not isinstance(subnode, MappingNode): 
+                            raise ConstructorError("while constructing a mapping", 
+                                    node.start_mark, 
+                                    "expected a mapping for merging, but found %s" 
+                                    % subnode.id, subnode.start_mark) 
+                        self.flatten_mapping(subnode) 
+                        submerge.append(subnode.value) 
+                    submerge.reverse() 
+                    for value in submerge: 
+                        merge.extend(value) 
+                else: 
+                    raise ConstructorError("while constructing a mapping", node.start_mark, 
+                            "expected a mapping or list of mappings for merging, but found %s" 
+                            % value_node.id, value_node.start_mark) 
+            elif key_node.tag == u'tag:yaml.org,2002:value': 
+                key_node.tag = u'tag:yaml.org,2002:str' 
+                index += 1 
+            else: 
+                index += 1 
+        if merge: 
+            node.value = merge + node.value 
+ 
+    def construct_mapping(self, node, deep=False): 
+        if isinstance(node, MappingNode): 
+            self.flatten_mapping(node) 
+        return BaseConstructor.construct_mapping(self, node, deep=deep) 
+ 
+    def construct_yaml_null(self, node): 
+        self.construct_scalar(node) 
+        return None 
+ 
+    bool_values = { 
+        u'yes':     True, 
+        u'no':      False, 
+        u'true':    True, 
+        u'false':   False, 
+        u'on':      True, 
+        u'off':     False, 
+    } 
+ 
+    def construct_yaml_bool(self, node): 
+        value = self.construct_scalar(node) 
+        return self.bool_values[value.lower()] 
+ 
+    def construct_yaml_int(self, node): 
+        value = str(self.construct_scalar(node)) 
+        value = value.replace('_', '') 
+        sign = +1 
+        if value[0] == '-': 
+            sign = -1 
+        if value[0] in '+-': 
+            value = value[1:] 
+        if value == '0': 
+            return 0 
+        elif value.startswith('0b'): 
+            return sign*int(value[2:], 2) 
+        elif value.startswith('0x'): 
+            return sign*int(value[2:], 16) 
+        elif value[0] == '0': 
+            return sign*int(value, 8) 
+        elif ':' in value: 
+            digits = [int(part) for part in value.split(':')] 
+            digits.reverse() 
+            base = 1 
+            value = 0 
+            for digit in digits: 
+                value += digit*base 
+                base *= 60 
+            return sign*value 
+        else: 
+            return sign*int(value) 
+ 
+    inf_value = 1e300 
+    while inf_value != inf_value*inf_value: 
+        inf_value *= inf_value 
+    nan_value = -inf_value/inf_value   # Trying to make a quiet NaN (like C99). 
+ 
+    def construct_yaml_float(self, node): 
+        value = str(self.construct_scalar(node)) 
+        value = value.replace('_', '').lower() 
+        sign = +1 
+        if value[0] == '-': 
+            sign = -1 
+        if value[0] in '+-': 
+            value = value[1:] 
+        if value == '.inf': 
+            return sign*self.inf_value 
+        elif value == '.nan': 
+            return self.nan_value 
+        elif ':' in value: 
+            digits = [float(part) for part in value.split(':')] 
+            digits.reverse() 
+            base = 1 
+            value = 0.0 
+            for digit in digits: 
+                value += digit*base 
+                base *= 60 
+            return sign*value 
+        else: 
+            return sign*float(value) 
+ 
+    def construct_yaml_binary(self, node): 
+        value = self.construct_scalar(node) 
+        try: 
+            return str(value).decode('base64') 
+        except (binascii.Error, UnicodeEncodeError), exc: 
+            raise ConstructorError(None, None, 
                     "failed to decode base64 data: %s" % exc, node.start_mark)
-
-    timestamp_regexp = re.compile(
-            ur'''^(?P<year>[0-9][0-9][0-9][0-9])
-                -(?P<month>[0-9][0-9]?)
-                -(?P<day>[0-9][0-9]?)
-                (?:(?:[Tt]|[ \t]+)
-                (?P<hour>[0-9][0-9]?)
-                :(?P<minute>[0-9][0-9])
-                :(?P<second>[0-9][0-9])
-                (?:\.(?P<fraction>[0-9]*))?
-                (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
-                (?::(?P<tz_minute>[0-9][0-9]))?))?)?$''', re.X)
-
-    def construct_yaml_timestamp(self, node):
-        value = self.construct_scalar(node)
-        match = self.timestamp_regexp.match(node.value)
-        values = match.groupdict()
-        year = int(values['year'])
-        month = int(values['month'])
-        day = int(values['day'])
-        if not values['hour']:
-            return datetime.date(year, month, day)
-        hour = int(values['hour'])
-        minute = int(values['minute'])
-        second = int(values['second'])
-        fraction = 0
+ 
+    timestamp_regexp = re.compile( 
+            ur'''^(?P<year>[0-9][0-9][0-9][0-9]) 
+                -(?P<month>[0-9][0-9]?) 
+                -(?P<day>[0-9][0-9]?) 
+                (?:(?:[Tt]|[ \t]+) 
+                (?P<hour>[0-9][0-9]?) 
+                :(?P<minute>[0-9][0-9]) 
+                :(?P<second>[0-9][0-9]) 
+                (?:\.(?P<fraction>[0-9]*))? 
+                (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?) 
+                (?::(?P<tz_minute>[0-9][0-9]))?))?)?$''', re.X) 
+ 
+    def construct_yaml_timestamp(self, node): 
+        value = self.construct_scalar(node) 
+        match = self.timestamp_regexp.match(node.value) 
+        values = match.groupdict() 
+        year = int(values['year']) 
+        month = int(values['month']) 
+        day = int(values['day']) 
+        if not values['hour']: 
+            return datetime.date(year, month, day) 
+        hour = int(values['hour']) 
+        minute = int(values['minute']) 
+        second = int(values['second']) 
+        fraction = 0 
         tzinfo = None
-        if values['fraction']:
-            fraction = values['fraction'][:6]
-            while len(fraction) < 6:
-                fraction += '0'
-            fraction = int(fraction)
-        if values['tz_sign']:
-            tz_hour = int(values['tz_hour'])
-            tz_minute = int(values['tz_minute'] or 0)
-            delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute)
-            if values['tz_sign'] == '-':
-                delta = -delta
+        if values['fraction']: 
+            fraction = values['fraction'][:6] 
+            while len(fraction) < 6: 
+                fraction += '0' 
+            fraction = int(fraction) 
+        if values['tz_sign']: 
+            tz_hour = int(values['tz_hour']) 
+            tz_minute = int(values['tz_minute'] or 0) 
+            delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute) 
+            if values['tz_sign'] == '-': 
+                delta = -delta 
             tzinfo = timezone(delta)
         elif values['tz']:
             tzinfo = timezone(datetime.timedelta(0))
         return datetime.datetime(year, month, day, hour, minute, second, fraction,
                                  tzinfo=tzinfo)
-
-    def construct_yaml_omap(self, node):
-        # Note: we do not check for duplicate keys, because it's too
-        # CPU-expensive.
-        omap = []
-        yield omap
-        if not isinstance(node, SequenceNode):
-            raise ConstructorError("while constructing an ordered map", node.start_mark,
-                    "expected a sequence, but found %s" % node.id, node.start_mark)
-        for subnode in node.value:
-            if not isinstance(subnode, MappingNode):
-                raise ConstructorError("while constructing an ordered map", node.start_mark,
-                        "expected a mapping of length 1, but found %s" % subnode.id,
-                        subnode.start_mark)
-            if len(subnode.value) != 1:
-                raise ConstructorError("while constructing an ordered map", node.start_mark,
-                        "expected a single mapping item, but found %d items" % len(subnode.value),
-                        subnode.start_mark)
-            key_node, value_node = subnode.value[0]
-            key = self.construct_object(key_node)
-            value = self.construct_object(value_node)
-            omap.append((key, value))
-
-    def construct_yaml_pairs(self, node):
-        # Note: the same code as `construct_yaml_omap`.
-        pairs = []
-        yield pairs
-        if not isinstance(node, SequenceNode):
-            raise ConstructorError("while constructing pairs", node.start_mark,
-                    "expected a sequence, but found %s" % node.id, node.start_mark)
-        for subnode in node.value:
-            if not isinstance(subnode, MappingNode):
-                raise ConstructorError("while constructing pairs", node.start_mark,
-                        "expected a mapping of length 1, but found %s" % subnode.id,
-                        subnode.start_mark)
-            if len(subnode.value) != 1:
-                raise ConstructorError("while constructing pairs", node.start_mark,
-                        "expected a single mapping item, but found %d items" % len(subnode.value),
-                        subnode.start_mark)
-            key_node, value_node = subnode.value[0]
-            key = self.construct_object(key_node)
-            value = self.construct_object(value_node)
-            pairs.append((key, value))
-
-    def construct_yaml_set(self, node):
-        data = set()
-        yield data
-        value = self.construct_mapping(node)
-        data.update(value)
-
-    def construct_yaml_str(self, node):
-        value = self.construct_scalar(node)
-        try:
-            return value.encode('ascii')
-        except UnicodeEncodeError:
-            return value
-
-    def construct_yaml_seq(self, node):
-        data = []
-        yield data
-        data.extend(self.construct_sequence(node))
-
-    def construct_yaml_map(self, node):
-        data = {}
-        yield data
-        value = self.construct_mapping(node)
-        data.update(value)
-
-    def construct_yaml_object(self, node, cls):
-        data = cls.__new__(cls)
-        yield data
-        if hasattr(data, '__setstate__'):
-            state = self.construct_mapping(node, deep=True)
-            data.__setstate__(state)
-        else:
-            state = self.construct_mapping(node)
-            data.__dict__.update(state)
-
-    def construct_undefined(self, node):
-        raise ConstructorError(None, None,
-                "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'),
-                node.start_mark)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:null',
-        SafeConstructor.construct_yaml_null)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:bool',
-        SafeConstructor.construct_yaml_bool)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:int',
-        SafeConstructor.construct_yaml_int)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:float',
-        SafeConstructor.construct_yaml_float)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:binary',
-        SafeConstructor.construct_yaml_binary)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:timestamp',
-        SafeConstructor.construct_yaml_timestamp)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:omap',
-        SafeConstructor.construct_yaml_omap)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:pairs',
-        SafeConstructor.construct_yaml_pairs)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:set',
-        SafeConstructor.construct_yaml_set)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:str',
-        SafeConstructor.construct_yaml_str)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:seq',
-        SafeConstructor.construct_yaml_seq)
-
-SafeConstructor.add_constructor(
-        u'tag:yaml.org,2002:map',
-        SafeConstructor.construct_yaml_map)
-
-SafeConstructor.add_constructor(None,
-        SafeConstructor.construct_undefined)
-
+ 
+    def construct_yaml_omap(self, node): 
+        # Note: we do not check for duplicate keys, because it's too 
+        # CPU-expensive. 
+        omap = [] 
+        yield omap 
+        if not isinstance(node, SequenceNode): 
+            raise ConstructorError("while constructing an ordered map", node.start_mark, 
+                    "expected a sequence, but found %s" % node.id, node.start_mark) 
+        for subnode in node.value: 
+            if not isinstance(subnode, MappingNode): 
+                raise ConstructorError("while constructing an ordered map", node.start_mark, 
+                        "expected a mapping of length 1, but found %s" % subnode.id, 
+                        subnode.start_mark) 
+            if len(subnode.value) != 1: 
+                raise ConstructorError("while constructing an ordered map", node.start_mark, 
+                        "expected a single mapping item, but found %d items" % len(subnode.value), 
+                        subnode.start_mark) 
+            key_node, value_node = subnode.value[0] 
+            key = self.construct_object(key_node) 
+            value = self.construct_object(value_node) 
+            omap.append((key, value)) 
+ 
+    def construct_yaml_pairs(self, node): 
+        # Note: the same code as `construct_yaml_omap`. 
+        pairs = [] 
+        yield pairs 
+        if not isinstance(node, SequenceNode): 
+            raise ConstructorError("while constructing pairs", node.start_mark, 
+                    "expected a sequence, but found %s" % node.id, node.start_mark) 
+        for subnode in node.value: 
+            if not isinstance(subnode, MappingNode): 
+                raise ConstructorError("while constructing pairs", node.start_mark, 
+                        "expected a mapping of length 1, but found %s" % subnode.id, 
+                        subnode.start_mark) 
+            if len(subnode.value) != 1: 
+                raise ConstructorError("while constructing pairs", node.start_mark, 
+                        "expected a single mapping item, but found %d items" % len(subnode.value), 
+                        subnode.start_mark) 
+            key_node, value_node = subnode.value[0] 
+            key = self.construct_object(key_node) 
+            value = self.construct_object(value_node) 
+            pairs.append((key, value)) 
+ 
+    def construct_yaml_set(self, node): 
+        data = set() 
+        yield data 
+        value = self.construct_mapping(node) 
+        data.update(value) 
+ 
+    def construct_yaml_str(self, node): 
+        value = self.construct_scalar(node) 
+        try: 
+            return value.encode('ascii') 
+        except UnicodeEncodeError: 
+            return value 
+ 
+    def construct_yaml_seq(self, node): 
+        data = [] 
+        yield data 
+        data.extend(self.construct_sequence(node)) 
+ 
+    def construct_yaml_map(self, node): 
+        data = {} 
+        yield data 
+        value = self.construct_mapping(node) 
+        data.update(value) 
+ 
+    def construct_yaml_object(self, node, cls): 
+        data = cls.__new__(cls) 
+        yield data 
+        if hasattr(data, '__setstate__'): 
+            state = self.construct_mapping(node, deep=True) 
+            data.__setstate__(state) 
+        else: 
+            state = self.construct_mapping(node) 
+            data.__dict__.update(state) 
+ 
+    def construct_undefined(self, node): 
+        raise ConstructorError(None, None, 
+                "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'), 
+                node.start_mark) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:null', 
+        SafeConstructor.construct_yaml_null) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:bool', 
+        SafeConstructor.construct_yaml_bool) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:int', 
+        SafeConstructor.construct_yaml_int) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:float', 
+        SafeConstructor.construct_yaml_float) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:binary', 
+        SafeConstructor.construct_yaml_binary) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:timestamp', 
+        SafeConstructor.construct_yaml_timestamp) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:omap', 
+        SafeConstructor.construct_yaml_omap) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:pairs', 
+        SafeConstructor.construct_yaml_pairs) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:set', 
+        SafeConstructor.construct_yaml_set) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:str', 
+        SafeConstructor.construct_yaml_str) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:seq', 
+        SafeConstructor.construct_yaml_seq) 
+ 
+SafeConstructor.add_constructor( 
+        u'tag:yaml.org,2002:map', 
+        SafeConstructor.construct_yaml_map) 
+ 
+SafeConstructor.add_constructor(None, 
+        SafeConstructor.construct_undefined) 
+ 
 class FullConstructor(SafeConstructor):
     # 'extend' is blacklisted because it is used by
     # construct_python_object_apply to add `listitems` to a newly generate
     # python instance
     def get_state_keys_blacklist(self):
         return ['^extend$', '^__.*__$']
-
+ 
     def get_state_keys_blacklist_regexp(self):
         if not hasattr(self, 'state_keys_blacklist_regexp'):
             self.state_keys_blacklist_regexp = re.compile('(' + '|'.join(self.get_state_keys_blacklist()) + ')')
         return self.state_keys_blacklist_regexp
 
-    def construct_python_str(self, node):
-        return self.construct_scalar(node).encode('utf-8')
-
-    def construct_python_unicode(self, node):
-        return self.construct_scalar(node)
-
-    def construct_python_long(self, node):
-        return long(self.construct_yaml_int(node))
-
-    def construct_python_complex(self, node):
-       return complex(self.construct_scalar(node))
-
-    def construct_python_tuple(self, node):
-        return tuple(self.construct_sequence(node))
-
+    def construct_python_str(self, node): 
+        return self.construct_scalar(node).encode('utf-8') 
+ 
+    def construct_python_unicode(self, node): 
+        return self.construct_scalar(node) 
+ 
+    def construct_python_long(self, node): 
+        return long(self.construct_yaml_int(node)) 
+ 
+    def construct_python_complex(self, node): 
+       return complex(self.construct_scalar(node)) 
+ 
+    def construct_python_tuple(self, node): 
+        return tuple(self.construct_sequence(node)) 
+ 
     def find_python_module(self, name, mark, unsafe=False):
-        if not name:
-            raise ConstructorError("while constructing a Python module", mark,
-                    "expected non-empty name appended to the tag", mark)
+        if not name: 
+            raise ConstructorError("while constructing a Python module", mark, 
+                    "expected non-empty name appended to the tag", mark) 
         if unsafe:
             try:
                 __import__(name)
@@ -546,19 +546,19 @@ class FullConstructor(SafeConstructor):
                 raise ConstructorError("while constructing a Python module", mark,
                         "cannot find module %r (%s)" % (name.encode('utf-8'), exc), mark)
         if name not in sys.modules:
-            raise ConstructorError("while constructing a Python module", mark,
+            raise ConstructorError("while constructing a Python module", mark, 
                     "module %r is not imported" % name.encode('utf-8'), mark)
-        return sys.modules[name]
-
+        return sys.modules[name] 
+ 
     def find_python_name(self, name, mark, unsafe=False):
-        if not name:
-            raise ConstructorError("while constructing a Python object", mark,
-                    "expected non-empty name appended to the tag", mark)
-        if u'.' in name:
-            module_name, object_name = name.rsplit('.', 1)
-        else:
-            module_name = '__builtin__'
-            object_name = name
+        if not name: 
+            raise ConstructorError("while constructing a Python object", mark, 
+                    "expected non-empty name appended to the tag", mark) 
+        if u'.' in name: 
+            module_name, object_name = name.rsplit('.', 1) 
+        else: 
+            module_name = '__builtin__' 
+            object_name = name 
         if unsafe:
             try:
                 __import__(module_name)
@@ -566,168 +566,168 @@ class FullConstructor(SafeConstructor):
                 raise ConstructorError("while constructing a Python object", mark,
                         "cannot find module %r (%s)" % (module_name.encode('utf-8'), exc), mark)
         if module_name not in sys.modules:
-            raise ConstructorError("while constructing a Python object", mark,
+            raise ConstructorError("while constructing a Python object", mark, 
                     "module %r is not imported" % module_name.encode('utf-8'), mark)
-        module = sys.modules[module_name]
-        if not hasattr(module, object_name):
-            raise ConstructorError("while constructing a Python object", mark,
-                    "cannot find %r in the module %r" % (object_name.encode('utf-8'),
-                        module.__name__), mark)
-        return getattr(module, object_name)
-
-    def construct_python_name(self, suffix, node):
-        value = self.construct_scalar(node)
-        if value:
-            raise ConstructorError("while constructing a Python name", node.start_mark,
-                    "expected the empty value, but found %r" % value.encode('utf-8'),
-                    node.start_mark)
-        return self.find_python_name(suffix, node.start_mark)
-
-    def construct_python_module(self, suffix, node):
-        value = self.construct_scalar(node)
-        if value:
-            raise ConstructorError("while constructing a Python module", node.start_mark,
-                    "expected the empty value, but found %r" % value.encode('utf-8'),
-                    node.start_mark)
-        return self.find_python_module(suffix, node.start_mark)
-
-    class classobj: pass
-
-    def make_python_instance(self, suffix, node,
+        module = sys.modules[module_name] 
+        if not hasattr(module, object_name): 
+            raise ConstructorError("while constructing a Python object", mark, 
+                    "cannot find %r in the module %r" % (object_name.encode('utf-8'), 
+                        module.__name__), mark) 
+        return getattr(module, object_name) 
+ 
+    def construct_python_name(self, suffix, node): 
+        value = self.construct_scalar(node) 
+        if value: 
+            raise ConstructorError("while constructing a Python name", node.start_mark, 
+                    "expected the empty value, but found %r" % value.encode('utf-8'), 
+                    node.start_mark) 
+        return self.find_python_name(suffix, node.start_mark) 
+ 
+    def construct_python_module(self, suffix, node): 
+        value = self.construct_scalar(node) 
+        if value: 
+            raise ConstructorError("while constructing a Python module", node.start_mark, 
+                    "expected the empty value, but found %r" % value.encode('utf-8'), 
+                    node.start_mark) 
+        return self.find_python_module(suffix, node.start_mark) 
+ 
+    class classobj: pass 
+ 
+    def make_python_instance(self, suffix, node, 
             args=None, kwds=None, newobj=False, unsafe=False):
-        if not args:
-            args = []
-        if not kwds:
-            kwds = {}
-        cls = self.find_python_name(suffix, node.start_mark)
+        if not args: 
+            args = [] 
+        if not kwds: 
+            kwds = {} 
+        cls = self.find_python_name(suffix, node.start_mark) 
         if not (unsafe or isinstance(cls, type) or isinstance(cls, type(self.classobj))):
             raise ConstructorError("while constructing a Python instance", node.start_mark,
                     "expected a class, but found %r" % type(cls),
                     node.start_mark)
-        if newobj and isinstance(cls, type(self.classobj))  \
-                and not args and not kwds:
-            instance = self.classobj()
-            instance.__class__ = cls
-            return instance
-        elif newobj and isinstance(cls, type):
-            return cls.__new__(cls, *args, **kwds)
-        else:
-            return cls(*args, **kwds)
-
+        if newobj and isinstance(cls, type(self.classobj))  \ 
+                and not args and not kwds: 
+            instance = self.classobj() 
+            instance.__class__ = cls 
+            return instance 
+        elif newobj and isinstance(cls, type): 
+            return cls.__new__(cls, *args, **kwds) 
+        else: 
+            return cls(*args, **kwds) 
+ 
     def set_python_instance_state(self, instance, state, unsafe=False):
-        if hasattr(instance, '__setstate__'):
-            instance.__setstate__(state)
-        else:
-            slotstate = {}
-            if isinstance(state, tuple) and len(state) == 2:
-                state, slotstate = state
-            if hasattr(instance, '__dict__'):
+        if hasattr(instance, '__setstate__'): 
+            instance.__setstate__(state) 
+        else: 
+            slotstate = {} 
+            if isinstance(state, tuple) and len(state) == 2: 
+                state, slotstate = state 
+            if hasattr(instance, '__dict__'): 
                 if not unsafe and state:
                     for key in state.keys():
                         self.check_state_key(key)
-                instance.__dict__.update(state)
-            elif state:
-                slotstate.update(state)
-            for key, value in slotstate.items():
+                instance.__dict__.update(state) 
+            elif state: 
+                slotstate.update(state) 
+            for key, value in slotstate.items(): 
                 if not unsafe:
                     self.check_state_key(key)
                 setattr(instance, key, value)
-
-    def construct_python_object(self, suffix, node):
-        # Format:
-        #   !!python/object:module.name { ... state ... }
-        instance = self.make_python_instance(suffix, node, newobj=True)
-        yield instance
-        deep = hasattr(instance, '__setstate__')
-        state = self.construct_mapping(node, deep=deep)
-        self.set_python_instance_state(instance, state)
-
-    def construct_python_object_apply(self, suffix, node, newobj=False):
-        # Format:
-        #   !!python/object/apply       # (or !!python/object/new)
-        #   args: [ ... arguments ... ]
-        #   kwds: { ... keywords ... }
-        #   state: ... state ...
-        #   listitems: [ ... listitems ... ]
-        #   dictitems: { ... dictitems ... }
-        # or short format:
-        #   !!python/object/apply [ ... arguments ... ]
-        # The difference between !!python/object/apply and !!python/object/new
-        # is how an object is created, check make_python_instance for details.
-        if isinstance(node, SequenceNode):
-            args = self.construct_sequence(node, deep=True)
-            kwds = {}
-            state = {}
-            listitems = []
-            dictitems = {}
-        else:
-            value = self.construct_mapping(node, deep=True)
-            args = value.get('args', [])
-            kwds = value.get('kwds', {})
-            state = value.get('state', {})
-            listitems = value.get('listitems', [])
-            dictitems = value.get('dictitems', {})
-        instance = self.make_python_instance(suffix, node, args, kwds, newobj)
-        if state:
-            self.set_python_instance_state(instance, state)
-        if listitems:
-            instance.extend(listitems)
-        if dictitems:
-            for key in dictitems:
-                instance[key] = dictitems[key]
-        return instance
-
-    def construct_python_object_new(self, suffix, node):
-        return self.construct_python_object_apply(suffix, node, newobj=True)
-
+ 
+    def construct_python_object(self, suffix, node): 
+        # Format: 
+        #   !!python/object:module.name { ... state ... } 
+        instance = self.make_python_instance(suffix, node, newobj=True) 
+        yield instance 
+        deep = hasattr(instance, '__setstate__') 
+        state = self.construct_mapping(node, deep=deep) 
+        self.set_python_instance_state(instance, state) 
+ 
+    def construct_python_object_apply(self, suffix, node, newobj=False): 
+        # Format: 
+        #   !!python/object/apply       # (or !!python/object/new) 
+        #   args: [ ... arguments ... ] 
+        #   kwds: { ... keywords ... } 
+        #   state: ... state ... 
+        #   listitems: [ ... listitems ... ] 
+        #   dictitems: { ... dictitems ... } 
+        # or short format: 
+        #   !!python/object/apply [ ... arguments ... ] 
+        # The difference between !!python/object/apply and !!python/object/new 
+        # is how an object is created, check make_python_instance for details. 
+        if isinstance(node, SequenceNode): 
+            args = self.construct_sequence(node, deep=True) 
+            kwds = {} 
+            state = {} 
+            listitems = [] 
+            dictitems = {} 
+        else: 
+            value = self.construct_mapping(node, deep=True) 
+            args = value.get('args', []) 
+            kwds = value.get('kwds', {}) 
+            state = value.get('state', {}) 
+            listitems = value.get('listitems', []) 
+            dictitems = value.get('dictitems', {}) 
+        instance = self.make_python_instance(suffix, node, args, kwds, newobj) 
+        if state: 
+            self.set_python_instance_state(instance, state) 
+        if listitems: 
+            instance.extend(listitems) 
+        if dictitems: 
+            for key in dictitems: 
+                instance[key] = dictitems[key] 
+        return instance 
+ 
+    def construct_python_object_new(self, suffix, node): 
+        return self.construct_python_object_apply(suffix, node, newobj=True) 
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/none',
+    u'tag:yaml.org,2002:python/none', 
     FullConstructor.construct_yaml_null)
-
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/bool',
+    u'tag:yaml.org,2002:python/bool', 
     FullConstructor.construct_yaml_bool)
-
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/str',
+    u'tag:yaml.org,2002:python/str', 
     FullConstructor.construct_python_str)
-
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/unicode',
+    u'tag:yaml.org,2002:python/unicode', 
     FullConstructor.construct_python_unicode)
-
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/int',
+    u'tag:yaml.org,2002:python/int', 
     FullConstructor.construct_yaml_int)
-
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/long',
+    u'tag:yaml.org,2002:python/long', 
     FullConstructor.construct_python_long)
-
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/float',
+    u'tag:yaml.org,2002:python/float', 
     FullConstructor.construct_yaml_float)
-
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/complex',
+    u'tag:yaml.org,2002:python/complex', 
     FullConstructor.construct_python_complex)
-
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/list',
+    u'tag:yaml.org,2002:python/list', 
     FullConstructor.construct_yaml_seq)
-
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/tuple',
+    u'tag:yaml.org,2002:python/tuple', 
     FullConstructor.construct_python_tuple)
-
+ 
 FullConstructor.add_constructor(
-    u'tag:yaml.org,2002:python/dict',
+    u'tag:yaml.org,2002:python/dict', 
     FullConstructor.construct_yaml_map)
-
+ 
 FullConstructor.add_multi_constructor(
-    u'tag:yaml.org,2002:python/name:',
+    u'tag:yaml.org,2002:python/name:', 
     FullConstructor.construct_python_name)
-
+ 
 class UnsafeConstructor(FullConstructor):
 
     def find_python_module(self, name, mark):