plain-parser 0.1.1.dev2__py3-none-any.whl → 0.1.2__py3-none-any.whl

plain_parser/concept_utils.py

@@ -1,11 +1,11 @@
 import re
 from copy import deepcopy
+from graphlib import CycleError, TopologicalSorter
 from typing import Optional
 
 import mistletoe.block_token
-import networkx as nx
 
-from plain_parser import plain_spec
+from plain_parser import graph, plain_spec
 from plain_parser.exceptions import PlainSyntaxError
 
 # These are reserved concept names that are pre-defined and must not be redefined in the definitions section.
@@ -186,34 +186,63 @@ def build_adjacency_list(definitions: Optional[list[dict]]) -> tuple[dict, dict]
     return adjacency_list, concept_definitions
 
 
+MAX_REPORTED_CYCLES = 10
+
+
+def format_cycles_error(adjacency_list: dict[str, list[str]], concept_definitions: dict[str, dict]) -> str:
+    """
+    List the elementary cycles in the graph, each as a "Cycle N: :A: -> :B: -> :A:" line
+    followed by the definition of every concept in the cycle. Arrows point from a definition
+    to a concept it mentions, each cycle starts at its earliest-defined concept, and cycles
+    are ordered by definition position, so the report reads top to bottom like the file.
+    At most MAX_REPORTED_CYCLES are listed; the search stops once one more than that is found.
+    """
+    position = {concept: index for index, concept in enumerate(concept_definitions)}
+    cycles = []
+    # key the graph in definition order so a search cut short by the limit has found the earliest cycles
+    by_position = {concept: adjacency_list[concept] for concept in [*concept_definitions, *adjacency_list]}
+    for cycle in graph.simple_cycles(by_position, limit=MAX_REPORTED_CYCLES + 1):
+        # reverse since simple_cycles edges point from a used concept to the one defined with it
+        cycle = cycle[::-1]
+        first = min(range(len(cycle)), key=lambda i: position[cycle[i]])
+        cycles.append(cycle[first:] + cycle[:first])
+    cycles.sort(key=lambda cycle: (position[cycle[0]], len(cycle), [position[c] for c in cycle]))
+
+    if len(cycles) > MAX_REPORTED_CYCLES:
+        cycles = cycles[:MAX_REPORTED_CYCLES]
+        lines = [
+            f"Plain syntax error: Found more than {MAX_REPORTED_CYCLES} cycles in concept definitions. Cycles are not allowed.",
+            f"Showing the first {MAX_REPORTED_CYCLES}.",
+        ]
+    else:
+        lines = [f"Plain syntax error: Found {len(cycles)} cycle(s) in concept definitions. Cycles are not allowed."]
+    for number, cycle in enumerate(cycles, start=1):
+        lines.append("")
+        lines.append(f"Cycle {number}: " + " -> ".join(cycle + [cycle[0]]))
+        # concepts defined on one line can share a cycle; print that line once
+        lines.extend(dict.fromkeys(concept_definitions[concept]["markdown"] for concept in cycle))
+    return "\n".join(lines)
+
+
 def sort_definitions(definitions: list[dict]) -> list[dict]:
     if len(definitions) <= 1:
         return
 
     adjacency_list, concept_definitions = build_adjacency_list(definitions)
 
-    concept_graph = nx.DiGraph()
+    # adjacency_list maps a used concept to the concepts defined in terms of it,
+    # so the used concept is a predecessor of each of them
+    sorter: TopologicalSorter[str] = TopologicalSorter()
     for node, neighbors in adjacency_list.items():
+        sorter.add(node)
         for neighbour in neighbors:
-            concept_graph.add_edge(node, neighbour)
-        if not neighbors:
-            concept_graph.add_node(node)
-
-    if not nx.is_directed_acyclic_graph(concept_graph):
-        msg = "Found cycles in the concept graph. Cycles are not allowed."
-        all_cycles = list(nx.simple_cycles(concept_graph))
-
-        for cycle in all_cycles:
-            cyclic_definitions = []
-            cyclic_definitions.append(concept_definitions[cycle[0]]["markdown"])
-            cyclic_definitions.append(concept_definitions[cycle[1]]["markdown"])
-            msg += "Cyclic definitons:\n"
-            msg += "\n".join(cyclic_definitions)
-            msg += "\n"
+            sorter.add(neighbour, node)
 
-        raise PlainSyntaxError(f"Plain syntax error: {msg}")
+    try:
+        order = list(sorter.static_order())
+    except CycleError:
+        raise PlainSyntaxError(format_cycles_error(adjacency_list, concept_definitions)) from None
 
-    order = list(nx.topological_sort(concept_graph))
     if len(order) > 0:
         definition_to_order_idx = {
             plain_spec.hash_text(str(concept_definitions[concept])): idx for idx, concept in enumerate(order)

plain_parser/graph.py

@@ -0,0 +1,164 @@
+"""Cycle search over a directed graph given as a mapping from node to its successors.
+
+Nodes that appear only as successors are treated as having no outgoing edges.
+
+The search is Johnson's algorithm, written from the pseudocode in the paper, with the
+strongly connected components found by Tarjan's algorithm as given on Wikipedia.
+
+- D. B. Johnson, "Finding all the elementary circuits of a directed graph",
+  SIAM J. Comput. 4(1):77-84, 1975, doi:10.1137/0204007
+- R. Tarjan, "Depth-first search and linear graph algorithms",
+  SIAM J. Comput. 1(2):146-160, 1972, doi:10.1137/0201010
+- https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+
+Both searches keep their own stack of frames instead of recursing, so the depth of a
+tangle is not limited by Python's recursion limit.
+"""
+
+import heapq
+from collections import defaultdict
+from collections.abc import Hashable, Iterable, Iterator, Mapping
+from typing import Optional, TypeVar
+
+Node = TypeVar("Node", bound=Hashable)
+
+
+def _successors(graph: Mapping[Node, Iterable[Node]]) -> dict[Node, list[Node]]:
+    # a repeated edge would otherwise yield every cycle through it once per repeat
+    successors = {node: list(dict.fromkeys(targets)) for node, targets in graph.items()}
+    for targets in list(successors.values()):
+        for target in targets:
+            successors.setdefault(target, [])
+    return successors
+
+
+def strongly_connected_components(graph: Mapping[Node, Iterable[Node]]) -> list[set[Node]]:
+    """Tarjan: one depth-first walk, each node stamped with its visit index and the lowest
+    index it can reach; a node whose lowest reachable index is its own closes a component."""
+    successors = _successors(graph)
+    index: dict[Node, int] = {}
+    lowlink: dict[Node, int] = {}
+    stack: list[Node] = []
+    on_stack: set[Node] = set()
+    components: list[set[Node]] = []
+
+    def visit(node: Node) -> tuple[Node, Iterator[Node]]:
+        index[node] = lowlink[node] = len(index)
+        stack.append(node)
+        on_stack.add(node)
+        return node, iter(successors[node])
+
+    for root in successors:
+        if root in index:
+            continue
+        frames = [visit(root)]
+        while frames:
+            node, targets = frames[-1]
+            for target in targets:
+                if target not in index:
+                    frames.append(visit(target))
+                    break
+                if target in on_stack:
+                    lowlink[node] = min(lowlink[node], index[target])
+            else:
+                frames.pop()
+                if frames:
+                    parent = frames[-1][0]
+                    lowlink[parent] = min(lowlink[parent], lowlink[node])
+                if lowlink[node] == index[node]:
+                    component: set[Node] = set()
+                    while True:
+                        member = stack.pop()
+                        on_stack.discard(member)
+                        component.add(member)
+                        if member == node:
+                            break
+                    components.append(component)
+    return components
+
+
+def _cycles_through(adjacency: dict[Node, list[Node]], s: Node) -> Iterator[list[Node]]:
+    """Johnson's CIRCUIT: every elementary cycle through `s` in one strongly connected component.
+
+    A node is blocked while it is on the path, and stays blocked after backtracking until a
+    cycle is found through some node it was waiting on."""
+    blocked: set[Node] = set()
+    blocked_map: dict[Node, set[Node]] = defaultdict(set)
+
+    def unblock(node: Node) -> None:
+        pending = [node]
+        while pending:
+            current = pending.pop()
+            blocked.discard(current)
+            pending.extend(waiting for waiting in blocked_map.pop(current, ()) if waiting in blocked)
+
+    path = [s]
+    blocked.add(s)
+    frames = [iter(adjacency[s])]
+    found_below = [False]
+    while frames:
+        node = path[-1]
+        for target in frames[-1]:
+            if target == s:
+                yield list(path)
+                found_below[-1] = True
+            elif target not in blocked:
+                path.append(target)
+                blocked.add(target)
+                frames.append(iter(adjacency[target]))
+                found_below.append(False)
+                break
+        else:
+            frames.pop()
+            path.pop()
+            if found_below.pop():
+                unblock(node)
+                if found_below:
+                    found_below[-1] = True
+            else:
+                for target in adjacency[node]:
+                    blocked_map[target].add(node)
+
+
+def _all_cycles(graph: Mapping[Node, Iterable[Node]]) -> Iterator[list[Node]]:
+    """Johnson's main loop: every cycle lies inside one strongly connected component, and
+    every cycle inside a component either passes through its least node or survives that
+    node's removal. So search each component from its least node, drop the node, and split
+    what is left into components again. Components are taken least node first, so a caller
+    that stops early has seen the cycles through the earliest nodes."""
+    successors = _successors(graph)
+    for node, targets in successors.items():
+        if node in targets:
+            yield [node]
+    successors = {node: [t for t in targets if t != node] for node, targets in successors.items()}
+    position = {node: i for i, node in enumerate(successors)}
+
+    # components are disjoint, so no two entries share a least position and the sets are never compared
+    components: list[tuple[int, set[Node]]] = []
+
+    def push_components(adjacency: Mapping[Node, Iterable[Node]]) -> None:
+        for component in strongly_connected_components(adjacency):
+            if len(component) >= 2:
+                heapq.heappush(components, (min(map(position.__getitem__, component)), component))
+
+    push_components(successors)
+    while components:
+        _, component = heapq.heappop(components)
+        s = min(component, key=position.__getitem__)
+        adjacency = {n: [t for t in successors[n] if t in component] for n in component}
+        yield from _cycles_through(adjacency, s)
+        del adjacency[s]
+        for targets in adjacency.values():
+            if s in targets:
+                targets.remove(s)
+        push_components(adjacency)
+
+
+def simple_cycles(graph: Mapping[Node, Iterable[Node]], limit: Optional[int] = None) -> Iterator[list[Node]]:
+    """Yield the elementary cycles of `graph`, each as its nodes in edge order, stopping
+    after `limit` cycles when one is given. Self-loops come first; longer cycles follow in
+    order of their earliest node in `graph`'s iteration order."""
+    for found, cycle in enumerate(_all_cycles(graph), start=1):
+        if limit is not None and found > limit:
+            return
+        yield cycle

plain_parser/loaders.py

@@ -3,10 +3,10 @@ import re
 from typing import Optional
 
 from liquid2 import Environment, FileSystemLoader, StrictUndefined
-from liquid2.exceptions import UndefinedError
+from liquid2.exceptions import LiquidSyntaxError, UndefinedError
 
 from plain_parser import plain_spec
-from plain_parser.exceptions import UnsupportedBase64Content, UnsupportedResourceType
+from plain_parser.exceptions import PlainSyntaxError, UnsupportedBase64Content, UnsupportedResourceType
 from plain_parser.liquid_nodes import Plain2CodeIncludeTag, Plain2CodeLoaderMixin
 
 MAX_BASE64_BLOB_LENGTH = 8192
@@ -36,6 +36,20 @@ def open_from(dirs, file_name):
     return None
 
 
+def resolve_linked_resource(dirs, file_name):
+    """Return the first existing path for file_name across dirs, or None if not found.
+
+    Mirrors the search order used by open_from so that validating a linked resource and
+    loading it can never disagree.
+    """
+    for dir in dirs:
+        full_file_name = os.path.join(dir, file_name)
+        if os.path.exists(full_file_name):
+            return full_file_name
+
+    return None
+
+
 def load_linked_resources(template_dirs: list[str], resources_list, module_name: str):
     linked_resources = {}
 
@@ -81,7 +95,20 @@ class TrackingFileSystemLoader(Plain2CodeLoaderMixin, FileSystemLoader):
         return source
 
 
-def get_loaded_templates(source_path, plain_source):
+def liquid_error_message(error: LiquidSyntaxError) -> str:
+    # Built from attributes: str() of some liquid2 syntax errors (e.g. an unterminated `{{ x`) raises ValueError.
+    template_name = error.template_name or None
+    token = error.token
+    if token is None or token.start < 0:
+        where = f" in {template_name}" if template_name else ""
+    else:
+        line = token.source[: token.start].count("\n") + 1
+        column = token.start - (token.source.rfind("\n", 0, token.start) + 1)
+        where = f" at {template_name}:{line}:{column}" if template_name else f" at {line}:{column}"
+    return f"Plain syntax error: Invalid Liquid{where}: {error.message}"
+
+
+def get_loaded_templates(source_path, plain_source, template_name=None):
     # Render the plain source with Liquid templating engine
     # to identify the templates that are being loaded
 
@@ -92,9 +119,11 @@ def get_loaded_templates(source_path, plain_source):
     liquid_env.filters["code_variable"] = plain_spec.code_variable_liquid_filter
     liquid_env.filters["prohibited_chars"] = plain_spec.prohibited_chars_liquid_filter
 
-    plain_source_template = liquid_env.from_string(plain_source)
     try:
+        plain_source_template = liquid_env.from_string(plain_source, name=template_name or "")
         plain_source = plain_source_template.render()
+    except LiquidSyntaxError as e:
+        raise PlainSyntaxError(liquid_error_message(e))
     except UndefinedError as e:
         raise Exception(f"Undefined liquid variable: {str(e)}")
 

plain_parser/plain_file.py

@@ -88,7 +88,7 @@ def remove_quotes(token):
     token.children = tuple(new_children)
 
 
-def check_section_for_linked_resources(section):
+def check_section_for_linked_resources(section, template_dirs):
     linked_resources = []
     for link in traverse(section, klass=Link):
         parsed_url = urlparse(link.node.target)
@@ -97,11 +97,19 @@ def check_section_for_linked_resources(section):
                 f"Plain syntax error: Only relative links are allowed (text: {link.node.children[0].content}, target: {link.node.target})."
             )
 
-        if not os.path.exists(link.node.target):
-            raise PlainSyntaxError(f"Plain syntax error: Link {link.node.target} does not exist.")
+        resolved_target = loaders.resolve_linked_resource(template_dirs, link.node.target)
+        if resolved_target is None:
+            searched_dirs = "\n".join(f"  {position}. {dir}" for position, dir in enumerate(template_dirs, start=1))
+            raise PlainSyntaxError(
+                f"Plain syntax error: Link {link.node.target} does not exist. "
+                f"Linked resources are looked up relative to the following directories "
+                f"(highest to lowest precedence):\n{searched_dirs}"
+            )
 
-        if not os.path.isfile(link.node.target):
-            raise PlainSyntaxError(f"Plain syntax error: Link {link.node.target} must be a file.")
+        if not os.path.isfile(resolved_target):
+            raise PlainSyntaxError(
+                f"Plain syntax error: Link {link.node.target} must be a file (resolved to {resolved_target})."
+            )
 
         if len(link.node.children) != 1:
             raise PlainSyntaxError(f"Plain syntax error: Link must have text specified (link: {link.node.target}).")
@@ -120,15 +128,15 @@ def check_section_for_linked_resources(section):
         section.linked_resources = linked_resources
 
 
-def check_for_linked_resources(plain_source):
+def check_for_linked_resources(plain_source, template_dirs):
     for specification_heading in plain_spec.ALLOWED_SPECIFICATION_HEADINGS:
         if specification_heading in plain_source and hasattr(plain_source[specification_heading], "children"):
             for requirement in plain_source[specification_heading].children:
-                check_section_for_linked_resources(requirement)
+                check_section_for_linked_resources(requirement, template_dirs)
 
                 if hasattr(requirement, plain_spec.ACCEPTANCE_TESTS):
                     for acceptance_test in requirement.acceptance_tests:
-                        check_section_for_linked_resources(acceptance_test)
+                        check_section_for_linked_resources(acceptance_test, template_dirs)
 
 
 def process_section_code_variables(section, code_variables):
@@ -232,7 +240,7 @@ def _is_acceptance_test_heading(token) -> tuple[bool, str | None]:
     content = strong_children[0].content.strip()
     if content == plain_spec.ACCEPTANCE_TEST_HEADING:
         return True, None
-    problem = f"Syntax error at line {token.line_number}: Invalid acceptance test heading (`{content}`). Expected: `{plain_spec.ACCEPTANCE_TEST_HEADING}.`"
+    problem = f"Syntax error at line {token.line_number}: Invalid acceptance test heading (`{content}`). Expected: `{plain_spec.ACCEPTANCE_TEST_HEADING}`."
     return False, problem
 
 
@@ -500,6 +508,7 @@ def parse_plain_source(  # noqa: C901
     template_dirs: list[str],
     imported_modules: list[str],
     modules_trace: list[str],
+    module_name: str | None = None,
 ) -> PlainFileParseResult:
     plain_source_text = normalize_line_endings(plain_source_text)
 
@@ -519,7 +528,7 @@ def parse_plain_source(  # noqa: C901
     else:
         required_concepts = list[str]()
 
-    [_, loaded_templates] = loaders.get_loaded_templates(template_dirs, plain_source_text)
+    [_, loaded_templates] = loaders.get_loaded_templates(template_dirs, plain_source_text, module_name)
 
     plain_source_content = restore_stripped_lines(plain_source_text, plain_source_obj.content)
 
@@ -577,7 +586,7 @@ def parse_plain_source(  # noqa: C901
 
             if specification_heading == plain_spec.DEFINITIONS and current_specification_heading is not None:
                 raise PlainSyntaxError(
-                    f"Plain syntax error: Syntax error at line {token.line_number}: Definitions specification must be the first specification in the section  (`{token_text}`)"
+                    f"Plain syntax error: Syntax error at line {token.line_number}: Definitions specification must be the first specification in the section (`{token_text}`)"
                 )
 
             current_specification_heading = specification_heading
@@ -594,7 +603,7 @@ def parse_plain_source(  # noqa: C901
 
         else:
             raise PlainSyntaxError(
-                f"Plain syntax error: Syntax error at line {token.line_number}: Invalid source structure  (`{token_text}`)"
+                f"Plain syntax error: Syntax error at line {token.line_number}: Invalid source structure (`{token_text}`)"
             )
 
     # Acceptance tests are only allowed nested under functional specs. Reject them when
@@ -673,8 +682,8 @@ def read_module_plain_source(module_name: str, template_dirs: list[str]) -> str:
     if blob is not None:
         raise UnsupportedBase64Content(
             f"Module '{module_name}' contains a base64-encoded blob ({len(blob)} characters) "
-            "inlined in the specification. This is not supported."
-            "Remove the base64 data from the .plain file or if necessary,"
+            "inlined in the specification. This is not supported. "
+            "Remove the base64 data from the .plain file or if necessary, "
             "include the binary file path in the specification."
         )
 
@@ -696,6 +705,7 @@ def parse_plain_file(
         template_dirs,
         imported_modules,
         modules_trace + [module_name],
+        module_name=module_name,
     )
 
 
@@ -756,7 +766,7 @@ def process_required_modules(
                     )
 
         marshalled_plain_source = validate_and_marshall_module(
-            plain_file_parse_result, module_name, ancestor_exported_definitions, code_variables
+            plain_file_parse_result, module_name, ancestor_exported_definitions, code_variables, template_dirs
         )
         if module_name not in (chain_module_name for chain_module_name, _ in chain):
             chain.append((module_name, marshalled_plain_source))
@@ -793,6 +803,7 @@ def validate_and_marshall_module(
     module_name: str,
     exported_definitions: list[mistletoe.block_token.token],
     code_variables: dict,
+    template_dirs: list[str],
 ) -> dict:
     """Every check a module must pass after parsing, and its marshalled plain source tree."""
     if len(plain_file_parse_result.required_concepts) > 0:
@@ -826,7 +837,7 @@ def validate_and_marshall_module(
 
     process_acceptance_tests(plain_file_parse_result.plain_source)
 
-    check_for_linked_resources(plain_file_parse_result.plain_source)
+    check_for_linked_resources(plain_file_parse_result.plain_source, template_dirs)
 
     marshalled_plain_source = marshall_plain_source(plain_file_parse_result.plain_source)
 
@@ -881,7 +892,7 @@ def _parse_module(
     )
 
     marshalled_plain_source = validate_and_marshall_module(
-        plain_file_parse_result, module_name, exported_definitions, code_variables
+        plain_file_parse_result, module_name, exported_definitions, code_variables, template_dirs
     )
 
     return module_name, marshalled_plain_source, plain_file_parse_result.required_modules, chain

plain_parser/plain_spec.py

@@ -126,7 +126,7 @@ def collect_linked_resources(
 ):
 
     if not isinstance(plain_source_tree, dict):
-        raise ValueError("[plain_source_tree must be a dictionary.")
+        raise ValueError("plain_source_tree must be a dictionary.")
 
     if frid is not None:
         functional_requirements = get_frids(plain_source_tree)

{plain_parser-0.1.1.dev2.dist-info → plain_parser-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: plain-parser
-Version: 0.1.1.dev2
+Version: 0.1.2
 Summary: Parser for ***plain specification files
 License-Expression: MIT
 License-File: LICENSE
@@ -10,7 +10,6 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Compilers
 Requires-Python: >=3.11
 Requires-Dist: mistletoe<2,>=1.6.0
-Requires-Dist: networkx<4,>=3.6.1
 Requires-Dist: python-frontmatter<2,>=1.3.0
 Requires-Dist: python-liquid2<0.5,>=0.4.0
 Requires-Dist: pyyaml<7,>=6

plain_parser-0.1.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+plain_parser/__init__.py,sha256=RzRI_EVcrPnPT_BzoYtrw09-HUzKGrW4HT-GTd8GrTU,725
+plain_parser/cli.py,sha256=oJL_23l_K3ZWpJLRROGjFo2UOsJv7uUoP0RbfL8oit4,4682
+plain_parser/concept_utils.py,sha256=8NZf5OAKVfz_VvTd1Dn7yiGLv-VFVMjto9YW49xKFjI,9916
+plain_parser/exceptions.py,sha256=WcHK5g9K6bsE-ZZBKWl0lZtiMTQ6fif8-zdEx9qjmRw,795
+plain_parser/graph.py,sha256=xZfgzAXoL_hMfqre0Vj4kdvCC8vzfxZgvYptEK9W0Ho,6843
+plain_parser/liquid_nodes.py,sha256=CYmujdPJMK9hLjfFPmnSoKL3Ps4sb-2OOhH-fZUssis,3917
+plain_parser/loaders.py,sha256=o-I7u1NL8hZdTWztqwO7zw072aGxXTBBYSAFDBRG4q0,5136
+plain_parser/plain_file.py,sha256=NnPB9-xp2BIwJIaKmZnjTVjYCZPhlh4RLakR1CV6tUU,39867
+plain_parser/plain_spec.py,sha256=Z79Vi8bdRiOiM53QyWS8OLNSlGPrQObSZx11Eh8i8Mk,15308
+plain_parser-0.1.2.dist-info/METADATA,sha256=aJCTy3bMU2f17OFWQM1TxaCJjcgvUYRNZOCCD8LzLyQ,2642
+plain_parser-0.1.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+plain_parser-0.1.2.dist-info/entry_points.txt,sha256=pA31GGUyYrmZSpH1CuSzhjrv8pX5ac5HI5hFop1B4eI,55
+plain_parser-0.1.2.dist-info/licenses/LICENSE,sha256=QClWKncxgRjNUVOW8Axi7zK9HtsMdJEtUSMA4LEe8fo,1071
+plain_parser-0.1.2.dist-info/RECORD,,

plain_parser-0.1.1.dev2.dist-info/RECORD

@@ -1,13 +0,0 @@
-plain_parser/__init__.py,sha256=RzRI_EVcrPnPT_BzoYtrw09-HUzKGrW4HT-GTd8GrTU,725
-plain_parser/cli.py,sha256=oJL_23l_K3ZWpJLRROGjFo2UOsJv7uUoP0RbfL8oit4,4682
-plain_parser/concept_utils.py,sha256=BJzddKxrwg2KbV-58R74ihIJKcv-CGA4B5NZyhOixQ8,8100
-plain_parser/exceptions.py,sha256=WcHK5g9K6bsE-ZZBKWl0lZtiMTQ6fif8-zdEx9qjmRw,795
-plain_parser/liquid_nodes.py,sha256=CYmujdPJMK9hLjfFPmnSoKL3Ps4sb-2OOhH-fZUssis,3917
-plain_parser/loaders.py,sha256=5drZ7OOPJQjEitjWL5W5NfJ0CUatxKHU1UOwm_xhKKE,3850
-plain_parser/plain_file.py,sha256=cddrat_XLi72q00ZRAANjwIMMXrQnEUYdKaT8qo-y1s,39206
-plain_parser/plain_spec.py,sha256=31mLXDldi9zOXT9aK3QhD2mbxbph4ArFU_qgWYd2nwc,15309
-plain_parser-0.1.1.dev2.dist-info/METADATA,sha256=MHdortiS_vYocCr4P9r0SkxKnFq2k4fmrP3f6QLNwfw,2681
-plain_parser-0.1.1.dev2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-plain_parser-0.1.1.dev2.dist-info/entry_points.txt,sha256=pA31GGUyYrmZSpH1CuSzhjrv8pX5ac5HI5hFop1B4eI,55
-plain_parser-0.1.1.dev2.dist-info/licenses/LICENSE,sha256=QClWKncxgRjNUVOW8Axi7zK9HtsMdJEtUSMA4LEe8fo,1071
-plain_parser-0.1.1.dev2.dist-info/RECORD,,