From 0b03e27032bc8722cedcfa22f17311cc7594ecfa Mon Sep 17 00:00:00 2001
From: Labrys of Knossos <Labrys.git@gmail.com>
Date: Mon, 17 Dec 2018 20:52:16 -0500
Subject: [PATCH] Add pyyaml version 3.13 to Python 2 requirements

---
 libs/py2/_yaml.pyd           |  Bin 0 -> 225280 bytes
 libs/py2/yaml/__init__.py    |  315 ++++++++
 libs/py2/yaml/composer.py    |  139 ++++
 libs/py2/yaml/constructor.py |  675 ++++++++++++++++
 libs/py2/yaml/cyaml.py       |   85 ++
 libs/py2/yaml/dumper.py      |   62 ++
 libs/py2/yaml/emitter.py     | 1140 ++++++++++++++++++++++++++
 libs/py2/yaml/error.py       |   75 ++
 libs/py2/yaml/events.py      |   86 ++
 libs/py2/yaml/loader.py      |   40 +
 libs/py2/yaml/nodes.py       |   49 ++
 libs/py2/yaml/parser.py      |  589 ++++++++++++++
 libs/py2/yaml/reader.py      |  190 +++++
 libs/py2/yaml/representer.py |  486 ++++++++++++
 libs/py2/yaml/resolver.py    |  227 ++++++
 libs/py2/yaml/scanner.py     | 1453 ++++++++++++++++++++++++++++++++++
 libs/py2/yaml/serializer.py  |  111 +++
 libs/py2/yaml/tokens.py      |  104 +++
 libs/requirements-py2.txt    |    1 +
 19 files changed, 5827 insertions(+)
 create mode 100644 libs/py2/_yaml.pyd
 create mode 100644 libs/py2/yaml/__init__.py
 create mode 100644 libs/py2/yaml/composer.py
 create mode 100644 libs/py2/yaml/constructor.py
 create mode 100644 libs/py2/yaml/cyaml.py
 create mode 100644 libs/py2/yaml/dumper.py
 create mode 100644 libs/py2/yaml/emitter.py
 create mode 100644 libs/py2/yaml/error.py
 create mode 100644 libs/py2/yaml/events.py
 create mode 100644 libs/py2/yaml/loader.py
 create mode 100644 libs/py2/yaml/nodes.py
 create mode 100644 libs/py2/yaml/parser.py
 create mode 100644 libs/py2/yaml/reader.py
 create mode 100644 libs/py2/yaml/representer.py
 create mode 100644 libs/py2/yaml/resolver.py
 create mode 100644 libs/py2/yaml/scanner.py
 create mode 100644 libs/py2/yaml/serializer.py
 create mode 100644 libs/py2/yaml/tokens.py

diff --git a/libs/py2/_yaml.pyd b/libs/py2/_yaml.pyd
new file mode 100644
index 0000000000000000000000000000000000000000..3a505435678d4aa2689eef98b59417a2e217d8be
GIT binary patch
literal 225280
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

literal 0
HcmV?d00001

diff --git a/libs/py2/yaml/__init__.py b/libs/py2/yaml/__init__.py
new file mode 100644
index 00000000..25d03d6e
--- /dev/null
+++ b/libs/py2/yaml/__init__.py
@@ -0,0 +1,315 @@
+
+from error import *
+
+from tokens import *
+from events import *
+from nodes import *
+
+from loader import *
+from dumper import *
+
+__version__ = '3.13'
+
+try:
+    from cyaml import *
+    __with_libyaml__ = True
+except ImportError:
+    __with_libyaml__ = False
+
+def scan(stream, Loader=Loader):
+    """
+    Scan a YAML stream and produce scanning tokens.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_token():
+            yield loader.get_token()
+    finally:
+        loader.dispose()
+
+def parse(stream, Loader=Loader):
+    """
+    Parse a YAML stream and produce parsing events.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_event():
+            yield loader.get_event()
+    finally:
+        loader.dispose()
+
+def compose(stream, Loader=Loader):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding representation tree.
+    """
+    loader = Loader(stream)
+    try:
+        return loader.get_single_node()
+    finally:
+        loader.dispose()
+
+def compose_all(stream, Loader=Loader):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding representation trees.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_node():
+            yield loader.get_node()
+    finally:
+        loader.dispose()
+
+def load(stream, Loader=Loader):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+    """
+    loader = Loader(stream)
+    try:
+        return loader.get_single_data()
+    finally:
+        loader.dispose()
+
+def load_all(stream, Loader=Loader):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+    """
+    loader = Loader(stream)
+    try:
+        while loader.check_data():
+            yield loader.get_data()
+    finally:
+        loader.dispose()
+
+def safe_load(stream):
+    """
+    Parse the first YAML document in a stream
+    and produce the corresponding Python object.
+    Resolve only basic YAML tags.
+    """
+    return load(stream, SafeLoader)
+
+def safe_load_all(stream):
+    """
+    Parse all YAML documents in a stream
+    and produce corresponding Python objects.
+    Resolve only basic YAML tags.
+    """
+    return load_all(stream, SafeLoader)
+
+def emit(events, stream=None, Dumper=Dumper,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None):
+    """
+    Emit YAML parsing events into a stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        from StringIO import StringIO
+        stream = StringIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break)
+    try:
+        for event in events:
+            dumper.emit(event)
+    finally:
+        dumper.dispose()
+    if getvalue:
+        return getvalue()
+
+def serialize_all(nodes, stream=None, Dumper=Dumper,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None,
+        encoding='utf-8', explicit_start=None, explicit_end=None,
+        version=None, tags=None):
+    """
+    Serialize a sequence of representation trees into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        if encoding is None:
+            from StringIO import StringIO
+        else:
+            from cStringIO import StringIO
+        stream = StringIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break,
+            encoding=encoding, version=version, tags=tags,
+            explicit_start=explicit_start, explicit_end=explicit_end)
+    try:
+        dumper.open()
+        for node in nodes:
+            dumper.serialize(node)
+        dumper.close()
+    finally:
+        dumper.dispose()
+    if getvalue:
+        return getvalue()
+
+def serialize(node, stream=None, Dumper=Dumper, **kwds):
+    """
+    Serialize a representation tree into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    return serialize_all([node], stream, Dumper=Dumper, **kwds)
+
+def dump_all(documents, stream=None, Dumper=Dumper,
+        default_style=None, default_flow_style=None,
+        canonical=None, indent=None, width=None,
+        allow_unicode=None, line_break=None,
+        encoding='utf-8', explicit_start=None, explicit_end=None,
+        version=None, tags=None):
+    """
+    Serialize a sequence of Python objects into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    getvalue = None
+    if stream is None:
+        if encoding is None:
+            from StringIO import StringIO
+        else:
+            from cStringIO import StringIO
+        stream = StringIO()
+        getvalue = stream.getvalue
+    dumper = Dumper(stream, default_style=default_style,
+            default_flow_style=default_flow_style,
+            canonical=canonical, indent=indent, width=width,
+            allow_unicode=allow_unicode, line_break=line_break,
+            encoding=encoding, version=version, tags=tags,
+            explicit_start=explicit_start, explicit_end=explicit_end)
+    try:
+        dumper.open()
+        for data in documents:
+            dumper.represent(data)
+        dumper.close()
+    finally:
+        dumper.dispose()
+    if getvalue:
+        return getvalue()
+
+def dump(data, stream=None, Dumper=Dumper, **kwds):
+    """
+    Serialize a Python object into a YAML stream.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all([data], stream, Dumper=Dumper, **kwds)
+
+def safe_dump_all(documents, stream=None, **kwds):
+    """
+    Serialize a sequence of Python objects into a YAML stream.
+    Produce only basic YAML tags.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all(documents, stream, Dumper=SafeDumper, **kwds)
+
+def safe_dump(data, stream=None, **kwds):
+    """
+    Serialize a Python object into a YAML stream.
+    Produce only basic YAML tags.
+    If stream is None, return the produced string instead.
+    """
+    return dump_all([data], stream, Dumper=SafeDumper, **kwds)
+
+def add_implicit_resolver(tag, regexp, first=None,
+        Loader=Loader, Dumper=Dumper):
+    """
+    Add an implicit scalar detector.
+    If an implicit scalar value matches the given regexp,
+    the corresponding tag is assigned to the scalar.
+    first is a sequence of possible initial characters or None.
+    """
+    Loader.add_implicit_resolver(tag, regexp, first)
+    Dumper.add_implicit_resolver(tag, regexp, first)
+
+def add_path_resolver(tag, path, kind=None, Loader=Loader, Dumper=Dumper):
+    """
+    Add a path based resolver for the given tag.
+    A path is a list of keys that forms a path
+    to a node in the representation tree.
+    Keys can be string values, integers, or None.
+    """
+    Loader.add_path_resolver(tag, path, kind)
+    Dumper.add_path_resolver(tag, path, kind)
+
+def add_constructor(tag, constructor, Loader=Loader):
+    """
+    Add a constructor for the given tag.
+    Constructor is a function that accepts a Loader instance
+    and a node object and produces the corresponding Python object.
+    """
+    Loader.add_constructor(tag, constructor)
+
+def add_multi_constructor(tag_prefix, multi_constructor, Loader=Loader):
+    """
+    Add a multi-constructor for the given tag prefix.
+    Multi-constructor is called for a node if its tag starts with tag_prefix.
+    Multi-constructor accepts a Loader instance, a tag suffix,
+    and a node object and produces the corresponding Python object.
+    """
+    Loader.add_multi_constructor(tag_prefix, multi_constructor)
+
+def add_representer(data_type, representer, Dumper=Dumper):
+    """
+    Add a representer for the given type.
+    Representer is a function accepting a Dumper instance
+    and an instance of the given data type
+    and producing the corresponding representation node.
+    """
+    Dumper.add_representer(data_type, representer)
+
+def add_multi_representer(data_type, multi_representer, Dumper=Dumper):
+    """
+    Add a representer for the given type.
+    Multi-representer is a function accepting a Dumper instance
+    and an instance of the given data type or subtype
+    and producing the corresponding representation node.
+    """
+    Dumper.add_multi_representer(data_type, multi_representer)
+
+class YAMLObjectMetaclass(type):
+    """
+    The metaclass for YAMLObject.
+    """
+    def __init__(cls, name, bases, kwds):
+        super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)
+        if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None:
+            cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)
+            cls.yaml_dumper.add_representer(cls, cls.to_yaml)
+
+class YAMLObject(object):
+    """
+    An object that can dump itself to a YAML stream
+    and load itself from a YAML stream.
+    """
+
+    __metaclass__ = YAMLObjectMetaclass
+    __slots__ = ()  # no direct instantiation, so allow immutable subclasses
+
+    yaml_loader = Loader
+    yaml_dumper = Dumper
+
+    yaml_tag = None
+    yaml_flow_style = None
+
+    def from_yaml(cls, loader, node):
+        """
+        Convert a representation node to a Python object.
+        """
+        return loader.construct_yaml_object(node, cls)
+    from_yaml = classmethod(from_yaml)
+
+    def to_yaml(cls, dumper, data):
+        """
+        Convert a Python object to a representation node.
+        """
+        return dumper.represent_yaml_object(cls.yaml_tag, data, cls,
+                flow_style=cls.yaml_flow_style)
+    to_yaml = classmethod(to_yaml)
+
diff --git a/libs/py2/yaml/composer.py b/libs/py2/yaml/composer.py
new file mode 100644
index 00000000..06e5ac78
--- /dev/null
+++ b/libs/py2/yaml/composer.py
@@ -0,0 +1,139 @@
+
+__all__ = ['Composer', 'ComposerError']
+
+from error import MarkedYAMLError
+from events import *
+from nodes import *
+
+class ComposerError(MarkedYAMLError):
+    pass
+
+class Composer(object):
+
+    def __init__(self):
+        self.anchors = {}
+
+    def check_node(self):
+        # Drop the STREAM-START event.
+        if self.check_event(StreamStartEvent):
+            self.get_event()
+
+        # If there are more documents available?
+        return not self.check_event(StreamEndEvent)
+
+    def get_node(self):
+        # Get the root node of the next document.
+        if not self.check_event(StreamEndEvent):
+            return self.compose_document()
+
+    def get_single_node(self):
+        # Drop the STREAM-START event.
+        self.get_event()
+
+        # Compose a document if the stream is not empty.
+        document = None
+        if not self.check_event(StreamEndEvent):
+            document = self.compose_document()
+
+        # Ensure that the stream contains no more documents.
+        if not self.check_event(StreamEndEvent):
+            event = self.get_event()
+            raise ComposerError("expected a single document in the stream",
+                    document.start_mark, "but found another document",
+                    event.start_mark)
+
+        # Drop the STREAM-END event.
+        self.get_event()
+
+        return document
+
+    def compose_document(self):
+        # Drop the DOCUMENT-START event.
+        self.get_event()
+
+        # Compose the root node.
+        node = self.compose_node(None, None)
+
+        # Drop the DOCUMENT-END event.
+        self.get_event()
+
+        self.anchors = {}
+        return node
+
+    def compose_node(self, parent, index):
+        if self.check_event(AliasEvent):
+            event = self.get_event()
+            anchor = event.anchor
+            if anchor not in self.anchors:
+                raise ComposerError(None, None, "found undefined alias %r"
+                        % anchor.encode('utf-8'), event.start_mark)
+            return self.anchors[anchor]
+        event = self.peek_event()
+        anchor = event.anchor
+        if anchor is not None:
+            if anchor in self.anchors:
+                raise ComposerError("found duplicate anchor %r; first occurence"
+                        % anchor.encode('utf-8'), self.anchors[anchor].start_mark,
+                        "second occurence", event.start_mark)
+        self.descend_resolver(parent, index)
+        if self.check_event(ScalarEvent):
+            node = self.compose_scalar_node(anchor)
+        elif self.check_event(SequenceStartEvent):
+            node = self.compose_sequence_node(anchor)
+        elif self.check_event(MappingStartEvent):
+            node = self.compose_mapping_node(anchor)
+        self.ascend_resolver()
+        return node
+
+    def compose_scalar_node(self, anchor):
+        event = self.get_event()
+        tag = event.tag
+        if tag is None or tag == u'!':
+            tag = self.resolve(ScalarNode, event.value, event.implicit)
+        node = ScalarNode(tag, event.value,
+                event.start_mark, event.end_mark, style=event.style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        return node
+
+    def compose_sequence_node(self, anchor):
+        start_event = self.get_event()
+        tag = start_event.tag
+        if tag is None or tag == u'!':
+            tag = self.resolve(SequenceNode, None, start_event.implicit)
+        node = SequenceNode(tag, [],
+                start_event.start_mark, None,
+                flow_style=start_event.flow_style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        index = 0
+        while not self.check_event(SequenceEndEvent):
+            node.value.append(self.compose_node(node, index))
+            index += 1
+        end_event = self.get_event()
+        node.end_mark = end_event.end_mark
+        return node
+
+    def compose_mapping_node(self, anchor):
+        start_event = self.get_event()
+        tag = start_event.tag
+        if tag is None or tag == u'!':
+            tag = self.resolve(MappingNode, None, start_event.implicit)
+        node = MappingNode(tag, [],
+                start_event.start_mark, None,
+                flow_style=start_event.flow_style)
+        if anchor is not None:
+            self.anchors[anchor] = node
+        while not self.check_event(MappingEndEvent):
+            #key_event = self.peek_event()
+            item_key = self.compose_node(node, None)
+            #if item_key in node.value:
+            #    raise ComposerError("while composing a mapping", start_event.start_mark,
+            #            "found duplicate key", key_event.start_mark)
+            item_value = self.compose_node(node, item_key)
+            #node.value[item_key] = item_value
+            node.value.append((item_key, item_value))
+        end_event = self.get_event()
+        node.end_mark = end_event.end_mark
+        return node
+
diff --git a/libs/py2/yaml/constructor.py b/libs/py2/yaml/constructor.py
new file mode 100644
index 00000000..635faac3
--- /dev/null
+++ b/libs/py2/yaml/constructor.py
@@ -0,0 +1,675 @@
+
+__all__ = ['BaseConstructor', 'SafeConstructor', 'Constructor',
+    'ConstructorError']
+
+from error import *
+from nodes import *
+
+import datetime
+
+import binascii, re, sys, types
+
+class ConstructorError(MarkedYAMLError):
+    pass
+
+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 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 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,
+                    "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
+        if values['fraction']:
+            fraction = values['fraction'][:6]
+            while len(fraction) < 6:
+                fraction += '0'
+            fraction = int(fraction)
+        delta = None
+        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
+        data = datetime.datetime(year, month, day, hour, minute, second, fraction)
+        if delta:
+            data -= delta
+        return data
+
+    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 Constructor(SafeConstructor):
+
+    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):
+        if not name:
+            raise ConstructorError("while constructing a Python module", mark,
+                    "expected non-empty name appended to the tag", mark)
+        try:
+            __import__(name)
+        except ImportError, exc:
+            raise ConstructorError("while constructing a Python module", mark,
+                    "cannot find module %r (%s)" % (name.encode('utf-8'), exc), mark)
+        return sys.modules[name]
+
+    def find_python_name(self, name, mark):
+        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
+        try:
+            __import__(module_name)
+        except ImportError, exc:
+            raise ConstructorError("while constructing a Python object", mark,
+                    "cannot find module %r (%s)" % (module_name.encode('utf-8'), exc), 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,
+            args=None, kwds=None, newobj=False):
+        if not args:
+            args = []
+        if not kwds:
+            kwds = {}
+        cls = self.find_python_name(suffix, 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)
+
+    def set_python_instance_state(self, instance, state):
+        if hasattr(instance, '__setstate__'):
+            instance.__setstate__(state)
+        else:
+            slotstate = {}
+            if isinstance(state, tuple) and len(state) == 2:
+                state, slotstate = state
+            if hasattr(instance, '__dict__'):
+                instance.__dict__.update(state)
+            elif state:
+                slotstate.update(state)
+            for key, value in slotstate.items():
+                setattr(object, 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)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/none',
+    Constructor.construct_yaml_null)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/bool',
+    Constructor.construct_yaml_bool)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/str',
+    Constructor.construct_python_str)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/unicode',
+    Constructor.construct_python_unicode)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/int',
+    Constructor.construct_yaml_int)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/long',
+    Constructor.construct_python_long)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/float',
+    Constructor.construct_yaml_float)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/complex',
+    Constructor.construct_python_complex)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/list',
+    Constructor.construct_yaml_seq)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/tuple',
+    Constructor.construct_python_tuple)
+
+Constructor.add_constructor(
+    u'tag:yaml.org,2002:python/dict',
+    Constructor.construct_yaml_map)
+
+Constructor.add_multi_constructor(
+    u'tag:yaml.org,2002:python/name:',
+    Constructor.construct_python_name)
+
+Constructor.add_multi_constructor(
+    u'tag:yaml.org,2002:python/module:',
+    Constructor.construct_python_module)
+
+Constructor.add_multi_constructor(
+    u'tag:yaml.org,2002:python/object:',
+    Constructor.construct_python_object)
+
+Constructor.add_multi_constructor(
+    u'tag:yaml.org,2002:python/object/apply:',
+    Constructor.construct_python_object_apply)
+
+Constructor.add_multi_constructor(
+    u'tag:yaml.org,2002:python/object/new:',
+    Constructor.construct_python_object_new)
+
diff --git a/libs/py2/yaml/cyaml.py b/libs/py2/yaml/cyaml.py
new file mode 100644
index 00000000..68dcd751
--- /dev/null
+++ b/libs/py2/yaml/cyaml.py
@@ -0,0 +1,85 @@
+
+__all__ = ['CBaseLoader', 'CSafeLoader', 'CLoader',
+        'CBaseDumper', 'CSafeDumper', 'CDumper']
+
+from _yaml import CParser, CEmitter
+
+from constructor import *
+
+from serializer import *
+from representer import *
+
+from resolver import *
+
+class CBaseLoader(CParser, BaseConstructor, BaseResolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        BaseConstructor.__init__(self)
+        BaseResolver.__init__(self)
+
+class CSafeLoader(CParser, SafeConstructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        SafeConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class CLoader(CParser, Constructor, Resolver):
+
+    def __init__(self, stream):
+        CParser.__init__(self, stream)
+        Constructor.__init__(self)
+        Resolver.__init__(self)
+
+class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
+class CSafeDumper(CEmitter, SafeRepresenter, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        SafeRepresenter.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
+class CDumper(CEmitter, Serializer, Representer, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        CEmitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width, encoding=encoding,
+                allow_unicode=allow_unicode, line_break=line_break,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
diff --git a/libs/py2/yaml/dumper.py b/libs/py2/yaml/dumper.py
new file mode 100644
index 00000000..f811d2c9
--- /dev/null
+++ b/libs/py2/yaml/dumper.py
@@ -0,0 +1,62 @@
+
+__all__ = ['BaseDumper', 'SafeDumper', 'Dumper']
+
+from emitter import *
+from serializer import *
+from representer import *
+from resolver import *
+
+class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
+class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        SafeRepresenter.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
+class Dumper(Emitter, Serializer, Representer, Resolver):
+
+    def __init__(self, stream,
+            default_style=None, default_flow_style=None,
+            canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None,
+            encoding=None, explicit_start=None, explicit_end=None,
+            version=None, tags=None):
+        Emitter.__init__(self, stream, canonical=canonical,
+                indent=indent, width=width,
+                allow_unicode=allow_unicode, line_break=line_break)
+        Serializer.__init__(self, encoding=encoding,
+                explicit_start=explicit_start, explicit_end=explicit_end,
+                version=version, tags=tags)
+        Representer.__init__(self, default_style=default_style,
+                default_flow_style=default_flow_style)
+        Resolver.__init__(self)
+
diff --git a/libs/py2/yaml/emitter.py b/libs/py2/yaml/emitter.py
new file mode 100644
index 00000000..e5bcdccc
--- /dev/null
+++ b/libs/py2/yaml/emitter.py
@@ -0,0 +1,1140 @@
+
+# Emitter expects events obeying the following grammar:
+# stream ::= STREAM-START document* STREAM-END
+# document ::= DOCUMENT-START node DOCUMENT-END
+# node ::= SCALAR | sequence | mapping
+# sequence ::= SEQUENCE-START node* SEQUENCE-END
+# mapping ::= MAPPING-START (node node)* MAPPING-END
+
+__all__ = ['Emitter', 'EmitterError']
+
+from error import YAMLError
+from events import *
+
+class EmitterError(YAMLError):
+    pass
+
+class ScalarAnalysis(object):
+    def __init__(self, scalar, empty, multiline,
+            allow_flow_plain, allow_block_plain,
+            allow_single_quoted, allow_double_quoted,
+            allow_block):
+        self.scalar = scalar
+        self.empty = empty
+        self.multiline = multiline
+        self.allow_flow_plain = allow_flow_plain
+        self.allow_block_plain = allow_block_plain
+        self.allow_single_quoted = allow_single_quoted
+        self.allow_double_quoted = allow_double_quoted
+        self.allow_block = allow_block
+
+class Emitter(object):
+
+    DEFAULT_TAG_PREFIXES = {
+        u'!' : u'!',
+        u'tag:yaml.org,2002:' : u'!!',
+    }
+
+    def __init__(self, stream, canonical=None, indent=None, width=None,
+            allow_unicode=None, line_break=None):
+
+        # The stream should have the methods `write` and possibly `flush`.
+        self.stream = stream
+
+        # Encoding can be overriden by STREAM-START.
+        self.encoding = None
+
+        # Emitter is a state machine with a stack of states to handle nested
+        # structures.
+        self.states = []
+        self.state = self.expect_stream_start
+
+        # Current event and the event queue.
+        self.events = []
+        self.event = None
+
+        # The current indentation level and the stack of previous indents.
+        self.indents = []
+        self.indent = None
+
+        # Flow level.
+        self.flow_level = 0
+
+        # Contexts.
+        self.root_context = False
+        self.sequence_context = False
+        self.mapping_context = False
+        self.simple_key_context = False
+
+        # Characteristics of the last emitted character:
+        #  - current position.
+        #  - is it a whitespace?
+        #  - is it an indention character
+        #    (indentation space, '-', '?', or ':')?
+        self.line = 0
+        self.column = 0
+        self.whitespace = True
+        self.indention = True
+
+        # Whether the document requires an explicit document indicator
+        self.open_ended = False
+
+        # Formatting details.
+        self.canonical = canonical
+        self.allow_unicode = allow_unicode
+        self.best_indent = 2
+        if indent and 1 < indent < 10:
+            self.best_indent = indent
+        self.best_width = 80
+        if width and width > self.best_indent*2:
+            self.best_width = width
+        self.best_line_break = u'\n'
+        if line_break in [u'\r', u'\n', u'\r\n']:
+            self.best_line_break = line_break
+
+        # Tag prefixes.
+        self.tag_prefixes = None
+
+        # Prepared anchor and tag.
+        self.prepared_anchor = None
+        self.prepared_tag = None
+
+        # Scalar analysis and style.
+        self.analysis = None
+        self.style = None
+
+    def dispose(self):
+        # Reset the state attributes (to clear self-references)
+        self.states = []
+        self.state = None
+
+    def emit(self, event):
+        self.events.append(event)
+        while not self.need_more_events():
+            self.event = self.events.pop(0)
+            self.state()
+            self.event = None
+
+    # In some cases, we wait for a few next events before emitting.
+
+    def need_more_events(self):
+        if not self.events:
+            return True
+        event = self.events[0]
+        if isinstance(event, DocumentStartEvent):
+            return self.need_events(1)
+        elif isinstance(event, SequenceStartEvent):
+            return self.need_events(2)
+        elif isinstance(event, MappingStartEvent):
+            return self.need_events(3)
+        else:
+            return False
+
+    def need_events(self, count):
+        level = 0
+        for event in self.events[1:]:
+            if isinstance(event, (DocumentStartEvent, CollectionStartEvent)):
+                level += 1
+            elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)):
+                level -= 1
+            elif isinstance(event, StreamEndEvent):
+                level = -1
+            if level < 0:
+                return False
+        return (len(self.events) < count+1)
+
+    def increase_indent(self, flow=False, indentless=False):
+        self.indents.append(self.indent)
+        if self.indent is None:
+            if flow:
+                self.indent = self.best_indent
+            else:
+                self.indent = 0
+        elif not indentless:
+            self.indent += self.best_indent
+
+    # States.
+
+    # Stream handlers.
+
+    def expect_stream_start(self):
+        if isinstance(self.event, StreamStartEvent):
+            if self.event.encoding and not getattr(self.stream, 'encoding', None):
+                self.encoding = self.event.encoding
+            self.write_stream_start()
+            self.state = self.expect_first_document_start
+        else:
+            raise EmitterError("expected StreamStartEvent, but got %s"
+                    % self.event)
+
+    def expect_nothing(self):
+        raise EmitterError("expected nothing, but got %s" % self.event)
+
+    # Document handlers.
+
+    def expect_first_document_start(self):
+        return self.expect_document_start(first=True)
+
+    def expect_document_start(self, first=False):
+        if isinstance(self.event, DocumentStartEvent):
+            if (self.event.version or self.event.tags) and self.open_ended:
+                self.write_indicator(u'...', True)
+                self.write_indent()
+            if self.event.version:
+                version_text = self.prepare_version(self.event.version)
+                self.write_version_directive(version_text)
+            self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy()
+            if self.event.tags:
+                handles = self.event.tags.keys()
+                handles.sort()
+                for handle in handles:
+                    prefix = self.event.tags[handle]
+                    self.tag_prefixes[prefix] = handle
+                    handle_text = self.prepare_tag_handle(handle)
+                    prefix_text = self.prepare_tag_prefix(prefix)
+                    self.write_tag_directive(handle_text, prefix_text)
+            implicit = (first and not self.event.explicit and not self.canonical
+                    and not self.event.version and not self.event.tags
+                    and not self.check_empty_document())
+            if not implicit:
+                self.write_indent()
+                self.write_indicator(u'---', True)
+                if self.canonical:
+                    self.write_indent()
+            self.state = self.expect_document_root
+        elif isinstance(self.event, StreamEndEvent):
+            if self.open_ended:
+                self.write_indicator(u'...', True)
+                self.write_indent()
+            self.write_stream_end()
+            self.state = self.expect_nothing
+        else:
+            raise EmitterError("expected DocumentStartEvent, but got %s"
+                    % self.event)
+
+    def expect_document_end(self):
+        if isinstance(self.event, DocumentEndEvent):
+            self.write_indent()
+            if self.event.explicit:
+                self.write_indicator(u'...', True)
+                self.write_indent()
+            self.flush_stream()
+            self.state = self.expect_document_start
+        else:
+            raise EmitterError("expected DocumentEndEvent, but got %s"
+                    % self.event)
+
+    def expect_document_root(self):
+        self.states.append(self.expect_document_end)
+        self.expect_node(root=True)
+
+    # Node handlers.
+
+    def expect_node(self, root=False, sequence=False, mapping=False,
+            simple_key=False):
+        self.root_context = root
+        self.sequence_context = sequence
+        self.mapping_context = mapping
+        self.simple_key_context = simple_key
+        if isinstance(self.event, AliasEvent):
+            self.expect_alias()
+        elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)):
+            self.process_anchor(u'&')
+            self.process_tag()
+            if isinstance(self.event, ScalarEvent):
+                self.expect_scalar()
+            elif isinstance(self.event, SequenceStartEvent):
+                if self.flow_level or self.canonical or self.event.flow_style   \
+                        or self.check_empty_sequence():
+                    self.expect_flow_sequence()
+                else:
+                    self.expect_block_sequence()
+            elif isinstance(self.event, MappingStartEvent):
+                if self.flow_level or self.canonical or self.event.flow_style   \
+                        or self.check_empty_mapping():
+                    self.expect_flow_mapping()
+                else:
+                    self.expect_block_mapping()
+        else:
+            raise EmitterError("expected NodeEvent, but got %s" % self.event)
+
+    def expect_alias(self):
+        if self.event.anchor is None:
+            raise EmitterError("anchor is not specified for alias")
+        self.process_anchor(u'*')
+        self.state = self.states.pop()
+
+    def expect_scalar(self):
+        self.increase_indent(flow=True)
+        self.process_scalar()
+        self.indent = self.indents.pop()
+        self.state = self.states.pop()
+
+    # Flow sequence handlers.
+
+    def expect_flow_sequence(self):
+        self.write_indicator(u'[', True, whitespace=True)
+        self.flow_level += 1
+        self.increase_indent(flow=True)
+        self.state = self.expect_first_flow_sequence_item
+
+    def expect_first_flow_sequence_item(self):
+        if isinstance(self.event, SequenceEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            self.write_indicator(u']', False)
+            self.state = self.states.pop()
+        else:
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            self.states.append(self.expect_flow_sequence_item)
+            self.expect_node(sequence=True)
+
+    def expect_flow_sequence_item(self):
+        if isinstance(self.event, SequenceEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            if self.canonical:
+                self.write_indicator(u',', False)
+                self.write_indent()
+            self.write_indicator(u']', False)
+            self.state = self.states.pop()
+        else:
+            self.write_indicator(u',', False)
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            self.states.append(self.expect_flow_sequence_item)
+            self.expect_node(sequence=True)
+
+    # Flow mapping handlers.
+
+    def expect_flow_mapping(self):
+        self.write_indicator(u'{', True, whitespace=True)
+        self.flow_level += 1
+        self.increase_indent(flow=True)
+        self.state = self.expect_first_flow_mapping_key
+
+    def expect_first_flow_mapping_key(self):
+        if isinstance(self.event, MappingEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            self.write_indicator(u'}', False)
+            self.state = self.states.pop()
+        else:
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            if not self.canonical and self.check_simple_key():
+                self.states.append(self.expect_flow_mapping_simple_value)
+                self.expect_node(mapping=True, simple_key=True)
+            else:
+                self.write_indicator(u'?', True)
+                self.states.append(self.expect_flow_mapping_value)
+                self.expect_node(mapping=True)
+
+    def expect_flow_mapping_key(self):
+        if isinstance(self.event, MappingEndEvent):
+            self.indent = self.indents.pop()
+            self.flow_level -= 1
+            if self.canonical:
+                self.write_indicator(u',', False)
+                self.write_indent()
+            self.write_indicator(u'}', False)
+            self.state = self.states.pop()
+        else:
+            self.write_indicator(u',', False)
+            if self.canonical or self.column > self.best_width:
+                self.write_indent()
+            if not self.canonical and self.check_simple_key():
+                self.states.append(self.expect_flow_mapping_simple_value)
+                self.expect_node(mapping=True, simple_key=True)
+            else:
+                self.write_indicator(u'?', True)
+                self.states.append(self.expect_flow_mapping_value)
+                self.expect_node(mapping=True)
+
+    def expect_flow_mapping_simple_value(self):
+        self.write_indicator(u':', False)
+        self.states.append(self.expect_flow_mapping_key)
+        self.expect_node(mapping=True)
+
+    def expect_flow_mapping_value(self):
+        if self.canonical or self.column > self.best_width:
+            self.write_indent()
+        self.write_indicator(u':', True)
+        self.states.append(self.expect_flow_mapping_key)
+        self.expect_node(mapping=True)
+
+    # Block sequence handlers.
+
+    def expect_block_sequence(self):
+        indentless = (self.mapping_context and not self.indention)
+        self.increase_indent(flow=False, indentless=indentless)
+        self.state = self.expect_first_block_sequence_item
+
+    def expect_first_block_sequence_item(self):
+        return self.expect_block_sequence_item(first=True)
+
+    def expect_block_sequence_item(self, first=False):
+        if not first and isinstance(self.event, SequenceEndEvent):
+            self.indent = self.indents.pop()
+            self.state = self.states.pop()
+        else:
+            self.write_indent()
+            self.write_indicator(u'-', True, indention=True)
+            self.states.append(self.expect_block_sequence_item)
+            self.expect_node(sequence=True)
+
+    # Block mapping handlers.
+
+    def expect_block_mapping(self):
+        self.increase_indent(flow=False)
+        self.state = self.expect_first_block_mapping_key
+
+    def expect_first_block_mapping_key(self):
+        return self.expect_block_mapping_key(first=True)
+
+    def expect_block_mapping_key(self, first=False):
+        if not first and isinstance(self.event, MappingEndEvent):
+            self.indent = self.indents.pop()
+            self.state = self.states.pop()
+        else:
+            self.write_indent()
+            if self.check_simple_key():
+                self.states.append(self.expect_block_mapping_simple_value)
+                self.expect_node(mapping=True, simple_key=True)
+            else:
+                self.write_indicator(u'?', True, indention=True)
+                self.states.append(self.expect_block_mapping_value)
+                self.expect_node(mapping=True)
+
+    def expect_block_mapping_simple_value(self):
+        self.write_indicator(u':', False)
+        self.states.append(self.expect_block_mapping_key)
+        self.expect_node(mapping=True)
+
+    def expect_block_mapping_value(self):
+        self.write_indent()
+        self.write_indicator(u':', True, indention=True)
+        self.states.append(self.expect_block_mapping_key)
+        self.expect_node(mapping=True)
+
+    # Checkers.
+
+    def check_empty_sequence(self):
+        return (isinstance(self.event, SequenceStartEvent) and self.events
+                and isinstance(self.events[0], SequenceEndEvent))
+
+    def check_empty_mapping(self):
+        return (isinstance(self.event, MappingStartEvent) and self.events
+                and isinstance(self.events[0], MappingEndEvent))
+
+    def check_empty_document(self):
+        if not isinstance(self.event, DocumentStartEvent) or not self.events:
+            return False
+        event = self.events[0]
+        return (isinstance(event, ScalarEvent) and event.anchor is None
+                and event.tag is None and event.implicit and event.value == u'')
+
+    def check_simple_key(self):
+        length = 0
+        if isinstance(self.event, NodeEvent) and self.event.anchor is not None:
+            if self.prepared_anchor is None:
+                self.prepared_anchor = self.prepare_anchor(self.event.anchor)
+            length += len(self.prepared_anchor)
+        if isinstance(self.event, (ScalarEvent, CollectionStartEvent))  \
+                and self.event.tag is not None:
+            if self.prepared_tag is None:
+                self.prepared_tag = self.prepare_tag(self.event.tag)
+            length += len(self.prepared_tag)
+        if isinstance(self.event, ScalarEvent):
+            if self.analysis is None:
+                self.analysis = self.analyze_scalar(self.event.value)
+            length += len(self.analysis.scalar)
+        return (length < 128 and (isinstance(self.event, AliasEvent)
+            or (isinstance(self.event, ScalarEvent)
+                    and not self.analysis.empty and not self.analysis.multiline)
+            or self.check_empty_sequence() or self.check_empty_mapping()))
+
+    # Anchor, Tag, and Scalar processors.
+
+    def process_anchor(self, indicator):
+        if self.event.anchor is None:
+            self.prepared_anchor = None
+            return
+        if self.prepared_anchor is None:
+            self.prepared_anchor = self.prepare_anchor(self.event.anchor)
+        if self.prepared_anchor:
+            self.write_indicator(indicator+self.prepared_anchor, True)
+        self.prepared_anchor = None
+
+    def process_tag(self):
+        tag = self.event.tag
+        if isinstance(self.event, ScalarEvent):
+            if self.style is None:
+                self.style = self.choose_scalar_style()
+            if ((not self.canonical or tag is None) and
+                ((self.style == '' and self.event.implicit[0])
+                        or (self.style != '' and self.event.implicit[1]))):
+                self.prepared_tag = None
+                return
+            if self.event.implicit[0] and tag is None:
+                tag = u'!'
+                self.prepared_tag = None
+        else:
+            if (not self.canonical or tag is None) and self.event.implicit:
+                self.prepared_tag = None
+                return
+        if tag is None:
+            raise EmitterError("tag is not specified")
+        if self.prepared_tag is None:
+            self.prepared_tag = self.prepare_tag(tag)
+        if self.prepared_tag:
+            self.write_indicator(self.prepared_tag, True)
+        self.prepared_tag = None
+
+    def choose_scalar_style(self):
+        if self.analysis is None:
+            self.analysis = self.analyze_scalar(self.event.value)
+        if self.event.style == '"' or self.canonical:
+            return '"'
+        if not self.event.style and self.event.implicit[0]:
+            if (not (self.simple_key_context and
+                    (self.analysis.empty or self.analysis.multiline))
+                and (self.flow_level and self.analysis.allow_flow_plain
+                    or (not self.flow_level and self.analysis.allow_block_plain))):
+                return ''
+        if self.event.style and self.event.style in '|>':
+            if (not self.flow_level and not self.simple_key_context
+                    and self.analysis.allow_block):
+                return self.event.style
+        if not self.event.style or self.event.style == '\'':
+            if (self.analysis.allow_single_quoted and
+                    not (self.simple_key_context and self.analysis.multiline)):
+                return '\''
+        return '"'
+
+    def process_scalar(self):
+        if self.analysis is None:
+            self.analysis = self.analyze_scalar(self.event.value)
+        if self.style is None:
+            self.style = self.choose_scalar_style()
+        split = (not self.simple_key_context)
+        #if self.analysis.multiline and split    \
+        #        and (not self.style or self.style in '\'\"'):
+        #    self.write_indent()
+        if self.style == '"':
+            self.write_double_quoted(self.analysis.scalar, split)
+        elif self.style == '\'':
+            self.write_single_quoted(self.analysis.scalar, split)
+        elif self.style == '>':
+            self.write_folded(self.analysis.scalar)
+        elif self.style == '|':
+            self.write_literal(self.analysis.scalar)
+        else:
+            self.write_plain(self.analysis.scalar, split)
+        self.analysis = None
+        self.style = None
+
+    # Analyzers.
+
+    def prepare_version(self, version):
+        major, minor = version
+        if major != 1:
+            raise EmitterError("unsupported YAML version: %d.%d" % (major, minor))
+        return u'%d.%d' % (major, minor)
+
+    def prepare_tag_handle(self, handle):
+        if not handle:
+            raise EmitterError("tag handle must not be empty")
+        if handle[0] != u'!' or handle[-1] != u'!':
+            raise EmitterError("tag handle must start and end with '!': %r"
+                    % (handle.encode('utf-8')))
+        for ch in handle[1:-1]:
+            if not (u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'  \
+                    or ch in u'-_'):
+                raise EmitterError("invalid character %r in the tag handle: %r"
+                        % (ch.encode('utf-8'), handle.encode('utf-8')))
+        return handle
+
+    def prepare_tag_prefix(self, prefix):
+        if not prefix:
+            raise EmitterError("tag prefix must not be empty")
+        chunks = []
+        start = end = 0
+        if prefix[0] == u'!':
+            end = 1
+        while end < len(prefix):
+            ch = prefix[end]
+            if u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'   \
+                    or ch in u'-;/?!:@&=+$,_.~*\'()[]':
+                end += 1
+            else:
+                if start < end:
+                    chunks.append(prefix[start:end])
+                start = end = end+1
+                data = ch.encode('utf-8')
+                for ch in data:
+                    chunks.append(u'%%%02X' % ord(ch))
+        if start < end:
+            chunks.append(prefix[start:end])
+        return u''.join(chunks)
+
+    def prepare_tag(self, tag):
+        if not tag:
+            raise EmitterError("tag must not be empty")
+        if tag == u'!':
+            return tag
+        handle = None
+        suffix = tag
+        prefixes = self.tag_prefixes.keys()
+        prefixes.sort()
+        for prefix in prefixes:
+            if tag.startswith(prefix)   \
+                    and (prefix == u'!' or len(prefix) < len(tag)):
+                handle = self.tag_prefixes[prefix]
+                suffix = tag[len(prefix):]
+        chunks = []
+        start = end = 0
+        while end < len(suffix):
+            ch = suffix[end]
+            if u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'   \
+                    or ch in u'-;/?:@&=+$,_.~*\'()[]'   \
+                    or (ch == u'!' and handle != u'!'):
+                end += 1
+            else:
+                if start < end:
+                    chunks.append(suffix[start:end])
+                start = end = end+1
+                data = ch.encode('utf-8')
+                for ch in data:
+                    chunks.append(u'%%%02X' % ord(ch))
+        if start < end:
+            chunks.append(suffix[start:end])
+        suffix_text = u''.join(chunks)
+        if handle:
+            return u'%s%s' % (handle, suffix_text)
+        else:
+            return u'!<%s>' % suffix_text
+
+    def prepare_anchor(self, anchor):
+        if not anchor:
+            raise EmitterError("anchor must not be empty")
+        for ch in anchor:
+            if not (u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'  \
+                    or ch in u'-_'):
+                raise EmitterError("invalid character %r in the anchor: %r"
+                        % (ch.encode('utf-8'), anchor.encode('utf-8')))
+        return anchor
+
+    def analyze_scalar(self, scalar):
+
+        # Empty scalar is a special case.
+        if not scalar:
+            return ScalarAnalysis(scalar=scalar, empty=True, multiline=False,
+                    allow_flow_plain=False, allow_block_plain=True,
+                    allow_single_quoted=True, allow_double_quoted=True,
+                    allow_block=False)
+
+        # Indicators and special characters.
+        block_indicators = False
+        flow_indicators = False
+        line_breaks = False
+        special_characters = False
+
+        # Important whitespace combinations.
+        leading_space = False
+        leading_break = False
+        trailing_space = False
+        trailing_break = False
+        break_space = False
+        space_break = False
+
+        # Check document indicators.
+        if scalar.startswith(u'---') or scalar.startswith(u'...'):
+            block_indicators = True
+            flow_indicators = True
+
+        # First character or preceded by a whitespace.
+        preceeded_by_whitespace = True
+
+        # Last character or followed by a whitespace.
+        followed_by_whitespace = (len(scalar) == 1 or
+                scalar[1] in u'\0 \t\r\n\x85\u2028\u2029')
+
+        # The previous character is a space.
+        previous_space = False
+
+        # The previous character is a break.
+        previous_break = False
+
+        index = 0
+        while index < len(scalar):
+            ch = scalar[index]
+
+            # Check for indicators.
+            if index == 0:
+                # Leading indicators are special characters.
+                if ch in u'#,[]{}&*!|>\'\"%@`': 
+                    flow_indicators = True
+                    block_indicators = True
+                if ch in u'?:':
+                    flow_indicators = True
+                    if followed_by_whitespace:
+                        block_indicators = True
+                if ch == u'-' and followed_by_whitespace:
+                    flow_indicators = True
+                    block_indicators = True
+            else:
+                # Some indicators cannot appear within a scalar as well.
+                if ch in u',?[]{}':
+                    flow_indicators = True
+                if ch == u':':
+                    flow_indicators = True
+                    if followed_by_whitespace:
+                        block_indicators = True
+                if ch == u'#' and preceeded_by_whitespace:
+                    flow_indicators = True
+                    block_indicators = True
+
+            # Check for line breaks, special, and unicode characters.
+            if ch in u'\n\x85\u2028\u2029':
+                line_breaks = True
+            if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'):
+                if (ch == u'\x85' or u'\xA0' <= ch <= u'\uD7FF'
+                        or u'\uE000' <= ch <= u'\uFFFD') and ch != u'\uFEFF':
+                    unicode_characters = True
+                    if not self.allow_unicode:
+                        special_characters = True
+                else:
+                    special_characters = True
+
+            # Detect important whitespace combinations.
+            if ch == u' ':
+                if index == 0:
+                    leading_space = True
+                if index == len(scalar)-1:
+                    trailing_space = True
+                if previous_break:
+                    break_space = True
+                previous_space = True
+                previous_break = False
+            elif ch in u'\n\x85\u2028\u2029':
+                if index == 0:
+                    leading_break = True
+                if index == len(scalar)-1:
+                    trailing_break = True
+                if previous_space:
+                    space_break = True
+                previous_space = False
+                previous_break = True
+            else:
+                previous_space = False
+                previous_break = False
+
+            # Prepare for the next character.
+            index += 1
+            preceeded_by_whitespace = (ch in u'\0 \t\r\n\x85\u2028\u2029')
+            followed_by_whitespace = (index+1 >= len(scalar) or
+                    scalar[index+1] in u'\0 \t\r\n\x85\u2028\u2029')
+
+        # Let's decide what styles are allowed.
+        allow_flow_plain = True
+        allow_block_plain = True
+        allow_single_quoted = True
+        allow_double_quoted = True
+        allow_block = True
+
+        # Leading and trailing whitespaces are bad for plain scalars.
+        if (leading_space or leading_break
+                or trailing_space or trailing_break):
+            allow_flow_plain = allow_block_plain = False
+
+        # We do not permit trailing spaces for block scalars.
+        if trailing_space:
+            allow_block = False
+
+        # Spaces at the beginning of a new line are only acceptable for block
+        # scalars.
+        if break_space:
+            allow_flow_plain = allow_block_plain = allow_single_quoted = False
+
+        # Spaces followed by breaks, as well as special character are only
+        # allowed for double quoted scalars.
+        if space_break or special_characters:
+            allow_flow_plain = allow_block_plain =  \
+            allow_single_quoted = allow_block = False
+
+        # Although the plain scalar writer supports breaks, we never emit
+        # multiline plain scalars.
+        if line_breaks:
+            allow_flow_plain = allow_block_plain = False
+
+        # Flow indicators are forbidden for flow plain scalars.
+        if flow_indicators:
+            allow_flow_plain = False
+
+        # Block indicators are forbidden for block plain scalars.
+        if block_indicators:
+            allow_block_plain = False
+
+        return ScalarAnalysis(scalar=scalar,
+                empty=False, multiline=line_breaks,
+                allow_flow_plain=allow_flow_plain,
+                allow_block_plain=allow_block_plain,
+                allow_single_quoted=allow_single_quoted,
+                allow_double_quoted=allow_double_quoted,
+                allow_block=allow_block)
+
+    # Writers.
+
+    def flush_stream(self):
+        if hasattr(self.stream, 'flush'):
+            self.stream.flush()
+
+    def write_stream_start(self):
+        # Write BOM if needed.
+        if self.encoding and self.encoding.startswith('utf-16'):
+            self.stream.write(u'\uFEFF'.encode(self.encoding))
+
+    def write_stream_end(self):
+        self.flush_stream()
+
+    def write_indicator(self, indicator, need_whitespace,
+            whitespace=False, indention=False):
+        if self.whitespace or not need_whitespace:
+            data = indicator
+        else:
+            data = u' '+indicator
+        self.whitespace = whitespace
+        self.indention = self.indention and indention
+        self.column += len(data)
+        self.open_ended = False
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+
+    def write_indent(self):
+        indent = self.indent or 0
+        if not self.indention or self.column > indent   \
+                or (self.column == indent and not self.whitespace):
+            self.write_line_break()
+        if self.column < indent:
+            self.whitespace = True
+            data = u' '*(indent-self.column)
+            self.column = indent
+            if self.encoding:
+                data = data.encode(self.encoding)
+            self.stream.write(data)
+
+    def write_line_break(self, data=None):
+        if data is None:
+            data = self.best_line_break
+        self.whitespace = True
+        self.indention = True
+        self.line += 1
+        self.column = 0
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+
+    def write_version_directive(self, version_text):
+        data = u'%%YAML %s' % version_text
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+        self.write_line_break()
+
+    def write_tag_directive(self, handle_text, prefix_text):
+        data = u'%%TAG %s %s' % (handle_text, prefix_text)
+        if self.encoding:
+            data = data.encode(self.encoding)
+        self.stream.write(data)
+        self.write_line_break()
+
+    # Scalar streams.
+
+    def write_single_quoted(self, text, split=True):
+        self.write_indicator(u'\'', True)
+        spaces = False
+        breaks = False
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if spaces:
+                if ch is None or ch != u' ':
+                    if start+1 == end and self.column > self.best_width and split   \
+                            and start != 0 and end != len(text):
+                        self.write_indent()
+                    else:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                    start = end
+            elif breaks:
+                if ch is None or ch not in u'\n\x85\u2028\u2029':
+                    if text[start] == u'\n':
+                        self.write_line_break()
+                    for br in text[start:end]:
+                        if br == u'\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    self.write_indent()
+                    start = end
+            else:
+                if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u'\'':
+                    if start < end:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                        start = end
+            if ch == u'\'':
+                data = u'\'\''
+                self.column += 2
+                if self.encoding:
+                    data = data.encode(self.encoding)
+                self.stream.write(data)
+                start = end + 1
+            if ch is not None:
+                spaces = (ch == u' ')
+                breaks = (ch in u'\n\x85\u2028\u2029')
+            end += 1
+        self.write_indicator(u'\'', False)
+
+    ESCAPE_REPLACEMENTS = {
+        u'\0':      u'0',
+        u'\x07':    u'a',
+        u'\x08':    u'b',
+        u'\x09':    u't',
+        u'\x0A':    u'n',
+        u'\x0B':    u'v',
+        u'\x0C':    u'f',
+        u'\x0D':    u'r',
+        u'\x1B':    u'e',
+        u'\"':      u'\"',
+        u'\\':      u'\\',
+        u'\x85':    u'N',
+        u'\xA0':    u'_',
+        u'\u2028':  u'L',
+        u'\u2029':  u'P',
+    }
+
+    def write_double_quoted(self, text, split=True):
+        self.write_indicator(u'"', True)
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if ch is None or ch in u'"\\\x85\u2028\u2029\uFEFF' \
+                    or not (u'\x20' <= ch <= u'\x7E'
+                        or (self.allow_unicode
+                            and (u'\xA0' <= ch <= u'\uD7FF'
+                                or u'\uE000' <= ch <= u'\uFFFD'))):
+                if start < end:
+                    data = text[start:end]
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    start = end
+                if ch is not None:
+                    if ch in self.ESCAPE_REPLACEMENTS:
+                        data = u'\\'+self.ESCAPE_REPLACEMENTS[ch]
+                    elif ch <= u'\xFF':
+                        data = u'\\x%02X' % ord(ch)
+                    elif ch <= u'\uFFFF':
+                        data = u'\\u%04X' % ord(ch)
+                    else:
+                        data = u'\\U%08X' % ord(ch)
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    start = end+1
+            if 0 < end < len(text)-1 and (ch == u' ' or start >= end)   \
+                    and self.column+(end-start) > self.best_width and split:
+                data = text[start:end]+u'\\'
+                if start < end:
+                    start = end
+                self.column += len(data)
+                if self.encoding:
+                    data = data.encode(self.encoding)
+                self.stream.write(data)
+                self.write_indent()
+                self.whitespace = False
+                self.indention = False
+                if text[start] == u' ':
+                    data = u'\\'
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+            end += 1
+        self.write_indicator(u'"', False)
+
+    def determine_block_hints(self, text):
+        hints = u''
+        if text:
+            if text[0] in u' \n\x85\u2028\u2029':
+                hints += unicode(self.best_indent)
+            if text[-1] not in u'\n\x85\u2028\u2029':
+                hints += u'-'
+            elif len(text) == 1 or text[-2] in u'\n\x85\u2028\u2029':
+                hints += u'+'
+        return hints
+
+    def write_folded(self, text):
+        hints = self.determine_block_hints(text)
+        self.write_indicator(u'>'+hints, True)
+        if hints[-1:] == u'+':
+            self.open_ended = True
+        self.write_line_break()
+        leading_space = True
+        spaces = False
+        breaks = True
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if breaks:
+                if ch is None or ch not in u'\n\x85\u2028\u2029':
+                    if not leading_space and ch is not None and ch != u' '  \
+                            and text[start] == u'\n':
+                        self.write_line_break()
+                    leading_space = (ch == u' ')
+                    for br in text[start:end]:
+                        if br == u'\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    if ch is not None:
+                        self.write_indent()
+                    start = end
+            elif spaces:
+                if ch != u' ':
+                    if start+1 == end and self.column > self.best_width:
+                        self.write_indent()
+                    else:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                    start = end
+            else:
+                if ch is None or ch in u' \n\x85\u2028\u2029':
+                    data = text[start:end]
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    if ch is None:
+                        self.write_line_break()
+                    start = end
+            if ch is not None:
+                breaks = (ch in u'\n\x85\u2028\u2029')
+                spaces = (ch == u' ')
+            end += 1
+
+    def write_literal(self, text):
+        hints = self.determine_block_hints(text)
+        self.write_indicator(u'|'+hints, True)
+        if hints[-1:] == u'+':
+            self.open_ended = True
+        self.write_line_break()
+        breaks = True
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if breaks:
+                if ch is None or ch not in u'\n\x85\u2028\u2029':
+                    for br in text[start:end]:
+                        if br == u'\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    if ch is not None:
+                        self.write_indent()
+                    start = end
+            else:
+                if ch is None or ch in u'\n\x85\u2028\u2029':
+                    data = text[start:end]
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    if ch is None:
+                        self.write_line_break()
+                    start = end
+            if ch is not None:
+                breaks = (ch in u'\n\x85\u2028\u2029')
+            end += 1
+
+    def write_plain(self, text, split=True):
+        if self.root_context:
+            self.open_ended = True
+        if not text:
+            return
+        if not self.whitespace:
+            data = u' '
+            self.column += len(data)
+            if self.encoding:
+                data = data.encode(self.encoding)
+            self.stream.write(data)
+        self.whitespace = False
+        self.indention = False
+        spaces = False
+        breaks = False
+        start = end = 0
+        while end <= len(text):
+            ch = None
+            if end < len(text):
+                ch = text[end]
+            if spaces:
+                if ch != u' ':
+                    if start+1 == end and self.column > self.best_width and split:
+                        self.write_indent()
+                        self.whitespace = False
+                        self.indention = False
+                    else:
+                        data = text[start:end]
+                        self.column += len(data)
+                        if self.encoding:
+                            data = data.encode(self.encoding)
+                        self.stream.write(data)
+                    start = end
+            elif breaks:
+                if ch not in u'\n\x85\u2028\u2029':
+                    if text[start] == u'\n':
+                        self.write_line_break()
+                    for br in text[start:end]:
+                        if br == u'\n':
+                            self.write_line_break()
+                        else:
+                            self.write_line_break(br)
+                    self.write_indent()
+                    self.whitespace = False
+                    self.indention = False
+                    start = end
+            else:
+                if ch is None or ch in u' \n\x85\u2028\u2029':
+                    data = text[start:end]
+                    self.column += len(data)
+                    if self.encoding:
+                        data = data.encode(self.encoding)
+                    self.stream.write(data)
+                    start = end
+            if ch is not None:
+                spaces = (ch == u' ')
+                breaks = (ch in u'\n\x85\u2028\u2029')
+            end += 1
+
diff --git a/libs/py2/yaml/error.py b/libs/py2/yaml/error.py
new file mode 100644
index 00000000..577686db
--- /dev/null
+++ b/libs/py2/yaml/error.py
@@ -0,0 +1,75 @@
+
+__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError']
+
+class Mark(object):
+
+    def __init__(self, name, index, line, column, buffer, pointer):
+        self.name = name
+        self.index = index
+        self.line = line
+        self.column = column
+        self.buffer = buffer
+        self.pointer = pointer
+
+    def get_snippet(self, indent=4, max_length=75):
+        if self.buffer is None:
+            return None
+        head = ''
+        start = self.pointer
+        while start > 0 and self.buffer[start-1] not in u'\0\r\n\x85\u2028\u2029':
+            start -= 1
+            if self.pointer-start > max_length/2-1:
+                head = ' ... '
+                start += 5
+                break
+        tail = ''
+        end = self.pointer
+        while end < len(self.buffer) and self.buffer[end] not in u'\0\r\n\x85\u2028\u2029':
+            end += 1
+            if end-self.pointer > max_length/2-1:
+                tail = ' ... '
+                end -= 5
+                break
+        snippet = self.buffer[start:end].encode('utf-8')
+        return ' '*indent + head + snippet + tail + '\n'  \
+                + ' '*(indent+self.pointer-start+len(head)) + '^'
+
+    def __str__(self):
+        snippet = self.get_snippet()
+        where = "  in \"%s\", line %d, column %d"   \
+                % (self.name, self.line+1, self.column+1)
+        if snippet is not None:
+            where += ":\n"+snippet
+        return where
+
+class YAMLError(Exception):
+    pass
+
+class MarkedYAMLError(YAMLError):
+
+    def __init__(self, context=None, context_mark=None,
+            problem=None, problem_mark=None, note=None):
+        self.context = context
+        self.context_mark = context_mark
+        self.problem = problem
+        self.problem_mark = problem_mark
+        self.note = note
+
+    def __str__(self):
+        lines = []
+        if self.context is not None:
+            lines.append(self.context)
+        if self.context_mark is not None  \
+            and (self.problem is None or self.problem_mark is None
+                    or self.context_mark.name != self.problem_mark.name
+                    or self.context_mark.line != self.problem_mark.line
+                    or self.context_mark.column != self.problem_mark.column):
+            lines.append(str(self.context_mark))
+        if self.problem is not None:
+            lines.append(self.problem)
+        if self.problem_mark is not None:
+            lines.append(str(self.problem_mark))
+        if self.note is not None:
+            lines.append(self.note)
+        return '\n'.join(lines)
+
diff --git a/libs/py2/yaml/events.py b/libs/py2/yaml/events.py
new file mode 100644
index 00000000..f79ad389
--- /dev/null
+++ b/libs/py2/yaml/events.py
@@ -0,0 +1,86 @@
+
+# Abstract classes.
+
+class Event(object):
+    def __init__(self, start_mark=None, end_mark=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+    def __repr__(self):
+        attributes = [key for key in ['anchor', 'tag', 'implicit', 'value']
+                if hasattr(self, key)]
+        arguments = ', '.join(['%s=%r' % (key, getattr(self, key))
+                for key in attributes])
+        return '%s(%s)' % (self.__class__.__name__, arguments)
+
+class NodeEvent(Event):
+    def __init__(self, anchor, start_mark=None, end_mark=None):
+        self.anchor = anchor
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class CollectionStartEvent(NodeEvent):
+    def __init__(self, anchor, tag, implicit, start_mark=None, end_mark=None,
+            flow_style=None):
+        self.anchor = anchor
+        self.tag = tag
+        self.implicit = implicit
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.flow_style = flow_style
+
+class CollectionEndEvent(Event):
+    pass
+
+# Implementations.
+
+class StreamStartEvent(Event):
+    def __init__(self, start_mark=None, end_mark=None, encoding=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.encoding = encoding
+
+class StreamEndEvent(Event):
+    pass
+
+class DocumentStartEvent(Event):
+    def __init__(self, start_mark=None, end_mark=None,
+            explicit=None, version=None, tags=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.explicit = explicit
+        self.version = version
+        self.tags = tags
+
+class DocumentEndEvent(Event):
+    def __init__(self, start_mark=None, end_mark=None,
+            explicit=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.explicit = explicit
+
+class AliasEvent(NodeEvent):
+    pass
+
+class ScalarEvent(NodeEvent):
+    def __init__(self, anchor, tag, implicit, value,
+            start_mark=None, end_mark=None, style=None):
+        self.anchor = anchor
+        self.tag = tag
+        self.implicit = implicit
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.style = style
+
+class SequenceStartEvent(CollectionStartEvent):
+    pass
+
+class SequenceEndEvent(CollectionEndEvent):
+    pass
+
+class MappingStartEvent(CollectionStartEvent):
+    pass
+
+class MappingEndEvent(CollectionEndEvent):
+    pass
+
diff --git a/libs/py2/yaml/loader.py b/libs/py2/yaml/loader.py
new file mode 100644
index 00000000..293ff467
--- /dev/null
+++ b/libs/py2/yaml/loader.py
@@ -0,0 +1,40 @@
+
+__all__ = ['BaseLoader', 'SafeLoader', 'Loader']
+
+from reader import *
+from scanner import *
+from parser import *
+from composer import *
+from constructor import *
+from resolver import *
+
+class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        BaseConstructor.__init__(self)
+        BaseResolver.__init__(self)
+
+class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        SafeConstructor.__init__(self)
+        Resolver.__init__(self)
+
+class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver):
+
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        Constructor.__init__(self)
+        Resolver.__init__(self)
+
diff --git a/libs/py2/yaml/nodes.py b/libs/py2/yaml/nodes.py
new file mode 100644
index 00000000..c4f070c4
--- /dev/null
+++ b/libs/py2/yaml/nodes.py
@@ -0,0 +1,49 @@
+
+class Node(object):
+    def __init__(self, tag, value, start_mark, end_mark):
+        self.tag = tag
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+    def __repr__(self):
+        value = self.value
+        #if isinstance(value, list):
+        #    if len(value) == 0:
+        #        value = '<empty>'
+        #    elif len(value) == 1:
+        #        value = '<1 item>'
+        #    else:
+        #        value = '<%d items>' % len(value)
+        #else:
+        #    if len(value) > 75:
+        #        value = repr(value[:70]+u' ... ')
+        #    else:
+        #        value = repr(value)
+        value = repr(value)
+        return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value)
+
+class ScalarNode(Node):
+    id = 'scalar'
+    def __init__(self, tag, value,
+            start_mark=None, end_mark=None, style=None):
+        self.tag = tag
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.style = style
+
+class CollectionNode(Node):
+    def __init__(self, tag, value,
+            start_mark=None, end_mark=None, flow_style=None):
+        self.tag = tag
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.flow_style = flow_style
+
+class SequenceNode(CollectionNode):
+    id = 'sequence'
+
+class MappingNode(CollectionNode):
+    id = 'mapping'
+
diff --git a/libs/py2/yaml/parser.py b/libs/py2/yaml/parser.py
new file mode 100644
index 00000000..f9e3057f
--- /dev/null
+++ b/libs/py2/yaml/parser.py
@@ -0,0 +1,589 @@
+
+# The following YAML grammar is LL(1) and is parsed by a recursive descent
+# parser.
+#
+# stream            ::= STREAM-START implicit_document? explicit_document* STREAM-END
+# implicit_document ::= block_node DOCUMENT-END*
+# explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+# block_node_or_indentless_sequence ::=
+#                       ALIAS
+#                       | properties (block_content | indentless_block_sequence)?
+#                       | block_content
+#                       | indentless_block_sequence
+# block_node        ::= ALIAS
+#                       | properties block_content?
+#                       | block_content
+# flow_node         ::= ALIAS
+#                       | properties flow_content?
+#                       | flow_content
+# properties        ::= TAG ANCHOR? | ANCHOR TAG?
+# block_content     ::= block_collection | flow_collection | SCALAR
+# flow_content      ::= flow_collection | SCALAR
+# block_collection  ::= block_sequence | block_mapping
+# flow_collection   ::= flow_sequence | flow_mapping
+# block_sequence    ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+# indentless_sequence   ::= (BLOCK-ENTRY block_node?)+
+# block_mapping     ::= BLOCK-MAPPING_START
+#                       ((KEY block_node_or_indentless_sequence?)?
+#                       (VALUE block_node_or_indentless_sequence?)?)*
+#                       BLOCK-END
+# flow_sequence     ::= FLOW-SEQUENCE-START
+#                       (flow_sequence_entry FLOW-ENTRY)*
+#                       flow_sequence_entry?
+#                       FLOW-SEQUENCE-END
+# flow_sequence_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+# flow_mapping      ::= FLOW-MAPPING-START
+#                       (flow_mapping_entry FLOW-ENTRY)*
+#                       flow_mapping_entry?
+#                       FLOW-MAPPING-END
+# flow_mapping_entry    ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+#
+# FIRST sets:
+#
+# stream: { STREAM-START }
+# explicit_document: { DIRECTIVE DOCUMENT-START }
+# implicit_document: FIRST(block_node)
+# block_node: { ALIAS TAG ANCHOR SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# flow_node: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# block_content: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR }
+# flow_content: { FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR }
+# block_collection: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START }
+# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# block_sequence: { BLOCK-SEQUENCE-START }
+# block_mapping: { BLOCK-MAPPING-START }
+# block_node_or_indentless_sequence: { ALIAS ANCHOR TAG SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START BLOCK-ENTRY }
+# indentless_sequence: { ENTRY }
+# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START }
+# flow_sequence: { FLOW-SEQUENCE-START }
+# flow_mapping: { FLOW-MAPPING-START }
+# flow_sequence_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY }
+# flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY }
+
+__all__ = ['Parser', 'ParserError']
+
+from error import MarkedYAMLError
+from tokens import *
+from events import *
+from scanner import *
+
+class ParserError(MarkedYAMLError):
+    pass
+
+class Parser(object):
+    # Since writing a recursive-descendant parser is a straightforward task, we
+    # do not give many comments here.
+
+    DEFAULT_TAGS = {
+        u'!':   u'!',
+        u'!!':  u'tag:yaml.org,2002:',
+    }
+
+    def __init__(self):
+        self.current_event = None
+        self.yaml_version = None
+        self.tag_handles = {}
+        self.states = []
+        self.marks = []
+        self.state = self.parse_stream_start
+
+    def dispose(self):
+        # Reset the state attributes (to clear self-references)
+        self.states = []
+        self.state = None
+
+    def check_event(self, *choices):
+        # Check the type of the next event.
+        if self.current_event is None:
+            if self.state:
+                self.current_event = self.state()
+        if self.current_event is not None:
+            if not choices:
+                return True
+            for choice in choices:
+                if isinstance(self.current_event, choice):
+                    return True
+        return False
+
+    def peek_event(self):
+        # Get the next event.
+        if self.current_event is None:
+            if self.state:
+                self.current_event = self.state()
+        return self.current_event
+
+    def get_event(self):
+        # Get the next event and proceed further.
+        if self.current_event is None:
+            if self.state:
+                self.current_event = self.state()
+        value = self.current_event
+        self.current_event = None
+        return value
+
+    # stream    ::= STREAM-START implicit_document? explicit_document* STREAM-END
+    # implicit_document ::= block_node DOCUMENT-END*
+    # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+
+    def parse_stream_start(self):
+
+        # Parse the stream start.
+        token = self.get_token()
+        event = StreamStartEvent(token.start_mark, token.end_mark,
+                encoding=token.encoding)
+
+        # Prepare the next state.
+        self.state = self.parse_implicit_document_start
+
+        return event
+
+    def parse_implicit_document_start(self):
+
+        # Parse an implicit document.
+        if not self.check_token(DirectiveToken, DocumentStartToken,
+                StreamEndToken):
+            self.tag_handles = self.DEFAULT_TAGS
+            token = self.peek_token()
+            start_mark = end_mark = token.start_mark
+            event = DocumentStartEvent(start_mark, end_mark,
+                    explicit=False)
+
+            # Prepare the next state.
+            self.states.append(self.parse_document_end)
+            self.state = self.parse_block_node
+
+            return event
+
+        else:
+            return self.parse_document_start()
+
+    def parse_document_start(self):
+
+        # Parse any extra document end indicators.
+        while self.check_token(DocumentEndToken):
+            self.get_token()
+
+        # Parse an explicit document.
+        if not self.check_token(StreamEndToken):
+            token = self.peek_token()
+            start_mark = token.start_mark
+            version, tags = self.process_directives()
+            if not self.check_token(DocumentStartToken):
+                raise ParserError(None, None,
+                        "expected '<document start>', but found %r"
+                        % self.peek_token().id,
+                        self.peek_token().start_mark)
+            token = self.get_token()
+            end_mark = token.end_mark
+            event = DocumentStartEvent(start_mark, end_mark,
+                    explicit=True, version=version, tags=tags)
+            self.states.append(self.parse_document_end)
+            self.state = self.parse_document_content
+        else:
+            # Parse the end of the stream.
+            token = self.get_token()
+            event = StreamEndEvent(token.start_mark, token.end_mark)
+            assert not self.states
+            assert not self.marks
+            self.state = None
+        return event
+
+    def parse_document_end(self):
+
+        # Parse the document end.
+        token = self.peek_token()
+        start_mark = end_mark = token.start_mark
+        explicit = False
+        if self.check_token(DocumentEndToken):
+            token = self.get_token()
+            end_mark = token.end_mark
+            explicit = True
+        event = DocumentEndEvent(start_mark, end_mark,
+                explicit=explicit)
+
+        # Prepare the next state.
+        self.state = self.parse_document_start
+
+        return event
+
+    def parse_document_content(self):
+        if self.check_token(DirectiveToken,
+                DocumentStartToken, DocumentEndToken, StreamEndToken):
+            event = self.process_empty_scalar(self.peek_token().start_mark)
+            self.state = self.states.pop()
+            return event
+        else:
+            return self.parse_block_node()
+
+    def process_directives(self):
+        self.yaml_version = None
+        self.tag_handles = {}
+        while self.check_token(DirectiveToken):
+            token = self.get_token()
+            if token.name == u'YAML':
+                if self.yaml_version is not None:
+                    raise ParserError(None, None,
+                            "found duplicate YAML directive", token.start_mark)
+                major, minor = token.value
+                if major != 1:
+                    raise ParserError(None, None,
+                            "found incompatible YAML document (version 1.* is required)",
+                            token.start_mark)
+                self.yaml_version = token.value
+            elif token.name == u'TAG':
+                handle, prefix = token.value
+                if handle in self.tag_handles:
+                    raise ParserError(None, None,
+                            "duplicate tag handle %r" % handle.encode('utf-8'),
+                            token.start_mark)
+                self.tag_handles[handle] = prefix
+        if self.tag_handles:
+            value = self.yaml_version, self.tag_handles.copy()
+        else:
+            value = self.yaml_version, None
+        for key in self.DEFAULT_TAGS:
+            if key not in self.tag_handles:
+                self.tag_handles[key] = self.DEFAULT_TAGS[key]
+        return value
+
+    # block_node_or_indentless_sequence ::= ALIAS
+    #               | properties (block_content | indentless_block_sequence)?
+    #               | block_content
+    #               | indentless_block_sequence
+    # block_node    ::= ALIAS
+    #                   | properties block_content?
+    #                   | block_content
+    # flow_node     ::= ALIAS
+    #                   | properties flow_content?
+    #                   | flow_content
+    # properties    ::= TAG ANCHOR? | ANCHOR TAG?
+    # block_content     ::= block_collection | flow_collection | SCALAR
+    # flow_content      ::= flow_collection | SCALAR
+    # block_collection  ::= block_sequence | block_mapping
+    # flow_collection   ::= flow_sequence | flow_mapping
+
+    def parse_block_node(self):
+        return self.parse_node(block=True)
+
+    def parse_flow_node(self):
+        return self.parse_node()
+
+    def parse_block_node_or_indentless_sequence(self):
+        return self.parse_node(block=True, indentless_sequence=True)
+
+    def parse_node(self, block=False, indentless_sequence=False):
+        if self.check_token(AliasToken):
+            token = self.get_token()
+            event = AliasEvent(token.value, token.start_mark, token.end_mark)
+            self.state = self.states.pop()
+        else:
+            anchor = None
+            tag = None
+            start_mark = end_mark = tag_mark = None
+            if self.check_token(AnchorToken):
+                token = self.get_token()
+                start_mark = token.start_mark
+                end_mark = token.end_mark
+                anchor = token.value
+                if self.check_token(TagToken):
+                    token = self.get_token()
+                    tag_mark = token.start_mark
+                    end_mark = token.end_mark
+                    tag = token.value
+            elif self.check_token(TagToken):
+                token = self.get_token()
+                start_mark = tag_mark = token.start_mark
+                end_mark = token.end_mark
+                tag = token.value
+                if self.check_token(AnchorToken):
+                    token = self.get_token()
+                    end_mark = token.end_mark
+                    anchor = token.value
+            if tag is not None:
+                handle, suffix = tag
+                if handle is not None:
+                    if handle not in self.tag_handles:
+                        raise ParserError("while parsing a node", start_mark,
+                                "found undefined tag handle %r" % handle.encode('utf-8'),
+                                tag_mark)
+                    tag = self.tag_handles[handle]+suffix
+                else:
+                    tag = suffix
+            #if tag == u'!':
+            #    raise ParserError("while parsing a node", start_mark,
+            #            "found non-specific tag '!'", tag_mark,
+            #            "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.")
+            if start_mark is None:
+                start_mark = end_mark = self.peek_token().start_mark
+            event = None
+            implicit = (tag is None or tag == u'!')
+            if indentless_sequence and self.check_token(BlockEntryToken):
+                end_mark = self.peek_token().end_mark
+                event = SequenceStartEvent(anchor, tag, implicit,
+                        start_mark, end_mark)
+                self.state = self.parse_indentless_sequence_entry
+            else:
+                if self.check_token(ScalarToken):
+                    token = self.get_token()
+                    end_mark = token.end_mark
+                    if (token.plain and tag is None) or tag == u'!':
+                        implicit = (True, False)
+                    elif tag is None:
+                        implicit = (False, True)
+                    else:
+                        implicit = (False, False)
+                    event = ScalarEvent(anchor, tag, implicit, token.value,
+                            start_mark, end_mark, style=token.style)
+                    self.state = self.states.pop()
+                elif self.check_token(FlowSequenceStartToken):
+                    end_mark = self.peek_token().end_mark
+                    event = SequenceStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=True)
+                    self.state = self.parse_flow_sequence_first_entry
+                elif self.check_token(FlowMappingStartToken):
+                    end_mark = self.peek_token().end_mark
+                    event = MappingStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=True)
+                    self.state = self.parse_flow_mapping_first_key
+                elif block and self.check_token(BlockSequenceStartToken):
+                    end_mark = self.peek_token().start_mark
+                    event = SequenceStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=False)
+                    self.state = self.parse_block_sequence_first_entry
+                elif block and self.check_token(BlockMappingStartToken):
+                    end_mark = self.peek_token().start_mark
+                    event = MappingStartEvent(anchor, tag, implicit,
+                            start_mark, end_mark, flow_style=False)
+                    self.state = self.parse_block_mapping_first_key
+                elif anchor is not None or tag is not None:
+                    # Empty scalars are allowed even if a tag or an anchor is
+                    # specified.
+                    event = ScalarEvent(anchor, tag, (implicit, False), u'',
+                            start_mark, end_mark)
+                    self.state = self.states.pop()
+                else:
+                    if block:
+                        node = 'block'
+                    else:
+                        node = 'flow'
+                    token = self.peek_token()
+                    raise ParserError("while parsing a %s node" % node, start_mark,
+                            "expected the node content, but found %r" % token.id,
+                            token.start_mark)
+        return event
+
+    # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+
+    def parse_block_sequence_first_entry(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_block_sequence_entry()
+
+    def parse_block_sequence_entry(self):
+        if self.check_token(BlockEntryToken):
+            token = self.get_token()
+            if not self.check_token(BlockEntryToken, BlockEndToken):
+                self.states.append(self.parse_block_sequence_entry)
+                return self.parse_block_node()
+            else:
+                self.state = self.parse_block_sequence_entry
+                return self.process_empty_scalar(token.end_mark)
+        if not self.check_token(BlockEndToken):
+            token = self.peek_token()
+            raise ParserError("while parsing a block collection", self.marks[-1],
+                    "expected <block end>, but found %r" % token.id, token.start_mark)
+        token = self.get_token()
+        event = SequenceEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    # indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+
+    def parse_indentless_sequence_entry(self):
+        if self.check_token(BlockEntryToken):
+            token = self.get_token()
+            if not self.check_token(BlockEntryToken,
+                    KeyToken, ValueToken, BlockEndToken):
+                self.states.append(self.parse_indentless_sequence_entry)
+                return self.parse_block_node()
+            else:
+                self.state = self.parse_indentless_sequence_entry
+                return self.process_empty_scalar(token.end_mark)
+        token = self.peek_token()
+        event = SequenceEndEvent(token.start_mark, token.start_mark)
+        self.state = self.states.pop()
+        return event
+
+    # block_mapping     ::= BLOCK-MAPPING_START
+    #                       ((KEY block_node_or_indentless_sequence?)?
+    #                       (VALUE block_node_or_indentless_sequence?)?)*
+    #                       BLOCK-END
+
+    def parse_block_mapping_first_key(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_block_mapping_key()
+
+    def parse_block_mapping_key(self):
+        if self.check_token(KeyToken):
+            token = self.get_token()
+            if not self.check_token(KeyToken, ValueToken, BlockEndToken):
+                self.states.append(self.parse_block_mapping_value)
+                return self.parse_block_node_or_indentless_sequence()
+            else:
+                self.state = self.parse_block_mapping_value
+                return self.process_empty_scalar(token.end_mark)
+        if not self.check_token(BlockEndToken):
+            token = self.peek_token()
+            raise ParserError("while parsing a block mapping", self.marks[-1],
+                    "expected <block end>, but found %r" % token.id, token.start_mark)
+        token = self.get_token()
+        event = MappingEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    def parse_block_mapping_value(self):
+        if self.check_token(ValueToken):
+            token = self.get_token()
+            if not self.check_token(KeyToken, ValueToken, BlockEndToken):
+                self.states.append(self.parse_block_mapping_key)
+                return self.parse_block_node_or_indentless_sequence()
+            else:
+                self.state = self.parse_block_mapping_key
+                return self.process_empty_scalar(token.end_mark)
+        else:
+            self.state = self.parse_block_mapping_key
+            token = self.peek_token()
+            return self.process_empty_scalar(token.start_mark)
+
+    # flow_sequence     ::= FLOW-SEQUENCE-START
+    #                       (flow_sequence_entry FLOW-ENTRY)*
+    #                       flow_sequence_entry?
+    #                       FLOW-SEQUENCE-END
+    # flow_sequence_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+    #
+    # Note that while production rules for both flow_sequence_entry and
+    # flow_mapping_entry are equal, their interpretations are different.
+    # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?`
+    # generate an inline mapping (set syntax).
+
+    def parse_flow_sequence_first_entry(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_flow_sequence_entry(first=True)
+
+    def parse_flow_sequence_entry(self, first=False):
+        if not self.check_token(FlowSequenceEndToken):
+            if not first:
+                if self.check_token(FlowEntryToken):
+                    self.get_token()
+                else:
+                    token = self.peek_token()
+                    raise ParserError("while parsing a flow sequence", self.marks[-1],
+                            "expected ',' or ']', but got %r" % token.id, token.start_mark)
+            
+            if self.check_token(KeyToken):
+                token = self.peek_token()
+                event = MappingStartEvent(None, None, True,
+                        token.start_mark, token.end_mark,
+                        flow_style=True)
+                self.state = self.parse_flow_sequence_entry_mapping_key
+                return event
+            elif not self.check_token(FlowSequenceEndToken):
+                self.states.append(self.parse_flow_sequence_entry)
+                return self.parse_flow_node()
+        token = self.get_token()
+        event = SequenceEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    def parse_flow_sequence_entry_mapping_key(self):
+        token = self.get_token()
+        if not self.check_token(ValueToken,
+                FlowEntryToken, FlowSequenceEndToken):
+            self.states.append(self.parse_flow_sequence_entry_mapping_value)
+            return self.parse_flow_node()
+        else:
+            self.state = self.parse_flow_sequence_entry_mapping_value
+            return self.process_empty_scalar(token.end_mark)
+
+    def parse_flow_sequence_entry_mapping_value(self):
+        if self.check_token(ValueToken):
+            token = self.get_token()
+            if not self.check_token(FlowEntryToken, FlowSequenceEndToken):
+                self.states.append(self.parse_flow_sequence_entry_mapping_end)
+                return self.parse_flow_node()
+            else:
+                self.state = self.parse_flow_sequence_entry_mapping_end
+                return self.process_empty_scalar(token.end_mark)
+        else:
+            self.state = self.parse_flow_sequence_entry_mapping_end
+            token = self.peek_token()
+            return self.process_empty_scalar(token.start_mark)
+
+    def parse_flow_sequence_entry_mapping_end(self):
+        self.state = self.parse_flow_sequence_entry
+        token = self.peek_token()
+        return MappingEndEvent(token.start_mark, token.start_mark)
+
+    # flow_mapping  ::= FLOW-MAPPING-START
+    #                   (flow_mapping_entry FLOW-ENTRY)*
+    #                   flow_mapping_entry?
+    #                   FLOW-MAPPING-END
+    # flow_mapping_entry    ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+
+    def parse_flow_mapping_first_key(self):
+        token = self.get_token()
+        self.marks.append(token.start_mark)
+        return self.parse_flow_mapping_key(first=True)
+
+    def parse_flow_mapping_key(self, first=False):
+        if not self.check_token(FlowMappingEndToken):
+            if not first:
+                if self.check_token(FlowEntryToken):
+                    self.get_token()
+                else:
+                    token = self.peek_token()
+                    raise ParserError("while parsing a flow mapping", self.marks[-1],
+                            "expected ',' or '}', but got %r" % token.id, token.start_mark)
+            if self.check_token(KeyToken):
+                token = self.get_token()
+                if not self.check_token(ValueToken,
+                        FlowEntryToken, FlowMappingEndToken):
+                    self.states.append(self.parse_flow_mapping_value)
+                    return self.parse_flow_node()
+                else:
+                    self.state = self.parse_flow_mapping_value
+                    return self.process_empty_scalar(token.end_mark)
+            elif not self.check_token(FlowMappingEndToken):
+                self.states.append(self.parse_flow_mapping_empty_value)
+                return self.parse_flow_node()
+        token = self.get_token()
+        event = MappingEndEvent(token.start_mark, token.end_mark)
+        self.state = self.states.pop()
+        self.marks.pop()
+        return event
+
+    def parse_flow_mapping_value(self):
+        if self.check_token(ValueToken):
+            token = self.get_token()
+            if not self.check_token(FlowEntryToken, FlowMappingEndToken):
+                self.states.append(self.parse_flow_mapping_key)
+                return self.parse_flow_node()
+            else:
+                self.state = self.parse_flow_mapping_key
+                return self.process_empty_scalar(token.end_mark)
+        else:
+            self.state = self.parse_flow_mapping_key
+            token = self.peek_token()
+            return self.process_empty_scalar(token.start_mark)
+
+    def parse_flow_mapping_empty_value(self):
+        self.state = self.parse_flow_mapping_key
+        return self.process_empty_scalar(self.peek_token().start_mark)
+
+    def process_empty_scalar(self, mark):
+        return ScalarEvent(None, None, (True, False), u'', mark, mark)
+
diff --git a/libs/py2/yaml/reader.py b/libs/py2/yaml/reader.py
new file mode 100644
index 00000000..3249e6b9
--- /dev/null
+++ b/libs/py2/yaml/reader.py
@@ -0,0 +1,190 @@
+# This module contains abstractions for the input stream. You don't have to
+# looks further, there are no pretty code.
+#
+# We define two classes here.
+#
+#   Mark(source, line, column)
+# It's just a record and its only use is producing nice error messages.
+# Parser does not use it for any other purposes.
+#
+#   Reader(source, data)
+# Reader determines the encoding of `data` and converts it to unicode.
+# Reader provides the following methods and attributes:
+#   reader.peek(length=1) - return the next `length` characters
+#   reader.forward(length=1) - move the current position to `length` characters.
+#   reader.index - the number of the current character.
+#   reader.line, stream.column - the line and the column of the current character.
+
+__all__ = ['Reader', 'ReaderError']
+
+from error import YAMLError, Mark
+
+import codecs, re
+
+class ReaderError(YAMLError):
+
+    def __init__(self, name, position, character, encoding, reason):
+        self.name = name
+        self.character = character
+        self.position = position
+        self.encoding = encoding
+        self.reason = reason
+
+    def __str__(self):
+        if isinstance(self.character, str):
+            return "'%s' codec can't decode byte #x%02x: %s\n"  \
+                    "  in \"%s\", position %d"    \
+                    % (self.encoding, ord(self.character), self.reason,
+                            self.name, self.position)
+        else:
+            return "unacceptable character #x%04x: %s\n"    \
+                    "  in \"%s\", position %d"    \
+                    % (self.character, self.reason,
+                            self.name, self.position)
+
+class Reader(object):
+    # Reader:
+    # - determines the data encoding and converts it to unicode,
+    # - checks if characters are in allowed range,
+    # - adds '\0' to the end.
+
+    # Reader accepts
+    #  - a `str` object,
+    #  - a `unicode` object,
+    #  - a file-like object with its `read` method returning `str`,
+    #  - a file-like object with its `read` method returning `unicode`.
+
+    # Yeah, it's ugly and slow.
+
+    def __init__(self, stream):
+        self.name = None
+        self.stream = None
+        self.stream_pointer = 0
+        self.eof = True
+        self.buffer = u''
+        self.pointer = 0
+        self.raw_buffer = None
+        self.raw_decode = None
+        self.encoding = None
+        self.index = 0
+        self.line = 0
+        self.column = 0
+        if isinstance(stream, unicode):
+            self.name = "<unicode string>"
+            self.check_printable(stream)
+            self.buffer = stream+u'\0'
+        elif isinstance(stream, str):
+            self.name = "<string>"
+            self.raw_buffer = stream
+            self.determine_encoding()
+        else:
+            self.stream = stream
+            self.name = getattr(stream, 'name', "<file>")
+            self.eof = False
+            self.raw_buffer = ''
+            self.determine_encoding()
+
+    def peek(self, index=0):
+        try:
+            return self.buffer[self.pointer+index]
+        except IndexError:
+            self.update(index+1)
+            return self.buffer[self.pointer+index]
+
+    def prefix(self, length=1):
+        if self.pointer+length >= len(self.buffer):
+            self.update(length)
+        return self.buffer[self.pointer:self.pointer+length]
+
+    def forward(self, length=1):
+        if self.pointer+length+1 >= len(self.buffer):
+            self.update(length+1)
+        while length:
+            ch = self.buffer[self.pointer]
+            self.pointer += 1
+            self.index += 1
+            if ch in u'\n\x85\u2028\u2029'  \
+                    or (ch == u'\r' and self.buffer[self.pointer] != u'\n'):
+                self.line += 1
+                self.column = 0
+            elif ch != u'\uFEFF':
+                self.column += 1
+            length -= 1
+
+    def get_mark(self):
+        if self.stream is None:
+            return Mark(self.name, self.index, self.line, self.column,
+                    self.buffer, self.pointer)
+        else:
+            return Mark(self.name, self.index, self.line, self.column,
+                    None, None)
+
+    def determine_encoding(self):
+        while not self.eof and len(self.raw_buffer) < 2:
+            self.update_raw()
+        if not isinstance(self.raw_buffer, unicode):
+            if self.raw_buffer.startswith(codecs.BOM_UTF16_LE):
+                self.raw_decode = codecs.utf_16_le_decode
+                self.encoding = 'utf-16-le'
+            elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE):
+                self.raw_decode = codecs.utf_16_be_decode
+                self.encoding = 'utf-16-be'
+            else:
+                self.raw_decode = codecs.utf_8_decode
+                self.encoding = 'utf-8'
+        self.update(1)
+
+    NON_PRINTABLE = re.compile(u'[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD]')
+    def check_printable(self, data):
+        match = self.NON_PRINTABLE.search(data)
+        if match:
+            character = match.group()
+            position = self.index+(len(self.buffer)-self.pointer)+match.start()
+            raise ReaderError(self.name, position, ord(character),
+                    'unicode', "special characters are not allowed")
+
+    def update(self, length):
+        if self.raw_buffer is None:
+            return
+        self.buffer = self.buffer[self.pointer:]
+        self.pointer = 0
+        while len(self.buffer) < length:
+            if not self.eof:
+                self.update_raw()
+            if self.raw_decode is not None:
+                try:
+                    data, converted = self.raw_decode(self.raw_buffer,
+                            'strict', self.eof)
+                except UnicodeDecodeError, exc:
+                    character = exc.object[exc.start]
+                    if self.stream is not None:
+                        position = self.stream_pointer-len(self.raw_buffer)+exc.start
+                    else:
+                        position = exc.start
+                    raise ReaderError(self.name, position, character,
+                            exc.encoding, exc.reason)
+            else:
+                data = self.raw_buffer
+                converted = len(data)
+            self.check_printable(data)
+            self.buffer += data
+            self.raw_buffer = self.raw_buffer[converted:]
+            if self.eof:
+                self.buffer += u'\0'
+                self.raw_buffer = None
+                break
+
+    def update_raw(self, size=1024):
+        data = self.stream.read(size)
+        if data:
+            self.raw_buffer += data
+            self.stream_pointer += len(data)
+        else:
+            self.eof = True
+
+#try:
+#    import psyco
+#    psyco.bind(Reader)
+#except ImportError:
+#    pass
+
diff --git a/libs/py2/yaml/representer.py b/libs/py2/yaml/representer.py
new file mode 100644
index 00000000..4ea8cb1f
--- /dev/null
+++ b/libs/py2/yaml/representer.py
@@ -0,0 +1,486 @@
+
+__all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer',
+    'RepresenterError']
+
+from error import *
+from nodes import *
+
+import datetime
+
+import sys, copy_reg, types
+
+class RepresenterError(YAMLError):
+    pass
+
+class BaseRepresenter(object):
+
+    yaml_representers = {}
+    yaml_multi_representers = {}
+
+    def __init__(self, default_style=None, default_flow_style=None):
+        self.default_style = default_style
+        self.default_flow_style = default_flow_style
+        self.represented_objects = {}
+        self.object_keeper = []
+        self.alias_key = None
+
+    def represent(self, data):
+        node = self.represent_data(data)
+        self.serialize(node)
+        self.represented_objects = {}
+        self.object_keeper = []
+        self.alias_key = None
+
+    def get_classobj_bases(self, cls):
+        bases = [cls]
+        for base in cls.__bases__:
+            bases.extend(self.get_classobj_bases(base))
+        return bases
+
+    def represent_data(self, data):
+        if self.ignore_aliases(data):
+            self.alias_key = None
+        else:
+            self.alias_key = id(data)
+        if self.alias_key is not None:
+            if self.alias_key in self.represented_objects:
+                node = self.represented_objects[self.alias_key]
+                #if node is None:
+                #    raise RepresenterError("recursive objects are not allowed: %r" % data)
+                return node
+            #self.represented_objects[alias_key] = None
+            self.object_keeper.append(data)
+        data_types = type(data).__mro__
+        if type(data) is types.InstanceType:
+            data_types = self.get_classobj_bases(data.__class__)+list(data_types)
+        if data_types[0] in self.yaml_representers:
+            node = self.yaml_representers[data_types[0]](self, data)
+        else:
+            for data_type in data_types:
+                if data_type in self.yaml_multi_representers:
+                    node = self.yaml_multi_representers[data_type](self, data)
+                    break
+            else:
+                if None in self.yaml_multi_representers:
+                    node = self.yaml_multi_representers[None](self, data)
+                elif None in self.yaml_representers:
+                    node = self.yaml_representers[None](self, data)
+                else:
+                    node = ScalarNode(None, unicode(data))
+        #if alias_key is not None:
+        #    self.represented_objects[alias_key] = node
+        return node
+
+    def add_representer(cls, data_type, representer):
+        if not 'yaml_representers' in cls.__dict__:
+            cls.yaml_representers = cls.yaml_representers.copy()
+        cls.yaml_representers[data_type] = representer
+    add_representer = classmethod(add_representer)
+
+    def add_multi_representer(cls, data_type, representer):
+        if not 'yaml_multi_representers' in cls.__dict__:
+            cls.yaml_multi_representers = cls.yaml_multi_representers.copy()
+        cls.yaml_multi_representers[data_type] = representer
+    add_multi_representer = classmethod(add_multi_representer)
+
+    def represent_scalar(self, tag, value, style=None):
+        if style is None:
+            style = self.default_style
+        node = ScalarNode(tag, value, style=style)
+        if self.alias_key is not None:
+            self.represented_objects[self.alias_key] = node
+        return node
+
+    def represent_sequence(self, tag, sequence, flow_style=None):
+        value = []
+        node = SequenceNode(tag, value, flow_style=flow_style)
+        if self.alias_key is not None:
+            self.represented_objects[self.alias_key] = node
+        best_style = True
+        for item in sequence:
+            node_item = self.represent_data(item)
+            if not (isinstance(node_item, ScalarNode) and not node_item.style):
+                best_style = False
+            value.append(node_item)
+        if flow_style is None:
+            if self.default_flow_style is not None:
+                node.flow_style = self.default_flow_style
+            else:
+                node.flow_style = best_style
+        return node
+
+    def represent_mapping(self, tag, mapping, flow_style=None):
+        value = []
+        node = MappingNode(tag, value, flow_style=flow_style)
+        if self.alias_key is not None:
+            self.represented_objects[self.alias_key] = node
+        best_style = True
+        if hasattr(mapping, 'items'):
+            mapping = mapping.items()
+            mapping.sort()
+        for item_key, item_value in mapping:
+            node_key = self.represent_data(item_key)
+            node_value = self.represent_data(item_value)
+            if not (isinstance(node_key, ScalarNode) and not node_key.style):
+                best_style = False
+            if not (isinstance(node_value, ScalarNode) and not node_value.style):
+                best_style = False
+            value.append((node_key, node_value))
+        if flow_style is None:
+            if self.default_flow_style is not None:
+                node.flow_style = self.default_flow_style
+            else:
+                node.flow_style = best_style
+        return node
+
+    def ignore_aliases(self, data):
+        return False
+
+class SafeRepresenter(BaseRepresenter):
+
+    def ignore_aliases(self, data):
+        if data is None:
+            return True
+        if isinstance(data, tuple) and data == ():
+            return True
+        if isinstance(data, (str, unicode, bool, int, float)):
+            return True
+
+    def represent_none(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:null',
+                u'null')
+
+    def represent_str(self, data):
+        tag = None
+        style = None
+        try:
+            data = unicode(data, 'ascii')
+            tag = u'tag:yaml.org,2002:str'
+        except UnicodeDecodeError:
+            try:
+                data = unicode(data, 'utf-8')
+                tag = u'tag:yaml.org,2002:str'
+            except UnicodeDecodeError:
+                data = data.encode('base64')
+                tag = u'tag:yaml.org,2002:binary'
+                style = '|'
+        return self.represent_scalar(tag, data, style=style)
+
+    def represent_unicode(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:str', data)
+
+    def represent_bool(self, data):
+        if data:
+            value = u'true'
+        else:
+            value = u'false'
+        return self.represent_scalar(u'tag:yaml.org,2002:bool', value)
+
+    def represent_int(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data))
+
+    def represent_long(self, data):
+        return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data))
+
+    inf_value = 1e300
+    while repr(inf_value) != repr(inf_value*inf_value):
+        inf_value *= inf_value
+
+    def represent_float(self, data):
+        if data != data or (data == 0.0 and data == 1.0):
+            value = u'.nan'
+        elif data == self.inf_value:
+            value = u'.inf'
+        elif data == -self.inf_value:
+            value = u'-.inf'
+        else:
+            value = unicode(repr(data)).lower()
+            # Note that in some cases `repr(data)` represents a float number
+            # without the decimal parts.  For instance:
+            #   >>> repr(1e17)
+            #   '1e17'
+            # Unfortunately, this is not a valid float representation according
+            # to the definition of the `!!float` tag.  We fix this by adding
+            # '.0' before the 'e' symbol.
+            if u'.' not in value and u'e' in value:
+                value = value.replace(u'e', u'.0e', 1)
+        return self.represent_scalar(u'tag:yaml.org,2002:float', value)
+
+    def represent_list(self, data):
+        #pairs = (len(data) > 0 and isinstance(data, list))
+        #if pairs:
+        #    for item in data:
+        #        if not isinstance(item, tuple) or len(item) != 2:
+        #            pairs = False
+        #            break
+        #if not pairs:
+            return self.represent_sequence(u'tag:yaml.org,2002:seq', data)
+        #value = []
+        #for item_key, item_value in data:
+        #    value.append(self.represent_mapping(u'tag:yaml.org,2002:map',
+        #        [(item_key, item_value)]))
+        #return SequenceNode(u'tag:yaml.org,2002:pairs', value)
+
+    def represent_dict(self, data):
+        return self.represent_mapping(u'tag:yaml.org,2002:map', data)
+
+    def represent_set(self, data):
+        value = {}
+        for key in data:
+            value[key] = None
+        return self.represent_mapping(u'tag:yaml.org,2002:set', value)
+
+    def represent_date(self, data):
+        value = unicode(data.isoformat())
+        return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value)
+
+    def represent_datetime(self, data):
+        value = unicode(data.isoformat(' '))
+        return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value)
+
+    def represent_yaml_object(self, tag, data, cls, flow_style=None):
+        if hasattr(data, '__getstate__'):
+            state = data.__getstate__()
+        else:
+            state = data.__dict__.copy()
+        return self.represent_mapping(tag, state, flow_style=flow_style)
+
+    def represent_undefined(self, data):
+        raise RepresenterError("cannot represent an object: %s" % data)
+
+SafeRepresenter.add_representer(type(None),
+        SafeRepresenter.represent_none)
+
+SafeRepresenter.add_representer(str,
+        SafeRepresenter.represent_str)
+
+SafeRepresenter.add_representer(unicode,
+        SafeRepresenter.represent_unicode)
+
+SafeRepresenter.add_representer(bool,
+        SafeRepresenter.represent_bool)
+
+SafeRepresenter.add_representer(int,
+        SafeRepresenter.represent_int)
+
+SafeRepresenter.add_representer(long,
+        SafeRepresenter.represent_long)
+
+SafeRepresenter.add_representer(float,
+        SafeRepresenter.represent_float)
+
+SafeRepresenter.add_representer(list,
+        SafeRepresenter.represent_list)
+
+SafeRepresenter.add_representer(tuple,
+        SafeRepresenter.represent_list)
+
+SafeRepresenter.add_representer(dict,
+        SafeRepresenter.represent_dict)
+
+SafeRepresenter.add_representer(set,
+        SafeRepresenter.represent_set)
+
+SafeRepresenter.add_representer(datetime.date,
+        SafeRepresenter.represent_date)
+
+SafeRepresenter.add_representer(datetime.datetime,
+        SafeRepresenter.represent_datetime)
+
+SafeRepresenter.add_representer(None,
+        SafeRepresenter.represent_undefined)
+
+class Representer(SafeRepresenter):
+
+    def represent_str(self, data):
+        tag = None
+        style = None
+        try:
+            data = unicode(data, 'ascii')
+            tag = u'tag:yaml.org,2002:str'
+        except UnicodeDecodeError:
+            try:
+                data = unicode(data, 'utf-8')
+                tag = u'tag:yaml.org,2002:python/str'
+            except UnicodeDecodeError:
+                data = data.encode('base64')
+                tag = u'tag:yaml.org,2002:binary'
+                style = '|'
+        return self.represent_scalar(tag, data, style=style)
+
+    def represent_unicode(self, data):
+        tag = None
+        try:
+            data.encode('ascii')
+            tag = u'tag:yaml.org,2002:python/unicode'
+        except UnicodeEncodeError:
+            tag = u'tag:yaml.org,2002:str'
+        return self.represent_scalar(tag, data)
+
+    def represent_long(self, data):
+        tag = u'tag:yaml.org,2002:int'
+        if int(data) is not data:
+            tag = u'tag:yaml.org,2002:python/long'
+        return self.represent_scalar(tag, unicode(data))
+
+    def represent_complex(self, data):
+        if data.imag == 0.0:
+            data = u'%r' % data.real
+        elif data.real == 0.0:
+            data = u'%rj' % data.imag
+        elif data.imag > 0:
+            data = u'%r+%rj' % (data.real, data.imag)
+        else:
+            data = u'%r%rj' % (data.real, data.imag)
+        return self.represent_scalar(u'tag:yaml.org,2002:python/complex', data)
+
+    def represent_tuple(self, data):
+        return self.represent_sequence(u'tag:yaml.org,2002:python/tuple', data)
+
+    def represent_name(self, data):
+        name = u'%s.%s' % (data.__module__, data.__name__)
+        return self.represent_scalar(u'tag:yaml.org,2002:python/name:'+name, u'')
+
+    def represent_module(self, data):
+        return self.represent_scalar(
+                u'tag:yaml.org,2002:python/module:'+data.__name__, u'')
+
+    def represent_instance(self, data):
+        # For instances of classic classes, we use __getinitargs__ and
+        # __getstate__ to serialize the data.
+
+        # If data.__getinitargs__ exists, the object must be reconstructed by
+        # calling cls(**args), where args is a tuple returned by
+        # __getinitargs__. Otherwise, the cls.__init__ method should never be
+        # called and the class instance is created by instantiating a trivial
+        # class and assigning to the instance's __class__ variable.
+
+        # If data.__getstate__ exists, it returns the state of the object.
+        # Otherwise, the state of the object is data.__dict__.
+
+        # We produce either a !!python/object or !!python/object/new node.
+        # If data.__getinitargs__ does not exist and state is a dictionary, we
+        # produce a !!python/object node . Otherwise we produce a
+        # !!python/object/new node.
+
+        cls = data.__class__
+        class_name = u'%s.%s' % (cls.__module__, cls.__name__)
+        args = None
+        state = None
+        if hasattr(data, '__getinitargs__'):
+            args = list(data.__getinitargs__())
+        if hasattr(data, '__getstate__'):
+            state = data.__getstate__()
+        else:
+            state = data.__dict__
+        if args is None and isinstance(state, dict):
+            return self.represent_mapping(
+                    u'tag:yaml.org,2002:python/object:'+class_name, state)
+        if isinstance(state, dict) and not state:
+            return self.represent_sequence(
+                    u'tag:yaml.org,2002:python/object/new:'+class_name, args)
+        value = {}
+        if args:
+            value['args'] = args
+        value['state'] = state
+        return self.represent_mapping(
+                u'tag:yaml.org,2002:python/object/new:'+class_name, value)
+
+    def represent_object(self, data):
+        # We use __reduce__ API to save the data. data.__reduce__ returns
+        # a tuple of length 2-5:
+        #   (function, args, state, listitems, dictitems)
+
+        # For reconstructing, we calls function(*args), then set its state,
+        # listitems, and dictitems if they are not None.
+
+        # A special case is when function.__name__ == '__newobj__'. In this
+        # case we create the object with args[0].__new__(*args).
+
+        # Another special case is when __reduce__ returns a string - we don't
+        # support it.
+
+        # We produce a !!python/object, !!python/object/new or
+        # !!python/object/apply node.
+
+        cls = type(data)
+        if cls in copy_reg.dispatch_table:
+            reduce = copy_reg.dispatch_table[cls](data)
+        elif hasattr(data, '__reduce_ex__'):
+            reduce = data.__reduce_ex__(2)
+        elif hasattr(data, '__reduce__'):
+            reduce = data.__reduce__()
+        else:
+            raise RepresenterError("cannot represent object: %r" % data)
+        reduce = (list(reduce)+[None]*5)[:5]
+        function, args, state, listitems, dictitems = reduce
+        args = list(args)
+        if state is None:
+            state = {}
+        if listitems is not None:
+            listitems = list(listitems)
+        if dictitems is not None:
+            dictitems = dict(dictitems)
+        if function.__name__ == '__newobj__':
+            function = args[0]
+            args = args[1:]
+            tag = u'tag:yaml.org,2002:python/object/new:'
+            newobj = True
+        else:
+            tag = u'tag:yaml.org,2002:python/object/apply:'
+            newobj = False
+        function_name = u'%s.%s' % (function.__module__, function.__name__)
+        if not args and not listitems and not dictitems \
+                and isinstance(state, dict) and newobj:
+            return self.represent_mapping(
+                    u'tag:yaml.org,2002:python/object:'+function_name, state)
+        if not listitems and not dictitems  \
+                and isinstance(state, dict) and not state:
+            return self.represent_sequence(tag+function_name, args)
+        value = {}
+        if args:
+            value['args'] = args
+        if state or not isinstance(state, dict):
+            value['state'] = state
+        if listitems:
+            value['listitems'] = listitems
+        if dictitems:
+            value['dictitems'] = dictitems
+        return self.represent_mapping(tag+function_name, value)
+
+Representer.add_representer(str,
+        Representer.represent_str)
+
+Representer.add_representer(unicode,
+        Representer.represent_unicode)
+
+Representer.add_representer(long,
+        Representer.represent_long)
+
+Representer.add_representer(complex,
+        Representer.represent_complex)
+
+Representer.add_representer(tuple,
+        Representer.represent_tuple)
+
+Representer.add_representer(type,
+        Representer.represent_name)
+
+Representer.add_representer(types.ClassType,
+        Representer.represent_name)
+
+Representer.add_representer(types.FunctionType,
+        Representer.represent_name)
+
+Representer.add_representer(types.BuiltinFunctionType,
+        Representer.represent_name)
+
+Representer.add_representer(types.ModuleType,
+        Representer.represent_module)
+
+Representer.add_multi_representer(types.InstanceType,
+        Representer.represent_instance)
+
+Representer.add_multi_representer(object,
+        Representer.represent_object)
+
diff --git a/libs/py2/yaml/resolver.py b/libs/py2/yaml/resolver.py
new file mode 100644
index 00000000..528fbc0e
--- /dev/null
+++ b/libs/py2/yaml/resolver.py
@@ -0,0 +1,227 @@
+
+__all__ = ['BaseResolver', 'Resolver']
+
+from error import *
+from nodes import *
+
+import re
+
+class ResolverError(YAMLError):
+    pass
+
+class BaseResolver(object):
+
+    DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str'
+    DEFAULT_SEQUENCE_TAG = u'tag:yaml.org,2002:seq'
+    DEFAULT_MAPPING_TAG = u'tag:yaml.org,2002:map'
+
+    yaml_implicit_resolvers = {}
+    yaml_path_resolvers = {}
+
+    def __init__(self):
+        self.resolver_exact_paths = []
+        self.resolver_prefix_paths = []
+
+    def add_implicit_resolver(cls, tag, regexp, first):
+        if not 'yaml_implicit_resolvers' in cls.__dict__:
+            implicit_resolvers = {}
+            for key in cls.yaml_implicit_resolvers:
+                implicit_resolvers[key] = cls.yaml_implicit_resolvers[key][:]
+            cls.yaml_implicit_resolvers = implicit_resolvers
+        if first is None:
+            first = [None]
+        for ch in first:
+            cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp))
+    add_implicit_resolver = classmethod(add_implicit_resolver)
+
+    def add_path_resolver(cls, tag, path, kind=None):
+        # Note: `add_path_resolver` is experimental.  The API could be changed.
+        # `new_path` is a pattern that is matched against the path from the
+        # root to the node that is being considered.  `node_path` elements are
+        # tuples `(node_check, index_check)`.  `node_check` is a node class:
+        # `ScalarNode`, `SequenceNode`, `MappingNode` or `None`.  `None`
+        # matches any kind of a node.  `index_check` could be `None`, a boolean
+        # value, a string value, or a number.  `None` and `False` match against
+        # any _value_ of sequence and mapping nodes.  `True` matches against
+        # any _key_ of a mapping node.  A string `index_check` matches against
+        # a mapping value that corresponds to a scalar key which content is
+        # equal to the `index_check` value.  An integer `index_check` matches
+        # against a sequence value with the index equal to `index_check`.
+        if not 'yaml_path_resolvers' in cls.__dict__:
+            cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy()
+        new_path = []
+        for element in path:
+            if isinstance(element, (list, tuple)):
+                if len(element) == 2:
+                    node_check, index_check = element
+                elif len(element) == 1:
+                    node_check = element[0]
+                    index_check = True
+                else:
+                    raise ResolverError("Invalid path element: %s" % element)
+            else:
+                node_check = None
+                index_check = element
+            if node_check is str:
+                node_check = ScalarNode
+            elif node_check is list:
+                node_check = SequenceNode
+            elif node_check is dict:
+                node_check = MappingNode
+            elif node_check not in [ScalarNode, SequenceNode, MappingNode]  \
+                    and not isinstance(node_check, basestring)  \
+                    and node_check is not None:
+                raise ResolverError("Invalid node checker: %s" % node_check)
+            if not isinstance(index_check, (basestring, int))   \
+                    and index_check is not None:
+                raise ResolverError("Invalid index checker: %s" % index_check)
+            new_path.append((node_check, index_check))
+        if kind is str:
+            kind = ScalarNode
+        elif kind is list:
+            kind = SequenceNode
+        elif kind is dict:
+            kind = MappingNode
+        elif kind not in [ScalarNode, SequenceNode, MappingNode]    \
+                and kind is not None:
+            raise ResolverError("Invalid node kind: %s" % kind)
+        cls.yaml_path_resolvers[tuple(new_path), kind] = tag
+    add_path_resolver = classmethod(add_path_resolver)
+
+    def descend_resolver(self, current_node, current_index):
+        if not self.yaml_path_resolvers:
+            return
+        exact_paths = {}
+        prefix_paths = []
+        if current_node:
+            depth = len(self.resolver_prefix_paths)
+            for path, kind in self.resolver_prefix_paths[-1]:
+                if self.check_resolver_prefix(depth, path, kind,
+                        current_node, current_index):
+                    if len(path) > depth:
+                        prefix_paths.append((path, kind))
+                    else:
+                        exact_paths[kind] = self.yaml_path_resolvers[path, kind]
+        else:
+            for path, kind in self.yaml_path_resolvers:
+                if not path:
+                    exact_paths[kind] = self.yaml_path_resolvers[path, kind]
+                else:
+                    prefix_paths.append((path, kind))
+        self.resolver_exact_paths.append(exact_paths)
+        self.resolver_prefix_paths.append(prefix_paths)
+
+    def ascend_resolver(self):
+        if not self.yaml_path_resolvers:
+            return
+        self.resolver_exact_paths.pop()
+        self.resolver_prefix_paths.pop()
+
+    def check_resolver_prefix(self, depth, path, kind,
+            current_node, current_index):
+        node_check, index_check = path[depth-1]
+        if isinstance(node_check, basestring):
+            if current_node.tag != node_check:
+                return
+        elif node_check is not None:
+            if not isinstance(current_node, node_check):
+                return
+        if index_check is True and current_index is not None:
+            return
+        if (index_check is False or index_check is None)    \
+                and current_index is None:
+            return
+        if isinstance(index_check, basestring):
+            if not (isinstance(current_index, ScalarNode)
+                    and index_check == current_index.value):
+                return
+        elif isinstance(index_check, int) and not isinstance(index_check, bool):
+            if index_check != current_index:
+                return
+        return True
+
+    def resolve(self, kind, value, implicit):
+        if kind is ScalarNode and implicit[0]:
+            if value == u'':
+                resolvers = self.yaml_implicit_resolvers.get(u'', [])
+            else:
+                resolvers = self.yaml_implicit_resolvers.get(value[0], [])
+            resolvers += self.yaml_implicit_resolvers.get(None, [])
+            for tag, regexp in resolvers:
+                if regexp.match(value):
+                    return tag
+            implicit = implicit[1]
+        if self.yaml_path_resolvers:
+            exact_paths = self.resolver_exact_paths[-1]
+            if kind in exact_paths:
+                return exact_paths[kind]
+            if None in exact_paths:
+                return exact_paths[None]
+        if kind is ScalarNode:
+            return self.DEFAULT_SCALAR_TAG
+        elif kind is SequenceNode:
+            return self.DEFAULT_SEQUENCE_TAG
+        elif kind is MappingNode:
+            return self.DEFAULT_MAPPING_TAG
+
+class Resolver(BaseResolver):
+    pass
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:bool',
+        re.compile(ur'''^(?:yes|Yes|YES|no|No|NO
+                    |true|True|TRUE|false|False|FALSE
+                    |on|On|ON|off|Off|OFF)$''', re.X),
+        list(u'yYnNtTfFoO'))
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:float',
+        re.compile(ur'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?
+                    |\.[0-9_]+(?:[eE][-+][0-9]+)?
+                    |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
+                    |[-+]?\.(?:inf|Inf|INF)
+                    |\.(?:nan|NaN|NAN))$''', re.X),
+        list(u'-+0123456789.'))
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:int',
+        re.compile(ur'''^(?:[-+]?0b[0-1_]+
+                    |[-+]?0[0-7_]+
+                    |[-+]?(?:0|[1-9][0-9_]*)
+                    |[-+]?0x[0-9a-fA-F_]+
+                    |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X),
+        list(u'-+0123456789'))
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:merge',
+        re.compile(ur'^(?:<<)$'),
+        [u'<'])
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:null',
+        re.compile(ur'''^(?: ~
+                    |null|Null|NULL
+                    | )$''', re.X),
+        [u'~', u'n', u'N', u''])
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:timestamp',
+        re.compile(ur'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]
+                    |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]?
+                     (?:[Tt]|[ \t]+)[0-9][0-9]?
+                     :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)?
+                     (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X),
+        list(u'0123456789'))
+
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:value',
+        re.compile(ur'^(?:=)$'),
+        [u'='])
+
+# The following resolver is only for documentation purposes. It cannot work
+# because plain scalars cannot start with '!', '&', or '*'.
+Resolver.add_implicit_resolver(
+        u'tag:yaml.org,2002:yaml',
+        re.compile(ur'^(?:!|&|\*)$'),
+        list(u'!&*'))
+
diff --git a/libs/py2/yaml/scanner.py b/libs/py2/yaml/scanner.py
new file mode 100644
index 00000000..834f662a
--- /dev/null
+++ b/libs/py2/yaml/scanner.py
@@ -0,0 +1,1453 @@
+
+# Scanner produces tokens of the following types:
+# STREAM-START
+# STREAM-END
+# DIRECTIVE(name, value)
+# DOCUMENT-START
+# DOCUMENT-END
+# BLOCK-SEQUENCE-START
+# BLOCK-MAPPING-START
+# BLOCK-END
+# FLOW-SEQUENCE-START
+# FLOW-MAPPING-START
+# FLOW-SEQUENCE-END
+# FLOW-MAPPING-END
+# BLOCK-ENTRY
+# FLOW-ENTRY
+# KEY
+# VALUE
+# ALIAS(value)
+# ANCHOR(value)
+# TAG(value)
+# SCALAR(value, plain, style)
+#
+# Read comments in the Scanner code for more details.
+#
+
+__all__ = ['Scanner', 'ScannerError']
+
+from error import MarkedYAMLError
+from tokens import *
+
+class ScannerError(MarkedYAMLError):
+    pass
+
+class SimpleKey(object):
+    # See below simple keys treatment.
+
+    def __init__(self, token_number, required, index, line, column, mark):
+        self.token_number = token_number
+        self.required = required
+        self.index = index
+        self.line = line
+        self.column = column
+        self.mark = mark
+
+class Scanner(object):
+
+    def __init__(self):
+        """Initialize the scanner."""
+        # It is assumed that Scanner and Reader will have a common descendant.
+        # Reader do the dirty work of checking for BOM and converting the
+        # input data to Unicode. It also adds NUL to the end.
+        #
+        # Reader supports the following methods
+        #   self.peek(i=0)       # peek the next i-th character
+        #   self.prefix(l=1)     # peek the next l characters
+        #   self.forward(l=1)    # read the next l characters and move the pointer.
+
+        # Had we reached the end of the stream?
+        self.done = False
+
+        # The number of unclosed '{' and '['. `flow_level == 0` means block
+        # context.
+        self.flow_level = 0
+
+        # List of processed tokens that are not yet emitted.
+        self.tokens = []
+
+        # Add the STREAM-START token.
+        self.fetch_stream_start()
+
+        # Number of tokens that were emitted through the `get_token` method.
+        self.tokens_taken = 0
+
+        # The current indentation level.
+        self.indent = -1
+
+        # Past indentation levels.
+        self.indents = []
+
+        # Variables related to simple keys treatment.
+
+        # A simple key is a key that is not denoted by the '?' indicator.
+        # Example of simple keys:
+        #   ---
+        #   block simple key: value
+        #   ? not a simple key:
+        #   : { flow simple key: value }
+        # We emit the KEY token before all keys, so when we find a potential
+        # simple key, we try to locate the corresponding ':' indicator.
+        # Simple keys should be limited to a single line and 1024 characters.
+
+        # Can a simple key start at the current position? A simple key may
+        # start:
+        # - at the beginning of the line, not counting indentation spaces
+        #       (in block context),
+        # - after '{', '[', ',' (in the flow context),
+        # - after '?', ':', '-' (in the block context).
+        # In the block context, this flag also signifies if a block collection
+        # may start at the current position.
+        self.allow_simple_key = True
+
+        # Keep track of possible simple keys. This is a dictionary. The key
+        # is `flow_level`; there can be no more that one possible simple key
+        # for each level. The value is a SimpleKey record:
+        #   (token_number, required, index, line, column, mark)
+        # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow),
+        # '[', or '{' tokens.
+        self.possible_simple_keys = {}
+
+    # Public methods.
+
+    def check_token(self, *choices):
+        # Check if the next token is one of the given types.
+        while self.need_more_tokens():
+            self.fetch_more_tokens()
+        if self.tokens:
+            if not choices:
+                return True
+            for choice in choices:
+                if isinstance(self.tokens[0], choice):
+                    return True
+        return False
+
+    def peek_token(self):
+        # Return the next token, but do not delete if from the queue.
+        while self.need_more_tokens():
+            self.fetch_more_tokens()
+        if self.tokens:
+            return self.tokens[0]
+
+    def get_token(self):
+        # Return the next token.
+        while self.need_more_tokens():
+            self.fetch_more_tokens()
+        if self.tokens:
+            self.tokens_taken += 1
+            return self.tokens.pop(0)
+
+    # Private methods.
+
+    def need_more_tokens(self):
+        if self.done:
+            return False
+        if not self.tokens:
+            return True
+        # The current token may be a potential simple key, so we
+        # need to look further.
+        self.stale_possible_simple_keys()
+        if self.next_possible_simple_key() == self.tokens_taken:
+            return True
+
+    def fetch_more_tokens(self):
+
+        # Eat whitespaces and comments until we reach the next token.
+        self.scan_to_next_token()
+
+        # Remove obsolete possible simple keys.
+        self.stale_possible_simple_keys()
+
+        # Compare the current indentation and column. It may add some tokens
+        # and decrease the current indentation level.
+        self.unwind_indent(self.column)
+
+        # Peek the next character.
+        ch = self.peek()
+
+        # Is it the end of stream?
+        if ch == u'\0':
+            return self.fetch_stream_end()
+
+        # Is it a directive?
+        if ch == u'%' and self.check_directive():
+            return self.fetch_directive()
+
+        # Is it the document start?
+        if ch == u'-' and self.check_document_start():
+            return self.fetch_document_start()
+
+        # Is it the document end?
+        if ch == u'.' and self.check_document_end():
+            return self.fetch_document_end()
+
+        # TODO: support for BOM within a stream.
+        #if ch == u'\uFEFF':
+        #    return self.fetch_bom()    <-- issue BOMToken
+
+        # Note: the order of the following checks is NOT significant.
+
+        # Is it the flow sequence start indicator?
+        if ch == u'[':
+            return self.fetch_flow_sequence_start()
+
+        # Is it the flow mapping start indicator?
+        if ch == u'{':
+            return self.fetch_flow_mapping_start()
+
+        # Is it the flow sequence end indicator?
+        if ch == u']':
+            return self.fetch_flow_sequence_end()
+
+        # Is it the flow mapping end indicator?
+        if ch == u'}':
+            return self.fetch_flow_mapping_end()
+
+        # Is it the flow entry indicator?
+        if ch == u',':
+            return self.fetch_flow_entry()
+
+        # Is it the block entry indicator?
+        if ch == u'-' and self.check_block_entry():
+            return self.fetch_block_entry()
+
+        # Is it the key indicator?
+        if ch == u'?' and self.check_key():
+            return self.fetch_key()
+
+        # Is it the value indicator?
+        if ch == u':' and self.check_value():
+            return self.fetch_value()
+
+        # Is it an alias?
+        if ch == u'*':
+            return self.fetch_alias()
+
+        # Is it an anchor?
+        if ch == u'&':
+            return self.fetch_anchor()
+
+        # Is it a tag?
+        if ch == u'!':
+            return self.fetch_tag()
+
+        # Is it a literal scalar?
+        if ch == u'|' and not self.flow_level:
+            return self.fetch_literal()
+
+        # Is it a folded scalar?
+        if ch == u'>' and not self.flow_level:
+            return self.fetch_folded()
+
+        # Is it a single quoted scalar?
+        if ch == u'\'':
+            return self.fetch_single()
+
+        # Is it a double quoted scalar?
+        if ch == u'\"':
+            return self.fetch_double()
+
+        # It must be a plain scalar then.
+        if self.check_plain():
+            return self.fetch_plain()
+
+        # No? It's an error. Let's produce a nice error message.
+        raise ScannerError("while scanning for the next token", None,
+                "found character %r that cannot start any token"
+                % ch.encode('utf-8'), self.get_mark())
+
+    # Simple keys treatment.
+
+    def next_possible_simple_key(self):
+        # Return the number of the nearest possible simple key. Actually we
+        # don't need to loop through the whole dictionary. We may replace it
+        # with the following code:
+        #   if not self.possible_simple_keys:
+        #       return None
+        #   return self.possible_simple_keys[
+        #           min(self.possible_simple_keys.keys())].token_number
+        min_token_number = None
+        for level in self.possible_simple_keys:
+            key = self.possible_simple_keys[level]
+            if min_token_number is None or key.token_number < min_token_number:
+                min_token_number = key.token_number
+        return min_token_number
+
+    def stale_possible_simple_keys(self):
+        # Remove entries that are no longer possible simple keys. According to
+        # the YAML specification, simple keys
+        # - should be limited to a single line,
+        # - should be no longer than 1024 characters.
+        # Disabling this procedure will allow simple keys of any length and
+        # height (may cause problems if indentation is broken though).
+        for level in self.possible_simple_keys.keys():
+            key = self.possible_simple_keys[level]
+            if key.line != self.line  \
+                    or self.index-key.index > 1024:
+                if key.required:
+                    raise ScannerError("while scanning a simple key", key.mark,
+                            "could not find expected ':'", self.get_mark())
+                del self.possible_simple_keys[level]
+
+    def save_possible_simple_key(self):
+        # The next token may start a simple key. We check if it's possible
+        # and save its position. This function is called for
+        #   ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'.
+
+        # Check if a simple key is required at the current position.
+        required = not self.flow_level and self.indent == self.column
+
+        # The next token might be a simple key. Let's save it's number and
+        # position.
+        if self.allow_simple_key:
+            self.remove_possible_simple_key()
+            token_number = self.tokens_taken+len(self.tokens)
+            key = SimpleKey(token_number, required,
+                    self.index, self.line, self.column, self.get_mark())
+            self.possible_simple_keys[self.flow_level] = key
+
+    def remove_possible_simple_key(self):
+        # Remove the saved possible key position at the current flow level.
+        if self.flow_level in self.possible_simple_keys:
+            key = self.possible_simple_keys[self.flow_level]
+            
+            if key.required:
+                raise ScannerError("while scanning a simple key", key.mark,
+                        "could not find expected ':'", self.get_mark())
+
+            del self.possible_simple_keys[self.flow_level]
+
+    # Indentation functions.
+
+    def unwind_indent(self, column):
+
+        ## In flow context, tokens should respect indentation.
+        ## Actually the condition should be `self.indent >= column` according to
+        ## the spec. But this condition will prohibit intuitively correct
+        ## constructions such as
+        ## key : {
+        ## }
+        #if self.flow_level and self.indent > column:
+        #    raise ScannerError(None, None,
+        #            "invalid intendation or unclosed '[' or '{'",
+        #            self.get_mark())
+
+        # In the flow context, indentation is ignored. We make the scanner less
+        # restrictive then specification requires.
+        if self.flow_level:
+            return
+
+        # In block context, we may need to issue the BLOCK-END tokens.
+        while self.indent > column:
+            mark = self.get_mark()
+            self.indent = self.indents.pop()
+            self.tokens.append(BlockEndToken(mark, mark))
+
+    def add_indent(self, column):
+        # Check if we need to increase indentation.
+        if self.indent < column:
+            self.indents.append(self.indent)
+            self.indent = column
+            return True
+        return False
+
+    # Fetchers.
+
+    def fetch_stream_start(self):
+        # We always add STREAM-START as the first token and STREAM-END as the
+        # last token.
+
+        # Read the token.
+        mark = self.get_mark()
+        
+        # Add STREAM-START.
+        self.tokens.append(StreamStartToken(mark, mark,
+            encoding=self.encoding))
+        
+
+    def fetch_stream_end(self):
+
+        # Set the current intendation to -1.
+        self.unwind_indent(-1)
+
+        # Reset simple keys.
+        self.remove_possible_simple_key()
+        self.allow_simple_key = False
+        self.possible_simple_keys = {}
+
+        # Read the token.
+        mark = self.get_mark()
+        
+        # Add STREAM-END.
+        self.tokens.append(StreamEndToken(mark, mark))
+
+        # The steam is finished.
+        self.done = True
+
+    def fetch_directive(self):
+        
+        # Set the current intendation to -1.
+        self.unwind_indent(-1)
+
+        # Reset simple keys.
+        self.remove_possible_simple_key()
+        self.allow_simple_key = False
+
+        # Scan and add DIRECTIVE.
+        self.tokens.append(self.scan_directive())
+
+    def fetch_document_start(self):
+        self.fetch_document_indicator(DocumentStartToken)
+
+    def fetch_document_end(self):
+        self.fetch_document_indicator(DocumentEndToken)
+
+    def fetch_document_indicator(self, TokenClass):
+
+        # Set the current intendation to -1.
+        self.unwind_indent(-1)
+
+        # Reset simple keys. Note that there could not be a block collection
+        # after '---'.
+        self.remove_possible_simple_key()
+        self.allow_simple_key = False
+
+        # Add DOCUMENT-START or DOCUMENT-END.
+        start_mark = self.get_mark()
+        self.forward(3)
+        end_mark = self.get_mark()
+        self.tokens.append(TokenClass(start_mark, end_mark))
+
+    def fetch_flow_sequence_start(self):
+        self.fetch_flow_collection_start(FlowSequenceStartToken)
+
+    def fetch_flow_mapping_start(self):
+        self.fetch_flow_collection_start(FlowMappingStartToken)
+
+    def fetch_flow_collection_start(self, TokenClass):
+
+        # '[' and '{' may start a simple key.
+        self.save_possible_simple_key()
+
+        # Increase the flow level.
+        self.flow_level += 1
+
+        # Simple keys are allowed after '[' and '{'.
+        self.allow_simple_key = True
+
+        # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(TokenClass(start_mark, end_mark))
+
+    def fetch_flow_sequence_end(self):
+        self.fetch_flow_collection_end(FlowSequenceEndToken)
+
+    def fetch_flow_mapping_end(self):
+        self.fetch_flow_collection_end(FlowMappingEndToken)
+
+    def fetch_flow_collection_end(self, TokenClass):
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Decrease the flow level.
+        self.flow_level -= 1
+
+        # No simple keys after ']' or '}'.
+        self.allow_simple_key = False
+
+        # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(TokenClass(start_mark, end_mark))
+
+    def fetch_flow_entry(self):
+
+        # Simple keys are allowed after ','.
+        self.allow_simple_key = True
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Add FLOW-ENTRY.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(FlowEntryToken(start_mark, end_mark))
+
+    def fetch_block_entry(self):
+
+        # Block context needs additional checks.
+        if not self.flow_level:
+
+            # Are we allowed to start a new entry?
+            if not self.allow_simple_key:
+                raise ScannerError(None, None,
+                        "sequence entries are not allowed here",
+                        self.get_mark())
+
+            # We may need to add BLOCK-SEQUENCE-START.
+            if self.add_indent(self.column):
+                mark = self.get_mark()
+                self.tokens.append(BlockSequenceStartToken(mark, mark))
+
+        # It's an error for the block entry to occur in the flow context,
+        # but we let the parser detect this.
+        else:
+            pass
+
+        # Simple keys are allowed after '-'.
+        self.allow_simple_key = True
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Add BLOCK-ENTRY.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(BlockEntryToken(start_mark, end_mark))
+
+    def fetch_key(self):
+        
+        # Block context needs additional checks.
+        if not self.flow_level:
+
+            # Are we allowed to start a key (not nessesary a simple)?
+            if not self.allow_simple_key:
+                raise ScannerError(None, None,
+                        "mapping keys are not allowed here",
+                        self.get_mark())
+
+            # We may need to add BLOCK-MAPPING-START.
+            if self.add_indent(self.column):
+                mark = self.get_mark()
+                self.tokens.append(BlockMappingStartToken(mark, mark))
+
+        # Simple keys are allowed after '?' in the block context.
+        self.allow_simple_key = not self.flow_level
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Add KEY.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(KeyToken(start_mark, end_mark))
+
+    def fetch_value(self):
+
+        # Do we determine a simple key?
+        if self.flow_level in self.possible_simple_keys:
+
+            # Add KEY.
+            key = self.possible_simple_keys[self.flow_level]
+            del self.possible_simple_keys[self.flow_level]
+            self.tokens.insert(key.token_number-self.tokens_taken,
+                    KeyToken(key.mark, key.mark))
+
+            # If this key starts a new block mapping, we need to add
+            # BLOCK-MAPPING-START.
+            if not self.flow_level:
+                if self.add_indent(key.column):
+                    self.tokens.insert(key.token_number-self.tokens_taken,
+                            BlockMappingStartToken(key.mark, key.mark))
+
+            # There cannot be two simple keys one after another.
+            self.allow_simple_key = False
+
+        # It must be a part of a complex key.
+        else:
+            
+            # Block context needs additional checks.
+            # (Do we really need them? They will be catched by the parser
+            # anyway.)
+            if not self.flow_level:
+
+                # We are allowed to start a complex value if and only if
+                # we can start a simple key.
+                if not self.allow_simple_key:
+                    raise ScannerError(None, None,
+                            "mapping values are not allowed here",
+                            self.get_mark())
+
+            # If this value starts a new block mapping, we need to add
+            # BLOCK-MAPPING-START.  It will be detected as an error later by
+            # the parser.
+            if not self.flow_level:
+                if self.add_indent(self.column):
+                    mark = self.get_mark()
+                    self.tokens.append(BlockMappingStartToken(mark, mark))
+
+            # Simple keys are allowed after ':' in the block context.
+            self.allow_simple_key = not self.flow_level
+
+            # Reset possible simple key on the current level.
+            self.remove_possible_simple_key()
+
+        # Add VALUE.
+        start_mark = self.get_mark()
+        self.forward()
+        end_mark = self.get_mark()
+        self.tokens.append(ValueToken(start_mark, end_mark))
+
+    def fetch_alias(self):
+
+        # ALIAS could be a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after ALIAS.
+        self.allow_simple_key = False
+
+        # Scan and add ALIAS.
+        self.tokens.append(self.scan_anchor(AliasToken))
+
+    def fetch_anchor(self):
+
+        # ANCHOR could start a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after ANCHOR.
+        self.allow_simple_key = False
+
+        # Scan and add ANCHOR.
+        self.tokens.append(self.scan_anchor(AnchorToken))
+
+    def fetch_tag(self):
+
+        # TAG could start a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after TAG.
+        self.allow_simple_key = False
+
+        # Scan and add TAG.
+        self.tokens.append(self.scan_tag())
+
+    def fetch_literal(self):
+        self.fetch_block_scalar(style='|')
+
+    def fetch_folded(self):
+        self.fetch_block_scalar(style='>')
+
+    def fetch_block_scalar(self, style):
+
+        # A simple key may follow a block scalar.
+        self.allow_simple_key = True
+
+        # Reset possible simple key on the current level.
+        self.remove_possible_simple_key()
+
+        # Scan and add SCALAR.
+        self.tokens.append(self.scan_block_scalar(style))
+
+    def fetch_single(self):
+        self.fetch_flow_scalar(style='\'')
+
+    def fetch_double(self):
+        self.fetch_flow_scalar(style='"')
+
+    def fetch_flow_scalar(self, style):
+
+        # A flow scalar could be a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after flow scalars.
+        self.allow_simple_key = False
+
+        # Scan and add SCALAR.
+        self.tokens.append(self.scan_flow_scalar(style))
+
+    def fetch_plain(self):
+
+        # A plain scalar could be a simple key.
+        self.save_possible_simple_key()
+
+        # No simple keys after plain scalars. But note that `scan_plain` will
+        # change this flag if the scan is finished at the beginning of the
+        # line.
+        self.allow_simple_key = False
+
+        # Scan and add SCALAR. May change `allow_simple_key`.
+        self.tokens.append(self.scan_plain())
+
+    # Checkers.
+
+    def check_directive(self):
+
+        # DIRECTIVE:        ^ '%' ...
+        # The '%' indicator is already checked.
+        if self.column == 0:
+            return True
+
+    def check_document_start(self):
+
+        # DOCUMENT-START:   ^ '---' (' '|'\n')
+        if self.column == 0:
+            if self.prefix(3) == u'---'  \
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                return True
+
+    def check_document_end(self):
+
+        # DOCUMENT-END:     ^ '...' (' '|'\n')
+        if self.column == 0:
+            if self.prefix(3) == u'...'  \
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                return True
+
+    def check_block_entry(self):
+
+        # BLOCK-ENTRY:      '-' (' '|'\n')
+        return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+
+    def check_key(self):
+
+        # KEY(flow context):    '?'
+        if self.flow_level:
+            return True
+
+        # KEY(block context):   '?' (' '|'\n')
+        else:
+            return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+
+    def check_value(self):
+
+        # VALUE(flow context):  ':'
+        if self.flow_level:
+            return True
+
+        # VALUE(block context): ':' (' '|'\n')
+        else:
+            return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029'
+
+    def check_plain(self):
+
+        # A plain scalar may start with any non-space character except:
+        #   '-', '?', ':', ',', '[', ']', '{', '}',
+        #   '#', '&', '*', '!', '|', '>', '\'', '\"',
+        #   '%', '@', '`'.
+        #
+        # It may also start with
+        #   '-', '?', ':'
+        # if it is followed by a non-space character.
+        #
+        # Note that we limit the last rule to the block context (except the
+        # '-' character) because we want the flow context to be space
+        # independent.
+        ch = self.peek()
+        return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`'  \
+                or (self.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029'
+                        and (ch == u'-' or (not self.flow_level and ch in u'?:')))
+
+    # Scanners.
+
+    def scan_to_next_token(self):
+        # We ignore spaces, line breaks and comments.
+        # If we find a line break in the block context, we set the flag
+        # `allow_simple_key` on.
+        # The byte order mark is stripped if it's the first character in the
+        # stream. We do not yet support BOM inside the stream as the
+        # specification requires. Any such mark will be considered as a part
+        # of the document.
+        #
+        # TODO: We need to make tab handling rules more sane. A good rule is
+        #   Tabs cannot precede tokens
+        #   BLOCK-SEQUENCE-START, BLOCK-MAPPING-START, BLOCK-END,
+        #   KEY(block), VALUE(block), BLOCK-ENTRY
+        # So the checking code is
+        #   if <TAB>:
+        #       self.allow_simple_keys = False
+        # We also need to add the check for `allow_simple_keys == True` to
+        # `unwind_indent` before issuing BLOCK-END.
+        # Scanners for block, flow, and plain scalars need to be modified.
+
+        if self.index == 0 and self.peek() == u'\uFEFF':
+            self.forward()
+        found = False
+        while not found:
+            while self.peek() == u' ':
+                self.forward()
+            if self.peek() == u'#':
+                while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                    self.forward()
+            if self.scan_line_break():
+                if not self.flow_level:
+                    self.allow_simple_key = True
+            else:
+                found = True
+
+    def scan_directive(self):
+        # See the specification for details.
+        start_mark = self.get_mark()
+        self.forward()
+        name = self.scan_directive_name(start_mark)
+        value = None
+        if name == u'YAML':
+            value = self.scan_yaml_directive_value(start_mark)
+            end_mark = self.get_mark()
+        elif name == u'TAG':
+            value = self.scan_tag_directive_value(start_mark)
+            end_mark = self.get_mark()
+        else:
+            end_mark = self.get_mark()
+            while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                self.forward()
+        self.scan_directive_ignored_line(start_mark)
+        return DirectiveToken(name, value, start_mark, end_mark)
+
+    def scan_directive_name(self, start_mark):
+        # See the specification for details.
+        length = 0
+        ch = self.peek(length)
+        while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'    \
+                or ch in u'-_':
+            length += 1
+            ch = self.peek(length)
+        if not length:
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch.encode('utf-8'), self.get_mark())
+        value = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch not in u'\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch.encode('utf-8'), self.get_mark())
+        return value
+
+    def scan_yaml_directive_value(self, start_mark):
+        # See the specification for details.
+        while self.peek() == u' ':
+            self.forward()
+        major = self.scan_yaml_directive_number(start_mark)
+        if self.peek() != '.':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a digit or '.', but found %r"
+                    % self.peek().encode('utf-8'),
+                    self.get_mark())
+        self.forward()
+        minor = self.scan_yaml_directive_number(start_mark)
+        if self.peek() not in u'\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a digit or ' ', but found %r"
+                    % self.peek().encode('utf-8'),
+                    self.get_mark())
+        return (major, minor)
+
+    def scan_yaml_directive_number(self, start_mark):
+        # See the specification for details.
+        ch = self.peek()
+        if not (u'0' <= ch <= u'9'):
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a digit, but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        length = 0
+        while u'0' <= self.peek(length) <= u'9':
+            length += 1
+        value = int(self.prefix(length))
+        self.forward(length)
+        return value
+
+    def scan_tag_directive_value(self, start_mark):
+        # See the specification for details.
+        while self.peek() == u' ':
+            self.forward()
+        handle = self.scan_tag_directive_handle(start_mark)
+        while self.peek() == u' ':
+            self.forward()
+        prefix = self.scan_tag_directive_prefix(start_mark)
+        return (handle, prefix)
+
+    def scan_tag_directive_handle(self, start_mark):
+        # See the specification for details.
+        value = self.scan_tag_handle('directive', start_mark)
+        ch = self.peek()
+        if ch != u' ':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected ' ', but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        return value
+
+    def scan_tag_directive_prefix(self, start_mark):
+        # See the specification for details.
+        value = self.scan_tag_uri('directive', start_mark)
+        ch = self.peek()
+        if ch not in u'\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected ' ', but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        return value
+
+    def scan_directive_ignored_line(self, start_mark):
+        # See the specification for details.
+        while self.peek() == u' ':
+            self.forward()
+        if self.peek() == u'#':
+            while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                self.forward()
+        ch = self.peek()
+        if ch not in u'\0\r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a directive", start_mark,
+                    "expected a comment or a line break, but found %r"
+                        % ch.encode('utf-8'), self.get_mark())
+        self.scan_line_break()
+
+    def scan_anchor(self, TokenClass):
+        # The specification does not restrict characters for anchors and
+        # aliases. This may lead to problems, for instance, the document:
+        #   [ *alias, value ]
+        # can be interpteted in two ways, as
+        #   [ "value" ]
+        # and
+        #   [ *alias , "value" ]
+        # Therefore we restrict aliases to numbers and ASCII letters.
+        start_mark = self.get_mark()
+        indicator = self.peek()
+        if indicator == u'*':
+            name = 'alias'
+        else:
+            name = 'anchor'
+        self.forward()
+        length = 0
+        ch = self.peek(length)
+        while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'    \
+                or ch in u'-_':
+            length += 1
+            ch = self.peek(length)
+        if not length:
+            raise ScannerError("while scanning an %s" % name, start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch.encode('utf-8'), self.get_mark())
+        value = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`':
+            raise ScannerError("while scanning an %s" % name, start_mark,
+                    "expected alphabetic or numeric character, but found %r"
+                    % ch.encode('utf-8'), self.get_mark())
+        end_mark = self.get_mark()
+        return TokenClass(value, start_mark, end_mark)
+
+    def scan_tag(self):
+        # See the specification for details.
+        start_mark = self.get_mark()
+        ch = self.peek(1)
+        if ch == u'<':
+            handle = None
+            self.forward(2)
+            suffix = self.scan_tag_uri('tag', start_mark)
+            if self.peek() != u'>':
+                raise ScannerError("while parsing a tag", start_mark,
+                        "expected '>', but found %r" % self.peek().encode('utf-8'),
+                        self.get_mark())
+            self.forward()
+        elif ch in u'\0 \t\r\n\x85\u2028\u2029':
+            handle = None
+            suffix = u'!'
+            self.forward()
+        else:
+            length = 1
+            use_handle = False
+            while ch not in u'\0 \r\n\x85\u2028\u2029':
+                if ch == u'!':
+                    use_handle = True
+                    break
+                length += 1
+                ch = self.peek(length)
+            handle = u'!'
+            if use_handle:
+                handle = self.scan_tag_handle('tag', start_mark)
+            else:
+                handle = u'!'
+                self.forward()
+            suffix = self.scan_tag_uri('tag', start_mark)
+        ch = self.peek()
+        if ch not in u'\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a tag", start_mark,
+                    "expected ' ', but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        value = (handle, suffix)
+        end_mark = self.get_mark()
+        return TagToken(value, start_mark, end_mark)
+
+    def scan_block_scalar(self, style):
+        # See the specification for details.
+
+        if style == '>':
+            folded = True
+        else:
+            folded = False
+
+        chunks = []
+        start_mark = self.get_mark()
+
+        # Scan the header.
+        self.forward()
+        chomping, increment = self.scan_block_scalar_indicators(start_mark)
+        self.scan_block_scalar_ignored_line(start_mark)
+
+        # Determine the indentation level and go to the first non-empty line.
+        min_indent = self.indent+1
+        if min_indent < 1:
+            min_indent = 1
+        if increment is None:
+            breaks, max_indent, end_mark = self.scan_block_scalar_indentation()
+            indent = max(min_indent, max_indent)
+        else:
+            indent = min_indent+increment-1
+            breaks, end_mark = self.scan_block_scalar_breaks(indent)
+        line_break = u''
+
+        # Scan the inner part of the block scalar.
+        while self.column == indent and self.peek() != u'\0':
+            chunks.extend(breaks)
+            leading_non_space = self.peek() not in u' \t'
+            length = 0
+            while self.peek(length) not in u'\0\r\n\x85\u2028\u2029':
+                length += 1
+            chunks.append(self.prefix(length))
+            self.forward(length)
+            line_break = self.scan_line_break()
+            breaks, end_mark = self.scan_block_scalar_breaks(indent)
+            if self.column == indent and self.peek() != u'\0':
+
+                # Unfortunately, folding rules are ambiguous.
+                #
+                # This is the folding according to the specification:
+                
+                if folded and line_break == u'\n'   \
+                        and leading_non_space and self.peek() not in u' \t':
+                    if not breaks:
+                        chunks.append(u' ')
+                else:
+                    chunks.append(line_break)
+                
+                # This is Clark Evans's interpretation (also in the spec
+                # examples):
+                #
+                #if folded and line_break == u'\n':
+                #    if not breaks:
+                #        if self.peek() not in ' \t':
+                #            chunks.append(u' ')
+                #        else:
+                #            chunks.append(line_break)
+                #else:
+                #    chunks.append(line_break)
+            else:
+                break
+
+        # Chomp the tail.
+        if chomping is not False:
+            chunks.append(line_break)
+        if chomping is True:
+            chunks.extend(breaks)
+
+        # We are done.
+        return ScalarToken(u''.join(chunks), False, start_mark, end_mark,
+                style)
+
+    def scan_block_scalar_indicators(self, start_mark):
+        # See the specification for details.
+        chomping = None
+        increment = None
+        ch = self.peek()
+        if ch in u'+-':
+            if ch == '+':
+                chomping = True
+            else:
+                chomping = False
+            self.forward()
+            ch = self.peek()
+            if ch in u'0123456789':
+                increment = int(ch)
+                if increment == 0:
+                    raise ScannerError("while scanning a block scalar", start_mark,
+                            "expected indentation indicator in the range 1-9, but found 0",
+                            self.get_mark())
+                self.forward()
+        elif ch in u'0123456789':
+            increment = int(ch)
+            if increment == 0:
+                raise ScannerError("while scanning a block scalar", start_mark,
+                        "expected indentation indicator in the range 1-9, but found 0",
+                        self.get_mark())
+            self.forward()
+            ch = self.peek()
+            if ch in u'+-':
+                if ch == '+':
+                    chomping = True
+                else:
+                    chomping = False
+                self.forward()
+        ch = self.peek()
+        if ch not in u'\0 \r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a block scalar", start_mark,
+                    "expected chomping or indentation indicators, but found %r"
+                        % ch.encode('utf-8'), self.get_mark())
+        return chomping, increment
+
+    def scan_block_scalar_ignored_line(self, start_mark):
+        # See the specification for details.
+        while self.peek() == u' ':
+            self.forward()
+        if self.peek() == u'#':
+            while self.peek() not in u'\0\r\n\x85\u2028\u2029':
+                self.forward()
+        ch = self.peek()
+        if ch not in u'\0\r\n\x85\u2028\u2029':
+            raise ScannerError("while scanning a block scalar", start_mark,
+                    "expected a comment or a line break, but found %r"
+                        % ch.encode('utf-8'), self.get_mark())
+        self.scan_line_break()
+
+    def scan_block_scalar_indentation(self):
+        # See the specification for details.
+        chunks = []
+        max_indent = 0
+        end_mark = self.get_mark()
+        while self.peek() in u' \r\n\x85\u2028\u2029':
+            if self.peek() != u' ':
+                chunks.append(self.scan_line_break())
+                end_mark = self.get_mark()
+            else:
+                self.forward()
+                if self.column > max_indent:
+                    max_indent = self.column
+        return chunks, max_indent, end_mark
+
+    def scan_block_scalar_breaks(self, indent):
+        # See the specification for details.
+        chunks = []
+        end_mark = self.get_mark()
+        while self.column < indent and self.peek() == u' ':
+            self.forward()
+        while self.peek() in u'\r\n\x85\u2028\u2029':
+            chunks.append(self.scan_line_break())
+            end_mark = self.get_mark()
+            while self.column < indent and self.peek() == u' ':
+                self.forward()
+        return chunks, end_mark
+
+    def scan_flow_scalar(self, style):
+        # See the specification for details.
+        # Note that we loose indentation rules for quoted scalars. Quoted
+        # scalars don't need to adhere indentation because " and ' clearly
+        # mark the beginning and the end of them. Therefore we are less
+        # restrictive then the specification requires. We only need to check
+        # that document separators are not included in scalars.
+        if style == '"':
+            double = True
+        else:
+            double = False
+        chunks = []
+        start_mark = self.get_mark()
+        quote = self.peek()
+        self.forward()
+        chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
+        while self.peek() != quote:
+            chunks.extend(self.scan_flow_scalar_spaces(double, start_mark))
+            chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark))
+        self.forward()
+        end_mark = self.get_mark()
+        return ScalarToken(u''.join(chunks), False, start_mark, end_mark,
+                style)
+
+    ESCAPE_REPLACEMENTS = {
+        u'0':   u'\0',
+        u'a':   u'\x07',
+        u'b':   u'\x08',
+        u't':   u'\x09',
+        u'\t':  u'\x09',
+        u'n':   u'\x0A',
+        u'v':   u'\x0B',
+        u'f':   u'\x0C',
+        u'r':   u'\x0D',
+        u'e':   u'\x1B',
+        u' ':   u'\x20',
+        u'\"':  u'\"',
+        u'\\':  u'\\',
+        u'N':   u'\x85',
+        u'_':   u'\xA0',
+        u'L':   u'\u2028',
+        u'P':   u'\u2029',
+    }
+
+    ESCAPE_CODES = {
+        u'x':   2,
+        u'u':   4,
+        u'U':   8,
+    }
+
+    def scan_flow_scalar_non_spaces(self, double, start_mark):
+        # See the specification for details.
+        chunks = []
+        while True:
+            length = 0
+            while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029':
+                length += 1
+            if length:
+                chunks.append(self.prefix(length))
+                self.forward(length)
+            ch = self.peek()
+            if not double and ch == u'\'' and self.peek(1) == u'\'':
+                chunks.append(u'\'')
+                self.forward(2)
+            elif (double and ch == u'\'') or (not double and ch in u'\"\\'):
+                chunks.append(ch)
+                self.forward()
+            elif double and ch == u'\\':
+                self.forward()
+                ch = self.peek()
+                if ch in self.ESCAPE_REPLACEMENTS:
+                    chunks.append(self.ESCAPE_REPLACEMENTS[ch])
+                    self.forward()
+                elif ch in self.ESCAPE_CODES:
+                    length = self.ESCAPE_CODES[ch]
+                    self.forward()
+                    for k in range(length):
+                        if self.peek(k) not in u'0123456789ABCDEFabcdef':
+                            raise ScannerError("while scanning a double-quoted scalar", start_mark,
+                                    "expected escape sequence of %d hexdecimal numbers, but found %r" %
+                                        (length, self.peek(k).encode('utf-8')), self.get_mark())
+                    code = int(self.prefix(length), 16)
+                    chunks.append(unichr(code))
+                    self.forward(length)
+                elif ch in u'\r\n\x85\u2028\u2029':
+                    self.scan_line_break()
+                    chunks.extend(self.scan_flow_scalar_breaks(double, start_mark))
+                else:
+                    raise ScannerError("while scanning a double-quoted scalar", start_mark,
+                            "found unknown escape character %r" % ch.encode('utf-8'), self.get_mark())
+            else:
+                return chunks
+
+    def scan_flow_scalar_spaces(self, double, start_mark):
+        # See the specification for details.
+        chunks = []
+        length = 0
+        while self.peek(length) in u' \t':
+            length += 1
+        whitespaces = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch == u'\0':
+            raise ScannerError("while scanning a quoted scalar", start_mark,
+                    "found unexpected end of stream", self.get_mark())
+        elif ch in u'\r\n\x85\u2028\u2029':
+            line_break = self.scan_line_break()
+            breaks = self.scan_flow_scalar_breaks(double, start_mark)
+            if line_break != u'\n':
+                chunks.append(line_break)
+            elif not breaks:
+                chunks.append(u' ')
+            chunks.extend(breaks)
+        else:
+            chunks.append(whitespaces)
+        return chunks
+
+    def scan_flow_scalar_breaks(self, double, start_mark):
+        # See the specification for details.
+        chunks = []
+        while True:
+            # Instead of checking indentation, we check for document
+            # separators.
+            prefix = self.prefix(3)
+            if (prefix == u'---' or prefix == u'...')   \
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                raise ScannerError("while scanning a quoted scalar", start_mark,
+                        "found unexpected document separator", self.get_mark())
+            while self.peek() in u' \t':
+                self.forward()
+            if self.peek() in u'\r\n\x85\u2028\u2029':
+                chunks.append(self.scan_line_break())
+            else:
+                return chunks
+
+    def scan_plain(self):
+        # See the specification for details.
+        # We add an additional restriction for the flow context:
+        #   plain scalars in the flow context cannot contain ',', ':' and '?'.
+        # We also keep track of the `allow_simple_key` flag here.
+        # Indentation rules are loosed for the flow context.
+        chunks = []
+        start_mark = self.get_mark()
+        end_mark = start_mark
+        indent = self.indent+1
+        # We allow zero indentation for scalars, but then we need to check for
+        # document separators at the beginning of the line.
+        #if indent == 0:
+        #    indent = 1
+        spaces = []
+        while True:
+            length = 0
+            if self.peek() == u'#':
+                break
+            while True:
+                ch = self.peek(length)
+                if ch in u'\0 \t\r\n\x85\u2028\u2029'   \
+                        or (not self.flow_level and ch == u':' and
+                                self.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029') \
+                        or (self.flow_level and ch in u',:?[]{}'):
+                    break
+                length += 1
+            # It's not clear what we should do with ':' in the flow context.
+            if (self.flow_level and ch == u':'
+                    and self.peek(length+1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'):
+                self.forward(length)
+                raise ScannerError("while scanning a plain scalar", start_mark,
+                    "found unexpected ':'", self.get_mark(),
+                    "Please check http://pyyaml.org/wiki/YAMLColonInFlowContext for details.")
+            if length == 0:
+                break
+            self.allow_simple_key = False
+            chunks.extend(spaces)
+            chunks.append(self.prefix(length))
+            self.forward(length)
+            end_mark = self.get_mark()
+            spaces = self.scan_plain_spaces(indent, start_mark)
+            if not spaces or self.peek() == u'#' \
+                    or (not self.flow_level and self.column < indent):
+                break
+        return ScalarToken(u''.join(chunks), True, start_mark, end_mark)
+
+    def scan_plain_spaces(self, indent, start_mark):
+        # See the specification for details.
+        # The specification is really confusing about tabs in plain scalars.
+        # We just forbid them completely. Do not use tabs in YAML!
+        chunks = []
+        length = 0
+        while self.peek(length) in u' ':
+            length += 1
+        whitespaces = self.prefix(length)
+        self.forward(length)
+        ch = self.peek()
+        if ch in u'\r\n\x85\u2028\u2029':
+            line_break = self.scan_line_break()
+            self.allow_simple_key = True
+            prefix = self.prefix(3)
+            if (prefix == u'---' or prefix == u'...')   \
+                    and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                return
+            breaks = []
+            while self.peek() in u' \r\n\x85\u2028\u2029':
+                if self.peek() == ' ':
+                    self.forward()
+                else:
+                    breaks.append(self.scan_line_break())
+                    prefix = self.prefix(3)
+                    if (prefix == u'---' or prefix == u'...')   \
+                            and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029':
+                        return
+            if line_break != u'\n':
+                chunks.append(line_break)
+            elif not breaks:
+                chunks.append(u' ')
+            chunks.extend(breaks)
+        elif whitespaces:
+            chunks.append(whitespaces)
+        return chunks
+
+    def scan_tag_handle(self, name, start_mark):
+        # See the specification for details.
+        # For some strange reasons, the specification does not allow '_' in
+        # tag handles. I have allowed it anyway.
+        ch = self.peek()
+        if ch != u'!':
+            raise ScannerError("while scanning a %s" % name, start_mark,
+                    "expected '!', but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        length = 1
+        ch = self.peek(length)
+        if ch != u' ':
+            while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'    \
+                    or ch in u'-_':
+                length += 1
+                ch = self.peek(length)
+            if ch != u'!':
+                self.forward(length)
+                raise ScannerError("while scanning a %s" % name, start_mark,
+                        "expected '!', but found %r" % ch.encode('utf-8'),
+                        self.get_mark())
+            length += 1
+        value = self.prefix(length)
+        self.forward(length)
+        return value
+
+    def scan_tag_uri(self, name, start_mark):
+        # See the specification for details.
+        # Note: we do not check if URI is well-formed.
+        chunks = []
+        length = 0
+        ch = self.peek(length)
+        while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z'    \
+                or ch in u'-;/?:@&=+$,_.!~*\'()[]%':
+            if ch == u'%':
+                chunks.append(self.prefix(length))
+                self.forward(length)
+                length = 0
+                chunks.append(self.scan_uri_escapes(name, start_mark))
+            else:
+                length += 1
+            ch = self.peek(length)
+        if length:
+            chunks.append(self.prefix(length))
+            self.forward(length)
+            length = 0
+        if not chunks:
+            raise ScannerError("while parsing a %s" % name, start_mark,
+                    "expected URI, but found %r" % ch.encode('utf-8'),
+                    self.get_mark())
+        return u''.join(chunks)
+
+    def scan_uri_escapes(self, name, start_mark):
+        # See the specification for details.
+        bytes = []
+        mark = self.get_mark()
+        while self.peek() == u'%':
+            self.forward()
+            for k in range(2):
+                if self.peek(k) not in u'0123456789ABCDEFabcdef':
+                    raise ScannerError("while scanning a %s" % name, start_mark,
+                            "expected URI escape sequence of 2 hexdecimal numbers, but found %r" %
+                                (self.peek(k).encode('utf-8')), self.get_mark())
+            bytes.append(chr(int(self.prefix(2), 16)))
+            self.forward(2)
+        try:
+            value = unicode(''.join(bytes), 'utf-8')
+        except UnicodeDecodeError, exc:
+            raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark)
+        return value
+
+    def scan_line_break(self):
+        # Transforms:
+        #   '\r\n'      :   '\n'
+        #   '\r'        :   '\n'
+        #   '\n'        :   '\n'
+        #   '\x85'      :   '\n'
+        #   '\u2028'    :   '\u2028'
+        #   '\u2029     :   '\u2029'
+        #   default     :   ''
+        ch = self.peek()
+        if ch in u'\r\n\x85':
+            if self.prefix(2) == u'\r\n':
+                self.forward(2)
+            else:
+                self.forward()
+            return u'\n'
+        elif ch in u'\u2028\u2029':
+            self.forward()
+            return ch
+        return u''
+
+#try:
+#    import psyco
+#    psyco.bind(Scanner)
+#except ImportError:
+#    pass
+
diff --git a/libs/py2/yaml/serializer.py b/libs/py2/yaml/serializer.py
new file mode 100644
index 00000000..0bf1e96d
--- /dev/null
+++ b/libs/py2/yaml/serializer.py
@@ -0,0 +1,111 @@
+
+__all__ = ['Serializer', 'SerializerError']
+
+from error import YAMLError
+from events import *
+from nodes import *
+
+class SerializerError(YAMLError):
+    pass
+
+class Serializer(object):
+
+    ANCHOR_TEMPLATE = u'id%03d'
+
+    def __init__(self, encoding=None,
+            explicit_start=None, explicit_end=None, version=None, tags=None):
+        self.use_encoding = encoding
+        self.use_explicit_start = explicit_start
+        self.use_explicit_end = explicit_end
+        self.use_version = version
+        self.use_tags = tags
+        self.serialized_nodes = {}
+        self.anchors = {}
+        self.last_anchor_id = 0
+        self.closed = None
+
+    def open(self):
+        if self.closed is None:
+            self.emit(StreamStartEvent(encoding=self.use_encoding))
+            self.closed = False
+        elif self.closed:
+            raise SerializerError("serializer is closed")
+        else:
+            raise SerializerError("serializer is already opened")
+
+    def close(self):
+        if self.closed is None:
+            raise SerializerError("serializer is not opened")
+        elif not self.closed:
+            self.emit(StreamEndEvent())
+            self.closed = True
+
+    #def __del__(self):
+    #    self.close()
+
+    def serialize(self, node):
+        if self.closed is None:
+            raise SerializerError("serializer is not opened")
+        elif self.closed:
+            raise SerializerError("serializer is closed")
+        self.emit(DocumentStartEvent(explicit=self.use_explicit_start,
+            version=self.use_version, tags=self.use_tags))
+        self.anchor_node(node)
+        self.serialize_node(node, None, None)
+        self.emit(DocumentEndEvent(explicit=self.use_explicit_end))
+        self.serialized_nodes = {}
+        self.anchors = {}
+        self.last_anchor_id = 0
+
+    def anchor_node(self, node):
+        if node in self.anchors:
+            if self.anchors[node] is None:
+                self.anchors[node] = self.generate_anchor(node)
+        else:
+            self.anchors[node] = None
+            if isinstance(node, SequenceNode):
+                for item in node.value:
+                    self.anchor_node(item)
+            elif isinstance(node, MappingNode):
+                for key, value in node.value:
+                    self.anchor_node(key)
+                    self.anchor_node(value)
+
+    def generate_anchor(self, node):
+        self.last_anchor_id += 1
+        return self.ANCHOR_TEMPLATE % self.last_anchor_id
+
+    def serialize_node(self, node, parent, index):
+        alias = self.anchors[node]
+        if node in self.serialized_nodes:
+            self.emit(AliasEvent(alias))
+        else:
+            self.serialized_nodes[node] = True
+            self.descend_resolver(parent, index)
+            if isinstance(node, ScalarNode):
+                detected_tag = self.resolve(ScalarNode, node.value, (True, False))
+                default_tag = self.resolve(ScalarNode, node.value, (False, True))
+                implicit = (node.tag == detected_tag), (node.tag == default_tag)
+                self.emit(ScalarEvent(alias, node.tag, implicit, node.value,
+                    style=node.style))
+            elif isinstance(node, SequenceNode):
+                implicit = (node.tag
+                            == self.resolve(SequenceNode, node.value, True))
+                self.emit(SequenceStartEvent(alias, node.tag, implicit,
+                    flow_style=node.flow_style))
+                index = 0
+                for item in node.value:
+                    self.serialize_node(item, node, index)
+                    index += 1
+                self.emit(SequenceEndEvent())
+            elif isinstance(node, MappingNode):
+                implicit = (node.tag
+                            == self.resolve(MappingNode, node.value, True))
+                self.emit(MappingStartEvent(alias, node.tag, implicit,
+                    flow_style=node.flow_style))
+                for key, value in node.value:
+                    self.serialize_node(key, node, None)
+                    self.serialize_node(value, node, key)
+                self.emit(MappingEndEvent())
+            self.ascend_resolver()
+
diff --git a/libs/py2/yaml/tokens.py b/libs/py2/yaml/tokens.py
new file mode 100644
index 00000000..4d0b48a3
--- /dev/null
+++ b/libs/py2/yaml/tokens.py
@@ -0,0 +1,104 @@
+
+class Token(object):
+    def __init__(self, start_mark, end_mark):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+    def __repr__(self):
+        attributes = [key for key in self.__dict__
+                if not key.endswith('_mark')]
+        attributes.sort()
+        arguments = ', '.join(['%s=%r' % (key, getattr(self, key))
+                for key in attributes])
+        return '%s(%s)' % (self.__class__.__name__, arguments)
+
+#class BOMToken(Token):
+#    id = '<byte order mark>'
+
+class DirectiveToken(Token):
+    id = '<directive>'
+    def __init__(self, name, value, start_mark, end_mark):
+        self.name = name
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class DocumentStartToken(Token):
+    id = '<document start>'
+
+class DocumentEndToken(Token):
+    id = '<document end>'
+
+class StreamStartToken(Token):
+    id = '<stream start>'
+    def __init__(self, start_mark=None, end_mark=None,
+            encoding=None):
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.encoding = encoding
+
+class StreamEndToken(Token):
+    id = '<stream end>'
+
+class BlockSequenceStartToken(Token):
+    id = '<block sequence start>'
+
+class BlockMappingStartToken(Token):
+    id = '<block mapping start>'
+
+class BlockEndToken(Token):
+    id = '<block end>'
+
+class FlowSequenceStartToken(Token):
+    id = '['
+
+class FlowMappingStartToken(Token):
+    id = '{'
+
+class FlowSequenceEndToken(Token):
+    id = ']'
+
+class FlowMappingEndToken(Token):
+    id = '}'
+
+class KeyToken(Token):
+    id = '?'
+
+class ValueToken(Token):
+    id = ':'
+
+class BlockEntryToken(Token):
+    id = '-'
+
+class FlowEntryToken(Token):
+    id = ','
+
+class AliasToken(Token):
+    id = '<alias>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class AnchorToken(Token):
+    id = '<anchor>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class TagToken(Token):
+    id = '<tag>'
+    def __init__(self, value, start_mark, end_mark):
+        self.value = value
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+
+class ScalarToken(Token):
+    id = '<scalar>'
+    def __init__(self, value, plain, start_mark, end_mark, style=None):
+        self.value = value
+        self.plain = plain
+        self.start_mark = start_mark
+        self.end_mark = end_mark
+        self.style = style
+
diff --git a/libs/requirements-py2.txt b/libs/requirements-py2.txt
index ca7d7e12..6cf3358d 100644
--- a/libs/requirements-py2.txt
+++ b/libs/requirements-py2.txt
@@ -2,3 +2,4 @@ backports.functools-lru-cache
 beautifulsoup4
 enum34
 futures
+pyyaml