syml 0.5__py3-none-any.whl

syml/__init__.py

@@ -0,0 +1,16 @@
+"""SYML (Simple YAML-like Markup Language) is a simple markup language with similar structure to YAML, but without all the gewgaws and folderol."""
+
+from io import TextIOBase
+from typing import Any
+
+from . import parsers
+
+
+def loads(document: str, **kwargs: Any) -> Any:  # noqa: ANN401
+    """Load a SYML document from a string."""
+    return parsers.parse(document, **kwargs)
+
+
+def load(file_obj: TextIOBase, **kwargs: Any) -> Any:  # noqa: ANN401
+    """Load a SYML document from a file-like object."""
+    return loads(file_obj.read(), **kwargs)

syml/basetypes.py

@@ -0,0 +1,117 @@
+"""SYML base types"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from attrs import define
+
+from syml import utils
+
+if TYPE_CHECKING:  # pragma: nocover
+    from parsimonious.nodes import Node as PNode
+
+
+StrPath = str | Path
+
+StrBool = str | bool
+
+
+@define(slots=True, frozen=True)
+class Pos:
+    """A position within a source file"""
+
+    index: int
+    line: int
+    column: int
+
+    @classmethod
+    def from_str_index(cls, text: str, index: int) -> Pos:
+        """Get (line_number, col) of `index` in `string`.
+
+        Based on http://stackoverflow.com/a/24495900
+        """
+        lines = utils.split_lines(text, keepends=True)
+        curr_pos = 0
+        for linenum, line in enumerate(lines):
+            if curr_pos + len(line) > index:
+                return cls(index, linenum + 1, index - curr_pos)
+            curr_pos += len(line)
+        return cls(len(text), linenum + 1, 0)
+
+
+@define(slots=True, repr=False, frozen=True)
+class Source:
+    """A line within a source file"""
+
+    filename: str | Path
+    start: Pos
+    end: Pos
+    text: str
+    # value corresponds to a line of text
+    value: StrBool
+
+    @classmethod
+    def from_node(cls, pnode: PNode, filename: StrPath = '', value: StrBool | None = None) -> Source:
+        """Build a Source from the given PNode, filename, and line value."""
+        return cls(
+            filename=filename,
+            start=Pos.from_str_index(pnode.full_text, pnode.start),
+            end=Pos.from_str_index(pnode.full_text, pnode.end),
+            text=pnode.text,
+            value=value if value is not None else pnode.text,
+        )
+
+    @classmethod
+    def from_text(
+        cls,
+        text: str,
+        substring: str | None = None,
+        source_text: str | None = None,
+        value: bool | str | None = None,  # noqa: FBT001
+        filename: StrPath = '',
+    ) -> Source:
+        """Build a Source from the given components."""
+        if substring is None:
+            substring = text
+        match = re.search(substring, text)
+        if match is None:
+            raise ValueError('No match found', substring)
+        source_text = match.group() if source_text is None else source_text
+        return Source(
+            filename=filename,
+            start=Pos.from_str_index(text, match.start()),
+            end=Pos.from_str_index(text, match.end()),
+            text=source_text,
+            value=value if value is not None else source_text,
+        )
+
+    def __repr__(self) -> str:
+        filename = f'{self.filename}, ' if self.filename else ''
+        return f'{filename}Line {self.start.line}, Column {self.start.column} (index {self.start.index}): {self.text!r} ({self.value!r})'
+
+    def __str__(self) -> str:
+        return self.text
+
+    def __add__(self, other: SourceStr) -> Source:
+        if isinstance(other, str):
+            lines = utils.split_lines(other, keepends=True)
+            return Source(
+                filename=self.filename,
+                start=self.start,
+                end=Pos(index=self.end.index + len(other), line=self.end.line + len(lines), column=len(lines[-1])),
+                text=self.text + other,
+                value=str(self.value) + other,
+            )
+        if isinstance(other, Source):
+            return self + other.text
+
+        raise TypeError('Tried to add invalid type to Source', type(other))
+
+
+SourceStr = Source | str
+
+
+SourceStrBool = SourceStr | bool

syml/exceptions.py

@@ -0,0 +1,9 @@
+"""Exceptions for parsing SYML documents"""
+
+
+class ParseError(ValueError):
+    """An error encountered while parsing"""
+
+
+class OutOfContextNodeError(ParseError):
+    """A node encountered in an illegal context"""

syml/grammars.py

@@ -0,0 +1,47 @@
+"""Parsimonious grammars for parsing SYML"""
+
+import textwrap
+
+syml_base_grammar = textwrap.dedent(
+    """
+    lines       = line*
+    line        = indent (comment / blank / structure / value) &eol
+    structure   = list_item / key_value / section
+
+    indent      = ~"\\s*"
+
+    blank       = &eol
+    comment     = ~"(#|//+)+" text?
+
+    list_item   = "-" ws value
+
+    key_value   = section ws data
+    section     = key ":"
+    key         = ~"[^\\s:]+"
+
+    eol         = "\\n" / ~"$"
+    ws          = ~"[ \\t]+"
+    text        = ~".+"
+
+    value       = structure / data
+
+    """
+)
+
+
+text_only_syml_grammar = syml_base_grammar + textwrap.dedent(
+    """
+    data        = text
+    """
+)
+
+# If we want mare YAML-like booleans:
+boolean_syml_grammar = syml_base_grammar + textwrap.dedent(
+    """
+    truthy      = "true" / "True" / "TRUE"
+    falsey      = "false" / "False" / "FALSE"
+    bool        = truthy / falsey
+
+    data        = bool / text
+    """
+)

syml/nodes.py

@@ -0,0 +1,298 @@
+"""Node implementations for parsing SYML documents"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:  # pragma: nocover
+    from parsimonious.nodes import Node as PNode
+
+from .basetypes import Pos, Source, SourceStrBool, StrBool, StrPath
+from .exceptions import OutOfContextNodeError
+from .utils import get_line
+
+
+@dataclass(kw_only=True)
+class SymlNode:
+    """A generic node in a SYML document."""
+
+    pnode: PNode
+    level: int | None = field(default=None)
+    parent: SymlNode | None = field(default=None)
+    comments: list[Comment] = field(default_factory=list)
+    children: list[SymlNode] | tuple[SymlNode] = field(default_factory=list)
+    value: Any = field(default=None)
+
+    def __post_init__(self) -> None:
+        if self.level is not None:
+            self.set_level(self.level)
+
+    def set_level(self, level: int) -> None:
+        """Set this node's level."""
+        self.level = level
+
+    def as_data(self, filename: StrPath = '', raw: bool = False) -> Any:  # noqa: FBT001, FBT002, ANN401  # pragma: nocover
+        """Return this node as primitive data types."""
+        raise NotImplementedError
+
+    def get_value(self) -> Any:  # noqa: ANN401  # pragma: nocover
+        """Return the value of this node."""
+        return None
+
+    def get_tip(self) -> SymlNode:
+        """Return the tip of this branch."""
+        return self
+
+    def can_add_node(self, node: SymlNode) -> bool:  # noqa: ARG002  # pragma: nocover
+        """Check if this node can add a child node."""
+        return False
+
+    def add_node(self, node: SymlNode) -> SymlNode:  # pragma: nocover
+        """Add a child node."""
+        raise NotImplementedError
+
+    def incorporate_node(self, node: SymlNode) -> SymlNode:
+        """Incorporate the given node into the tree somewhere nearby."""
+        if self.can_add_node(node):
+            return self.add_node(node)
+        if self.parent is not None:
+            return self.parent.incorporate_node(node)
+        else:  # pragma: nocover  # noqa: RET505
+            # Shouldn't ever get here:
+            self.fail_to_incorporate_node(node)
+            return self  # pragma: nocover
+
+    def fail_to_incorporate_node(self, node: SymlNode) -> None:
+        """Report a failure to incorporate a node."""
+        pnode = node.pnode
+        pos = Pos.from_str_index(pnode.full_text, pnode.start)
+        line = get_line(pnode.full_text, pos.line)
+        raise OutOfContextNodeError('Failed to incorporate a node', pos, line)
+
+
+SymlNodes = list[SymlNode]
+OptionalSymlNodes = list[SymlNode | None]
+
+NodeOrNodes = SymlNodes | SymlNode | StrBool
+
+OptionalNodes = NodeOrNodes | None
+
+
+@dataclass(kw_only=True)
+class ContainerNode(SymlNode):
+    """A container node that may contain a child value."""
+
+    value: SymlNode | StrBool | None = field(default=None)
+
+    def set_level(self, level: int) -> None:
+        """Set the level on this node and its child value."""
+        self.level = level
+        if isinstance(self.value, SymlNode):
+            self.value.set_level(level)
+
+    def as_data(self, filename: StrPath = '', raw: bool = False) -> StrBool | None:  # noqa: FBT001, FBT002
+        """Return the container as primitive data types."""
+        if isinstance(self.value, SymlNode):
+            return self.value.as_data(filename, raw=raw)
+        else:  # pragma: nocover  # noqa: RET505
+            # Shouldn't ever get here.
+            return self.value
+
+    def get_value(self) -> Any:  # noqa: ANN401  # pragma: nocover
+        """Return the value of this node."""
+        return self.value
+
+    def get_tip(self) -> SymlNode:
+        """Get the tip of this branch."""
+        if self.value is not None and isinstance(self.value, SymlNode):
+            return self.value.get_tip()
+        return self
+
+    def incorporate_node(self, node: SymlNode) -> SymlNode:
+        """Incorporate the given node into this branch."""
+        if self.can_add_node(node):
+            intermediary: SymlNode | None = None
+            if isinstance(node, KeyValue):
+                intermediary = Mapping(pnode=node.pnode, level=self.level)
+            elif isinstance(node, ListItem):
+                intermediary = List(pnode=node.pnode, level=self.level)
+
+            if intermediary is not None:
+                intermediary.set_level(node.level)  # type: ignore[arg-type]
+                intermediary = self.incorporate_node(intermediary)
+                return intermediary.incorporate_node(node)
+            return super().incorporate_node(node)
+        if self.parent is not None:
+            return self.parent.incorporate_node(node)
+        else:  # pragma: nocover  # noqa: RET505
+            self.fail_to_incorporate_node(node)
+            return self
+
+    def can_add_node(self, node: SymlNode) -> bool:
+        """Check if this container can add a child node."""
+        return self.value is None and (node.level is None or (self.level is not None and node.level > self.level))
+
+    def add_node(self, node: SymlNode) -> SymlNode:
+        """Add a child node to this container."""
+        self.value = node
+        node.parent = self
+        if node.level is None:
+            node.set_level(self.level)  # type: ignore[arg-type]
+        return node.get_tip()
+
+
+@dataclass(kw_only=True)
+class ParentNode(SymlNode):
+    """A parent node that con have multiple children"""
+
+    children: list[SymlNode] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.children = list(self.children)
+
+    def set_level(self, level: int) -> None:
+        """Set the level of this node and its children."""
+        self.level = level
+        for child in self.children:
+            if isinstance(child, SymlNode):  # pragma: nobranch
+                child.set_level(level)
+
+    def get_tip(self) -> SymlNode:
+        """Return the tip of this branch."""
+        if self.children and isinstance(self.children[-1], SymlNode):
+            return self.children[-1].get_tip()
+        return self
+
+    def can_add_node(self, node: SymlNode) -> bool:
+        """Check if a child node can be added."""
+        return node.level is None or (self.level is not None and node.level >= self.level)
+
+    def add_node(self, node: SymlNode) -> SymlNode:
+        """Add a child node."""
+        self.children.append(node)
+        node.parent = self
+        if node.level is None:
+            node.set_level(self.level)  # type: ignore[arg-type]
+        return node.get_tip()
+
+
+@dataclass(kw_only=True)
+class Root(ContainerNode):
+    """A root container node for a SYML document"""
+
+    value: SymlNode | None = field(default=None)
+    level: int = field(default=0)
+
+    def can_add_node(self, node: SymlNode) -> bool:
+        """Check if a child node may be added."""
+        return self.value is None and (node.level is None or (self.level is not None and node.level >= self.level))
+
+
+class Comment(ContainerNode):
+    """A comment node"""
+
+
+class List(ParentNode):
+    """A list node"""
+
+    def can_add_node(self, node: SymlNode) -> bool:
+        """Check if a child node can be added."""
+        return super().can_add_node(node) and isinstance(node, ListItem)
+
+    def as_data(self, filename: StrPath = '', raw: bool = False) -> list[StrBool]:  # noqa: FBT001, FBT002
+        """Return this node as primitive data types."""
+        return [c.as_data(filename, raw=raw) for c in self.children]
+
+
+class ListItem(ContainerNode):
+    """A list item within a list."""
+
+
+class Mapping(ParentNode):
+    """A mapping of keys to values"""
+
+    def can_add_node(self, node: SymlNode) -> bool:
+        """Check if a child node may be added."""
+        return super().can_add_node(node) and isinstance(node, KeyValue)
+
+    def as_data(self, filename: StrPath = '', raw: bool = False) -> OrderedDict[StrBool, StrBool]:  # noqa: FBT001, FBT002
+        """Return this node as primitive data types."""
+        return OrderedDict([(c.key.as_data(filename, raw=raw), c.as_data(filename, raw=raw)) for c in self.children])  # type: ignore[attr-defined]
+
+
+@dataclass(kw_only=True)
+class KeyValue(ContainerNode):
+    """A key-value item within a mapping"""
+
+    key: SymlNode | StrBool | None
+
+
+@dataclass(kw_only=True)
+class LeafNode(SymlNode):
+    """The tip of a branch"""
+
+    source_text: Source
+    value: StrBool | None = field(default=None)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        if self.value is not None:
+            self.value = [(self.pnode, self.value)]  # type: ignore[assignment]
+        else:
+            self.value = [(self.pnode, self.source_text.value)]  # type: ignore[assignment]
+
+    def get_value(self) -> SourceStrBool:
+        """Return this node as a primitive value."""
+        return self.value[0][1]  # type: ignore[index]  # pragma: nocover
+
+    def as_data(self, filename: StrPath = '', raw: bool = False) -> SourceStrBool | None:  # noqa: FBT001, FBT002
+        """Return this node as primitive types."""
+        if raw:
+            return self.get_value()
+        start_pnode = self.value[0][0]  # type: ignore[index]
+        end_pnode = self.value[-1][0]  # type: ignore[index]
+        start = Pos.from_str_index(start_pnode.full_text, start_pnode.start)  # type: ignore[union-attr]
+        end = Pos.from_str_index(end_pnode.full_text, end_pnode.end)  # type: ignore[union-attr]
+
+        value = self.get_value()
+
+        return Source(
+            filename=filename,
+            start=start,
+            end=end,
+            text=str(self.source_text) if isinstance(self.source_text, Source) else self.source_text,
+            # Values correspond to lines of text
+            value=value.value if isinstance(value, Source) else value,
+        )
+
+    def can_add_node(self, node: SymlNode) -> bool:
+        """Check if a child node can be added."""
+        return isinstance(node, LeafNode) and (
+            node.level is None or (self.level is not None and node.level >= self.level)
+        )
+
+
+class TextLeafNode(LeafNode):
+    """A leaf node containing a text value."""
+
+    def add_node(self, node: SymlNode) -> SymlNode:
+        """Add a node's text value to this node's text."""
+        self.source_text += '\n' + str(node.get_value())
+        self.value.append((node.pnode, node.get_value()))  # type: ignore[union-attr]
+        node.parent = self
+        return self.get_tip()
+
+    def get_value(self) -> str:
+        """Return this node as a primitive value."""
+        return '\n'.join([str(v[1]) for v in self.value])  # type: ignore[union-attr]
+
+
+class RawValueLeafNode(LeafNode):
+    """A leaf node containing a raw value"""
+
+    def get_value(self) -> StrBool:
+        """Return this node as a primitive value."""
+        return self.value[0][1]  # type: ignore[index]

syml/parsers.py

@@ -0,0 +1,134 @@
+"""SYML parsers"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from parsimonious import Grammar, NodeVisitor, VisitationError
+
+from . import basetypes as types
+from . import grammars, nodes
+from .exceptions import OutOfContextNodeError
+
+if TYPE_CHECKING:  # pragma: nocover
+    from parsimonious.nodes import Node as PNode
+
+    from .basetypes import StrPath
+    from .nodes import OptionalNodes, OptionalSymlNodes, SymlNode, SymlNodes
+
+
+class TextOnlySymlParser(NodeVisitor):  # type: ignore[type-arg]
+    """Parser for the SYML variant that allows only text leaf nodes"""
+
+    grammar = Grammar(grammars.text_only_syml_grammar)
+
+    def reduce_children(self, children: OptionalSymlNodes) -> SymlNodes:
+        """Return all non-null children."""
+        return [c for c in children if c is not None]
+
+    def visit_blank(self, node: PNode, children: OptionalSymlNodes) -> None:  # noqa: ARG002
+        """Visit a blank."""
+        return
+
+    def visit_line(self, node: PNode, children: OptionalSymlNodes) -> OptionalNodes:  # noqa: ARG002
+        """Visit a line."""
+        indent, value, _ = children
+        if value is not None:
+            value.set_level(indent)  # type: ignore[arg-type]
+            return value
+        return None
+
+    def generic_visit(self, node: PNode, children: OptionalSymlNodes) -> SymlNodes | SymlNode | None:  # type: ignore[override]  # noqa: ARG002
+        """Visit a generic node."""
+        nodes = self.reduce_children(children)
+        if not nodes:
+            return None
+        if len(nodes) == 1:
+            return nodes[0]
+        else:  # pragma: nocover  # noqa: RET505
+            return nodes
+
+    def get_text(self, node: PNode, children: OptionalSymlNodes) -> nodes.TextLeafNode:  # noqa: ARG002
+        """Return a text leaf node."""
+        return nodes.TextLeafNode(pnode=node, source_text=types.Source.from_node(node))
+
+    def visit_comment(self, node: PNode, children: OptionalSymlNodes) -> nodes.Comment:
+        """Visit a comment node."""
+        _, text = children
+        return nodes.Comment(pnode=node, value=text)
+
+    visit_text = get_text
+    visit_key = get_text
+
+    def visit_indent(self, node: PNode, children: OptionalSymlNodes) -> int:  # noqa: ARG002
+        """Visit an indentation token."""
+        return len(node.text.replace('\t', ' ' * 4).strip('\n'))
+
+    def visit_key_value(self, node: PNode, children: SymlNodes) -> OptionalNodes:  # noqa: ARG002
+        """Visit a mapping value."""
+        section, _, value = children
+        section.incorporate_node(value)
+        return section
+
+    def visit_section(self, node: PNode, children: OptionalSymlNodes) -> nodes.KeyValue:
+        """Visit a key/value section."""
+        key, _ = children
+        return nodes.KeyValue(pnode=node, key=key)
+
+    def visit_list_item(self, node: PNode, children: OptionalSymlNodes) -> nodes.ListItem:
+        """Visit a list item."""
+        _, _, value = children
+        li = nodes.ListItem(pnode=node)
+        if value is not None:  # pragma: nobranch
+            li.incorporate_node(value)
+        return li
+
+    def visit_lines(self, node: PNode, children: OptionalSymlNodes) -> nodes.Root:
+        """Visit the lines within a SYML document."""
+        root = nodes.Root(pnode=node)
+        current: SymlNode = root
+
+        for child in self.reduce_children(children):
+            if isinstance(child, nodes.Comment):
+                current.comments.append(child)
+            else:
+                current = current.incorporate_node(child)
+        return root
+
+    def parse(self, *args: Any, **kwargs: Any) -> SymlNode:  # noqa: ANN401
+        """Parse a SYML document."""
+        try:
+            return super().parse(*args, **kwargs)
+        except VisitationError as exc:
+            # Parsimonious swallows errors inside of `visit_` handlers and
+            # wraps them in VisitationError cruft.
+            if exc.args[0].startswith('OutOfContextNodeError'):
+                # Extract the original error message, ignoring the cruft.
+                msg = exc.args[0].split('\n\n\n')[0].split(':', 1)[1]
+                raise OutOfContextNodeError(msg) from exc
+            raise  # pragma: no cover
+
+
+class BooleanSymlParser(TextOnlySymlParser):
+    """Syml with support for YAML-like boolean values."""
+
+    grammar = Grammar(grammars.boolean_syml_grammar)
+
+    def visit_truthy(self, node: PNode, children: OptionalSymlNodes) -> nodes.RawValueLeafNode:  # noqa: ARG002
+        """Visit a truthy value."""
+        return nodes.RawValueLeafNode(pnode=node, source_text=types.Source.from_node(node), value=True)
+
+    def visit_falsey(self, node: PNode, children: OptionalSymlNodes) -> nodes.RawValueLeafNode:  # noqa: ARG002
+        """Visit a falsey value."""
+        return nodes.RawValueLeafNode(pnode=node, source_text=types.Source.from_node(node), value=False)
+
+
+def parse(
+    source_syml: str,
+    filename: StrPath = '',
+    raw: bool = True,  # noqa: FBT001, FBT002
+    booleans: bool = False,  # noqa: FBT001, FBT002
+) -> list[Any] | dict[str, Any] | str | bool:
+    """Parse a SYML document."""
+    parser = BooleanSymlParser if booleans else TextOnlySymlParser
+    return parser().parse(source_syml).as_data(filename, raw=raw)

syml/utils.py

@@ -0,0 +1,17 @@
+"""Utility functions for SYML"""
+
+from funcy import memoize
+
+
+@memoize
+def split_lines(text: str, keepends: bool = False) -> list[str]:  # noqa: FBT001, FBT002
+    """Memoized version of str.splitlines()"""
+    return text.splitlines(keepends=keepends)
+
+
+def get_line(text: str, line_number: int) -> str:
+    """Return the contents of the specified line number from the given text."""
+    try:
+        return split_lines(text, keepends=True)[line_number - 1]
+    except IndexError:
+        return ''

syml-0.5.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 David Eyk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

syml-0.5.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.1
+Name: syml
+Version: 0.5
+Summary: SYML (Simple YAML-like Markup Language) is a simple markup language with similar structure to YAML, but without all the gewgaws and folderol.
+Home-page: https://github.com/eykd/syml/
+Author: David Eyk
+Author-email: david@worldsenoughstudios.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: attrs (>=24.3.0,<25.0.0)
+Requires-Dist: funcy (>=2.0,<3.0)
+Requires-Dist: parsimonious (>=0.10.0,<0.11.0)
+Requires-Dist: regex (>=2024.11.6,<2025.0.0)
+Project-URL: Repository, https://github.com/eykd/syml
+Description-Content-Type: text/x-rst
+
+----
+SYML
+----
+
+SYML (Simple YAML-like Markup Language) is a simple markup language with
+similar structure to YAML, but without all the gewgaws and folderol.
+
+.. image:: https://travis-ci.org/eykd/syml.svg?branch=master
+    :target: https://travis-ci.org/eykd/syml
+
+.. image:: https://coveralls.io/repos/github/eykd/syml/badge.svg?branch=master
+    :target: https://coveralls.io/github/eykd/syml?branch=master
+
+
+Example
+=======
+
+Here's a simple SYML document::
+
+  >>> document = """
+  foo:
+    - bar
+    - baz
+    - blah
+      boo
+      baloon
+
+  booleans?:
+    - True
+    - False
+    - true
+    - false
+    - TRUE
+    - FALSE
+  """
+
+And the resulting data structure::
+
+  >>> import syml
+  >>> syml.loads(document)
+  OrderedDict([('foo', ['bar', 'baz', 'blah\nboo']),
+               ('booleans?', ['True', 'False', 'true', 'false', 'TRUE', 'FALSE'])])
+
+
+All values in SYML are just plain ol' text. But let's face it, sometimes you
+really do want YAML-like booleans::
+
+  >>> import syml
+  >>> syml.loads(document, booleans=True)
+  OrderedDict([('foo', ['bar', 'baz', 'blah\nboo']),
+               ('booleans?', [True, False, True, False, True, False])])
+

syml-0.5.dist-info/RECORD

@@ -0,0 +1,11 @@
+syml/__init__.py,sha256=xsy4SRFFMCPxHuwnPEI34sQCWrz7va_d1orDbhaFLQA,550
+syml/basetypes.py,sha256=UxTnG2yrv3srtjvsqK6KFV3uZOQFJFwYoGK3rnbT1ZY,3478
+syml/exceptions.py,sha256=kpuBpSUezugFwC30C3Sei4E_c-ZUa-C8uG4fBhvnwT8,215
+syml/grammars.py,sha256=A-rcGlwQNz3--gOLSXeNOrv_fK2nt7L2IjP86sbh-2c,968
+syml/nodes.py,sha256=sWwZGWRg0U-ekaeAnqSoMYST0th51WK_SHjAccRSJDc,10850
+syml/parsers.py,sha256=yq9vYFeqyrT_-F4oBiIcb091vd5rCDZjagvTn2KiN_4,5256
+syml/utils.py,sha256=A8WnE0mNTW6sBX9v42YOUaGiFLYb91o6QOONiMPO1RU,500
+syml-0.5.dist-info/LICENSE,sha256=XwO9yoKd4N5dwRGc8d2P54n_NS3gPXCtzewkBAjXy18,1066
+syml-0.5.dist-info/METADATA,sha256=fzugjRXOqz1PE8V3f5N2lLabnGUvZJ8mAHZnb5FZ7Uw,1840
+syml-0.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+syml-0.5.dist-info/RECORD,,

syml-0.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any