golden hour

/usr/lib64/python2.7/site-packages/yaml

File/Folder	Size	Actions
__init__.py	9.55 KB
__init__.pyc	11.14 KB
__init__.pyo	11.14 KB
composer.py	4.81 KB
composer.pyc	4.42 KB
composer.pyo	4.42 KB
constructor.py	24.56 KB
constructor.pyc	21.39 KB
constructor.pyo	21.39 KB
cyaml.py	3.21 KB
cyaml.pyc	3.72 KB
cyaml.pyo	3.72 KB
dumper.py	2.66 KB
dumper.pyc	2.51 KB
dumper.pyo	2.51 KB
emitter.py	42.28 KB
emitter.pyc	31.2 KB
emitter.pyo	31.2 KB
error.py	2.5 KB
error.pyc	2.89 KB
error.pyo	2.89 KB
events.py	2.39 KB
events.pyc	4.82 KB
events.pyo	4.82 KB
loader.py	1.11 KB
loader.pyc	1.85 KB
loader.pyo	1.85 KB
nodes.py	1.41 KB
nodes.pyc	2.13 KB
nodes.pyo	2.13 KB
parser.py	24.94 KB
parser.pyc	14.37 KB
parser.pyo	14.31 KB
reader.py	6.59 KB
reader.pyc	5.46 KB
reader.pyo	5.46 KB
representer.py	17.23 KB
representer.pyc	14.32 KB
representer.pyo	14.32 KB
resolver.py	8.76 KB
resolver.pyc	6.48 KB
resolver.pyo	6.48 KB
scanner.py	51.4 KB
scanner.pyc	32.28 KB
scanner.pyo	32.24 KB
serializer.py	4.07 KB
serializer.pyc	4.23 KB
serializer.pyo	4.23 KB
tokens.py	2.51 KB
tokens.pyc	6.34 KB
tokens.pyo	6.34 KB

Edit: composer.py

__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