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

outerbounds/_vendor/yaml/error.py

@@ -0,0 +1,94 @@
+__all__ = ["Mark", "YAMLError", "MarkedYAMLError"]
+
+
+class Mark:
+    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 "\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 "\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]
+        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)

outerbounds/_vendor/yaml/events.py

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

outerbounds/_vendor/yaml/loader.py

@@ -0,0 +1,62 @@
+__all__ = ["BaseLoader", "FullLoader", "SafeLoader", "Loader", "UnsafeLoader"]
+
+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 FullLoader(Reader, Scanner, Parser, Composer, FullConstructor, Resolver):
+    def __init__(self, stream):
+        Reader.__init__(self, stream)
+        Scanner.__init__(self)
+        Parser.__init__(self)
+        Composer.__init__(self)
+        FullConstructor.__init__(self)
+        Resolver.__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)
+
+
+# UnsafeLoader is the same as Loader (which is and was always unsafe on
+# untrusted input). Use of either Loader or UnsafeLoader should be rare, since
+# FullLoad should be able to load almost all YAML safely. Loader is left intact
+# to ensure backwards compatibility.
+class UnsafeLoader(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)

outerbounds/_vendor/yaml/nodes.py

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