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: serializer.py

__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()