outerbounds 0.3.68__py3-none-any.whl → 0.3.104__py3-none-any.whl

outerbounds/_vendor/yaml/serializer.py

@@ -0,0 +1,127 @@
+__all__ = ["Serializer", "SerializerError"]
+
+from .error import YAMLError
+from .events import *
+from .nodes import *
+
+
+class SerializerError(YAMLError):
+    pass
+
+
+class Serializer:
+
+    ANCHOR_TEMPLATE = "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()

outerbounds/_vendor/yaml/tokens.py

@@ -0,0 +1,129 @@
+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