File Manager

X7ROOT File Manager

Current Path: /usr/lib64/python2.7/site-packages/yaml

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

📁 ..
📄 __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)

Editing: 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()

X7ROOT File Manager

Editing: serializer.py

Upload File

Create Folder