okstra 0.130.4 → 0.131.0

package/runtime/python/okstra_vendor/networkx/readwrite/text.py

@@ -1,851 +0,0 @@
-"""
-Text-based visual representations of graphs
-"""
-
-import sys
-from collections import defaultdict
-
-import networkx as nx
-from networkx.utils import open_file
-
-__all__ = ["generate_network_text", "write_network_text"]
-
-
-class BaseGlyphs:
-    @classmethod
-    def as_dict(cls):
-        return {
-            a: getattr(cls, a)
-            for a in dir(cls)
-            if not a.startswith("_") and a != "as_dict"
-        }
-
-
-class AsciiBaseGlyphs(BaseGlyphs):
-    empty: str = "+"
-    newtree_last: str = "+-- "
-    newtree_mid: str = "+-- "
-    endof_forest: str = "    "
-    within_forest: str = ":   "
-    within_tree: str = "|   "
-
-
-class AsciiDirectedGlyphs(AsciiBaseGlyphs):
-    last: str = "L-> "
-    mid: str = "|-> "
-    backedge: str = "<-"
-    vertical_edge: str = "!"
-
-
-class AsciiUndirectedGlyphs(AsciiBaseGlyphs):
-    last: str = "L-- "
-    mid: str = "|-- "
-    backedge: str = "-"
-    vertical_edge: str = "|"
-
-
-class UtfBaseGlyphs(BaseGlyphs):
-    # Notes on available box and arrow characters
-    # https://en.wikipedia.org/wiki/Box-drawing_character
-    # https://stackoverflow.com/questions/2701192/triangle-arrow
-    empty: str = "╙"
-    newtree_last: str = "╙── "
-    newtree_mid: str = "╟── "
-    endof_forest: str = "    "
-    within_forest: str = "╎   "
-    within_tree: str = "│   "
-
-
-class UtfDirectedGlyphs(UtfBaseGlyphs):
-    last: str = "└─╼ "
-    mid: str = "├─╼ "
-    backedge: str = "╾"
-    vertical_edge: str = "╽"
-
-
-class UtfUndirectedGlyphs(UtfBaseGlyphs):
-    last: str = "└── "
-    mid: str = "├── "
-    backedge: str = "─"
-    vertical_edge: str = "│"
-
-
-def generate_network_text(
-    graph,
-    with_labels=True,
-    sources=None,
-    max_depth=None,
-    ascii_only=False,
-    vertical_chains=False,
-):
-    """Generate lines in the "network text" format
-
-    This works via a depth-first traversal of the graph and writing a line for
-    each unique node encountered. Non-tree edges are written to the right of
-    each node, and connection to a non-tree edge is indicated with an ellipsis.
-    This representation works best when the input graph is a forest, but any
-    graph can be represented.
-
-    This notation is original to networkx, although it is simple enough that it
-    may be known in existing literature. See #5602 for details. The procedure
-    is summarized as follows:
-
-    1. Given a set of source nodes (which can be specified, or automatically
-    discovered via finding the (strongly) connected components and choosing one
-    node with minimum degree from each), we traverse the graph in depth first
-    order.
-
-    2. Each reachable node will be printed exactly once on it's own line.
-
-    3. Edges are indicated in one of four ways:
-
-        a. a parent "L-style" connection on the upper left. This corresponds to
-        a traversal in the directed DFS tree.
-
-        b. a backref "<-style" connection shown directly on the right. For
-        directed graphs, these are drawn for any incoming edges to a node that
-        is not a parent edge. For undirected graphs, these are drawn for only
-        the non-parent edges that have already been represented (The edges that
-        have not been represented will be handled in the recursive case).
-
-        c. a child "L-style" connection on the lower right. Drawing of the
-        children are handled recursively.
-
-        d. if ``vertical_chains`` is true, and a parent node only has one child
-        a "vertical-style" edge is drawn between them.
-
-    4. The children of each node (wrt the directed DFS tree) are drawn
-    underneath and to the right of it. In the case that a child node has already
-    been drawn the connection is replaced with an ellipsis ("...") to indicate
-    that there is one or more connections represented elsewhere.
-
-    5. If a maximum depth is specified, an edge to nodes past this maximum
-    depth will be represented by an ellipsis.
-
-    6. If a node has a truthy "collapse" value, then we do not traverse past
-    that node.
-
-    Parameters
-    ----------
-    graph : nx.DiGraph | nx.Graph
-        Graph to represent
-
-    with_labels : bool | str
-        If True will use the "label" attribute of a node to display if it
-        exists otherwise it will use the node value itself. If given as a
-        string, then that attribute name will be used instead of "label".
-        Defaults to True.
-
-    sources : List
-        Specifies which nodes to start traversal from. Note: nodes that are not
-        reachable from one of these sources may not be shown. If unspecified,
-        the minimal set of nodes needed to reach all others will be used.
-
-    max_depth : int | None
-        The maximum depth to traverse before stopping. Defaults to None.
-
-    ascii_only : Boolean
-        If True only ASCII characters are used to construct the visualization
-
-    vertical_chains : Boolean
-        If True, chains of nodes will be drawn vertically when possible.
-
-    Yields
-    ------
-    str : a line of generated text
-
-    Examples
-    --------
-    >>> graph = nx.path_graph(10)
-    >>> graph.add_node("A")
-    >>> graph.add_node("B")
-    >>> graph.add_node("C")
-    >>> graph.add_node("D")
-    >>> graph.add_edge(9, "A")
-    >>> graph.add_edge(9, "B")
-    >>> graph.add_edge(9, "C")
-    >>> graph.add_edge("C", "D")
-    >>> graph.add_edge("C", "E")
-    >>> graph.add_edge("C", "F")
-    >>> nx.write_network_text(graph)
-    ╙── 0
-        └── 1
-            └── 2
-                └── 3
-                    └── 4
-                        └── 5
-                            └── 6
-                                └── 7
-                                    └── 8
-                                        └── 9
-                                            ├── A
-                                            ├── B
-                                            └── C
-                                                ├── D
-                                                ├── E
-                                                └── F
-    >>> nx.write_network_text(graph, vertical_chains=True)
-    ╙── 0
-        │
-        1
-        │
-        2
-        │
-        3
-        │
-        4
-        │
-        5
-        │
-        6
-        │
-        7
-        │
-        8
-        │
-        9
-        ├── A
-        ├── B
-        └── C
-            ├── D
-            ├── E
-            └── F
-    """
-    from typing import Any, NamedTuple
-
-    class StackFrame(NamedTuple):
-        parent: Any
-        node: Any
-        indents: list
-        this_islast: bool
-        this_vertical: bool
-
-    collapse_attr = "collapse"
-
-    is_directed = graph.is_directed()
-
-    if is_directed:
-        glyphs = AsciiDirectedGlyphs if ascii_only else UtfDirectedGlyphs
-        succ = graph.succ
-        pred = graph.pred
-    else:
-        glyphs = AsciiUndirectedGlyphs if ascii_only else UtfUndirectedGlyphs
-        succ = graph.adj
-        pred = graph.adj
-
-    if isinstance(with_labels, str):
-        label_attr = with_labels
-    elif with_labels:
-        label_attr = "label"
-    else:
-        label_attr = None
-
-    if max_depth == 0:
-        yield glyphs.empty + " ..."
-    elif len(graph.nodes) == 0:
-        yield glyphs.empty
-    else:
-        # If the nodes to traverse are unspecified, find the minimal set of
-        # nodes that will reach the entire graph
-        if sources is None:
-            sources = _find_sources(graph)
-
-        # Populate the stack with each:
-        # 1. parent node in the DFS tree (or None for root nodes),
-        # 2. the current node in the DFS tree
-        # 2. a list of indentations indicating depth
-        # 3. a flag indicating if the node is the final one to be written.
-        # Reverse the stack so sources are popped in the correct order.
-        last_idx = len(sources) - 1
-        stack = [
-            StackFrame(None, node, [], (idx == last_idx), False)
-            for idx, node in enumerate(sources)
-        ][::-1]
-
-        num_skipped_children = defaultdict(lambda: 0)
-        seen_nodes = set()
-        while stack:
-            parent, node, indents, this_islast, this_vertical = stack.pop()
-
-            if node is not Ellipsis:
-                skip = node in seen_nodes
-                if skip:
-                    # Mark that we skipped a parent's child
-                    num_skipped_children[parent] += 1
-
-                if this_islast:
-                    # If we reached the last child of a parent, and we skipped
-                    # any of that parents children, then we should emit an
-                    # ellipsis at the end after this.
-                    if num_skipped_children[parent] and parent is not None:
-                        # Append the ellipsis to be emitted last
-                        next_islast = True
-                        try_frame = StackFrame(
-                            node, Ellipsis, indents, next_islast, False
-                        )
-                        stack.append(try_frame)
-
-                        # Redo this frame, but not as a last object
-                        next_islast = False
-                        try_frame = StackFrame(
-                            parent, node, indents, next_islast, this_vertical
-                        )
-                        stack.append(try_frame)
-                        continue
-
-                if skip:
-                    continue
-                seen_nodes.add(node)
-
-            if not indents:
-                # Top level items (i.e. trees in the forest) get different
-                # glyphs to indicate they are not actually connected
-                if this_islast:
-                    this_vertical = False
-                    this_prefix = indents + [glyphs.newtree_last]
-                    next_prefix = indents + [glyphs.endof_forest]
-                else:
-                    this_prefix = indents + [glyphs.newtree_mid]
-                    next_prefix = indents + [glyphs.within_forest]
-
-            else:
-                # Non-top-level items
-                if this_vertical:
-                    this_prefix = indents
-                    next_prefix = indents
-                else:
-                    if this_islast:
-                        this_prefix = indents + [glyphs.last]
-                        next_prefix = indents + [glyphs.endof_forest]
-                    else:
-                        this_prefix = indents + [glyphs.mid]
-                        next_prefix = indents + [glyphs.within_tree]
-
-            if node is Ellipsis:
-                label = " ..."
-                suffix = ""
-                children = []
-            else:
-                if label_attr is not None:
-                    label = str(graph.nodes[node].get(label_attr, node))
-                else:
-                    label = str(node)
-
-                # Determine if we want to show the children of this node.
-                if collapse_attr is not None:
-                    collapse = graph.nodes[node].get(collapse_attr, False)
-                else:
-                    collapse = False
-
-                # Determine:
-                # (1) children to traverse into after showing this node.
-                # (2) parents to immediately show to the right of this node.
-                if is_directed:
-                    # In the directed case we must show every successor node
-                    # note: it may be skipped later, but we don't have that
-                    # information here.
-                    children = list(succ[node])
-                    # In the directed case we must show every predecessor
-                    # except for parent we directly traversed from.
-                    handled_parents = {parent}
-                else:
-                    # Showing only the unseen children results in a more
-                    # concise representation for the undirected case.
-                    children = [
-                        child for child in succ[node] if child not in seen_nodes
-                    ]
-
-                    # In the undirected case, parents are also children, so we
-                    # only need to immediately show the ones we can no longer
-                    # traverse
-                    handled_parents = {*children, parent}
-
-                if max_depth is not None and len(indents) == max_depth - 1:
-                    # Use ellipsis to indicate we have reached maximum depth
-                    if children:
-                        children = [Ellipsis]
-                    handled_parents = {parent}
-
-                if collapse:
-                    # Collapsing a node is the same as reaching maximum depth
-                    if children:
-                        children = [Ellipsis]
-                    handled_parents = {parent}
-
-                # The other parents are other predecessors of this node that
-                # are not handled elsewhere.
-                other_parents = [p for p in pred[node] if p not in handled_parents]
-                if other_parents:
-                    if label_attr is not None:
-                        other_parents_labels = ", ".join(
-                            [
-                                str(graph.nodes[p].get(label_attr, p))
-                                for p in other_parents
-                            ]
-                        )
-                    else:
-                        other_parents_labels = ", ".join(
-                            [str(p) for p in other_parents]
-                        )
-                    suffix = " ".join(["", glyphs.backedge, other_parents_labels])
-                else:
-                    suffix = ""
-
-            # Emit the line for this node, this will be called for each node
-            # exactly once.
-            if this_vertical:
-                yield "".join(this_prefix + [glyphs.vertical_edge])
-
-            yield "".join(this_prefix + [label, suffix])
-
-            if vertical_chains:
-                if is_directed:
-                    num_children = len(set(children))
-                else:
-                    num_children = len(set(children) - {parent})
-                # The next node can be drawn vertically if it is the only
-                # remaining child of this node.
-                next_is_vertical = num_children == 1
-            else:
-                next_is_vertical = False
-
-            # Push children on the stack in reverse order so they are popped in
-            # the original order.
-            for idx, child in enumerate(children[::-1]):
-                next_islast = idx == 0
-                try_frame = StackFrame(
-                    node, child, next_prefix, next_islast, next_is_vertical
-                )
-                stack.append(try_frame)
-
-
-@open_file(1, "w")
-def write_network_text(
-    graph,
-    path=None,
-    with_labels=True,
-    sources=None,
-    max_depth=None,
-    ascii_only=False,
-    end="\n",
-    vertical_chains=False,
-):
-    """Creates a nice text representation of a graph
-
-    This works via a depth-first traversal of the graph and writing a line for
-    each unique node encountered. Non-tree edges are written to the right of
-    each node, and connection to a non-tree edge is indicated with an ellipsis.
-    This representation works best when the input graph is a forest, but any
-    graph can be represented.
-
-    Parameters
-    ----------
-    graph : nx.DiGraph | nx.Graph
-        Graph to represent
-
-    path : string or file or callable or None
-       Filename or file handle for data output.
-       if a function, then it will be called for each generated line.
-       if None, this will default to "sys.stdout.write"
-
-    with_labels : bool | str
-        If True will use the "label" attribute of a node to display if it
-        exists otherwise it will use the node value itself. If given as a
-        string, then that attribute name will be used instead of "label".
-        Defaults to True.
-
-    sources : List
-        Specifies which nodes to start traversal from. Note: nodes that are not
-        reachable from one of these sources may not be shown. If unspecified,
-        the minimal set of nodes needed to reach all others will be used.
-
-    max_depth : int | None
-        The maximum depth to traverse before stopping. Defaults to None.
-
-    ascii_only : Boolean
-        If True only ASCII characters are used to construct the visualization
-
-    end : string
-        The line ending character
-
-    vertical_chains : Boolean
-        If True, chains of nodes will be drawn vertically when possible.
-
-    Examples
-    --------
-    >>> graph = nx.balanced_tree(r=2, h=2, create_using=nx.DiGraph)
-    >>> nx.write_network_text(graph)
-    ╙── 0
-        ├─╼ 1
-        │   ├─╼ 3
-        │   └─╼ 4
-        └─╼ 2
-            ├─╼ 5
-            └─╼ 6
-
-    >>> # A near tree with one non-tree edge
-    >>> graph.add_edge(5, 1)
-    >>> nx.write_network_text(graph)
-    ╙── 0
-        ├─╼ 1 ╾ 5
-        │   ├─╼ 3
-        │   └─╼ 4
-        └─╼ 2
-            ├─╼ 5
-            │   └─╼  ...
-            └─╼ 6
-
-    >>> graph = nx.cycle_graph(5)
-    >>> nx.write_network_text(graph)
-    ╙── 0
-        ├── 1
-        │   └── 2
-        │       └── 3
-        │           └── 4 ─ 0
-        └──  ...
-
-    >>> graph = nx.cycle_graph(5, nx.DiGraph)
-    >>> nx.write_network_text(graph, vertical_chains=True)
-    ╙── 0 ╾ 4
-        ╽
-        1
-        ╽
-        2
-        ╽
-        3
-        ╽
-        4
-        └─╼  ...
-
-    >>> nx.write_network_text(graph, vertical_chains=True, ascii_only=True)
-    +-- 0 <- 4
-        !
-        1
-        !
-        2
-        !
-        3
-        !
-        4
-        L->  ...
-
-    >>> graph = nx.generators.barbell_graph(4, 2)
-    >>> nx.write_network_text(graph, vertical_chains=False)
-    ╙── 4
-        ├── 5
-        │   └── 6
-        │       ├── 7
-        │       │   ├── 8 ─ 6
-        │       │   │   └── 9 ─ 6, 7
-        │       │   └──  ...
-        │       └──  ...
-        └── 3
-            ├── 0
-            │   ├── 1 ─ 3
-            │   │   └── 2 ─ 0, 3
-            │   └──  ...
-            └──  ...
-    >>> nx.write_network_text(graph, vertical_chains=True)
-    ╙── 4
-        ├── 5
-        │   │
-        │   6
-        │   ├── 7
-        │   │   ├── 8 ─ 6
-        │   │   │   │
-        │   │   │   9 ─ 6, 7
-        │   │   └──  ...
-        │   └──  ...
-        └── 3
-            ├── 0
-            │   ├── 1 ─ 3
-            │   │   │
-            │   │   2 ─ 0, 3
-            │   └──  ...
-            └──  ...
-
-    >>> graph = nx.complete_graph(5, create_using=nx.Graph)
-    >>> nx.write_network_text(graph)
-    ╙── 0
-        ├── 1
-        │   ├── 2 ─ 0
-        │   │   ├── 3 ─ 0, 1
-        │   │   │   └── 4 ─ 0, 1, 2
-        │   │   └──  ...
-        │   └──  ...
-        └──  ...
-
-    >>> graph = nx.complete_graph(3, create_using=nx.DiGraph)
-    >>> nx.write_network_text(graph)
-    ╙── 0 ╾ 1, 2
-        ├─╼ 1 ╾ 2
-        │   ├─╼ 2 ╾ 0
-        │   │   └─╼  ...
-        │   └─╼  ...
-        └─╼  ...
-    """
-    if path is None:
-        # The path is unspecified, write to stdout
-        _write = sys.stdout.write
-    elif hasattr(path, "write"):
-        # The path is already an open file
-        _write = path.write
-    elif callable(path):
-        # The path is a custom callable
-        _write = path
-    else:
-        raise TypeError(type(path))
-
-    for line in generate_network_text(
-        graph,
-        with_labels=with_labels,
-        sources=sources,
-        max_depth=max_depth,
-        ascii_only=ascii_only,
-        vertical_chains=vertical_chains,
-    ):
-        _write(line + end)
-
-
-def _find_sources(graph):
-    """
-    Determine a minimal set of nodes such that the entire graph is reachable
-    """
-    # For each connected part of the graph, choose at least
-    # one node as a starting point, preferably without a parent
-    if graph.is_directed():
-        # Choose one node from each SCC with minimum in_degree
-        sccs = list(nx.strongly_connected_components(graph))
-        # condensing the SCCs forms a dag, the nodes in this graph with
-        # 0 in-degree correspond to the SCCs from which the minimum set
-        # of nodes from which all other nodes can be reached.
-        scc_graph = nx.condensation(graph, sccs)
-        supernode_to_nodes = {sn: [] for sn in scc_graph.nodes()}
-        # Note: the order of mapping differs between pypy and cpython
-        # so we have to loop over graph nodes for consistency
-        mapping = scc_graph.graph["mapping"]
-        for n in graph.nodes:
-            sn = mapping[n]
-            supernode_to_nodes[sn].append(n)
-        sources = []
-        for sn in scc_graph.nodes():
-            if scc_graph.in_degree[sn] == 0:
-                scc = supernode_to_nodes[sn]
-                node = min(scc, key=lambda n: graph.in_degree[n])
-                sources.append(node)
-    else:
-        # For undirected graph, the entire graph will be reachable as
-        # long as we consider one node from every connected component
-        sources = [
-            min(cc, key=lambda n: graph.degree[n])
-            for cc in nx.connected_components(graph)
-        ]
-        sources = sorted(sources, key=lambda n: graph.degree[n])
-    return sources
-
-
-def _parse_network_text(lines):
-    """Reconstructs a graph from a network text representation.
-
-    This is mainly used for testing.  Network text is for display, not
-    serialization, as such this cannot parse all network text representations
-    because node labels can be ambiguous with the glyphs and indentation used
-    to represent edge structure. Additionally, there is no way to determine if
-    disconnected graphs were originally directed or undirected.
-
-    Parameters
-    ----------
-    lines : list or iterator of strings
-        Input data in network text format
-
-    Returns
-    -------
-    G: NetworkX graph
-        The graph corresponding to the lines in network text format.
-    """
-    from itertools import chain
-    from typing import Any, NamedTuple
-
-    class ParseStackFrame(NamedTuple):
-        node: Any
-        indent: int
-        has_vertical_child: int | None
-
-    initial_line_iter = iter(lines)
-
-    is_ascii = None
-    is_directed = None
-
-    ##############
-    # Initial Pass
-    ##############
-
-    # Do an initial pass over the lines to determine what type of graph it is.
-    # Remember what these lines were, so we can reiterate over them in the
-    # parsing pass.
-    initial_lines = []
-    try:
-        first_line = next(initial_line_iter)
-    except StopIteration:
-        ...
-    else:
-        initial_lines.append(first_line)
-        # The first character indicates if it is an ASCII or UTF graph
-        first_char = first_line[0]
-        if first_char in {
-            UtfBaseGlyphs.empty,
-            UtfBaseGlyphs.newtree_mid[0],
-            UtfBaseGlyphs.newtree_last[0],
-        }:
-            is_ascii = False
-        elif first_char in {
-            AsciiBaseGlyphs.empty,
-            AsciiBaseGlyphs.newtree_mid[0],
-            AsciiBaseGlyphs.newtree_last[0],
-        }:
-            is_ascii = True
-        else:
-            raise AssertionError(f"Unexpected first character: {first_char}")
-
-    if is_ascii:
-        directed_glyphs = AsciiDirectedGlyphs.as_dict()
-        undirected_glyphs = AsciiUndirectedGlyphs.as_dict()
-    else:
-        directed_glyphs = UtfDirectedGlyphs.as_dict()
-        undirected_glyphs = UtfUndirectedGlyphs.as_dict()
-
-    # For both directed / undirected glyphs, determine which glyphs never
-    # appear as substrings in the other undirected / directed glyphs.  Glyphs
-    # with this property unambiguously indicates if a graph is directed /
-    # undirected.
-    directed_items = set(directed_glyphs.values())
-    undirected_items = set(undirected_glyphs.values())
-    unambiguous_directed_items = []
-    for item in directed_items:
-        other_items = undirected_items
-        other_supersets = [other for other in other_items if item in other]
-        if not other_supersets:
-            unambiguous_directed_items.append(item)
-    unambiguous_undirected_items = []
-    for item in undirected_items:
-        other_items = directed_items
-        other_supersets = [other for other in other_items if item in other]
-        if not other_supersets:
-            unambiguous_undirected_items.append(item)
-
-    for line in initial_line_iter:
-        initial_lines.append(line)
-        if any(item in line for item in unambiguous_undirected_items):
-            is_directed = False
-            break
-        elif any(item in line for item in unambiguous_directed_items):
-            is_directed = True
-            break
-
-    if is_directed is None:
-        # Not enough information to determine, choose undirected by default
-        is_directed = False
-
-    glyphs = directed_glyphs if is_directed else undirected_glyphs
-
-    # the backedge symbol by itself can be ambiguous, but with spaces around it
-    # becomes unambiguous.
-    backedge_symbol = " " + glyphs["backedge"] + " "
-
-    # Reconstruct an iterator over all of the lines.
-    parsing_line_iter = chain(initial_lines, initial_line_iter)
-
-    ##############
-    # Parsing Pass
-    ##############
-
-    edges = []
-    nodes = []
-    is_empty = None
-
-    noparent = object()  # sentinel value
-
-    # keep a stack of previous nodes that could be parents of subsequent nodes
-    stack = [ParseStackFrame(noparent, -1, None)]
-
-    for line in parsing_line_iter:
-        if line == glyphs["empty"]:
-            # If the line is the empty glyph, we are done.
-            # There shouldn't be anything else after this.
-            is_empty = True
-            continue
-
-        if backedge_symbol in line:
-            # This line has one or more backedges, separate those out
-            node_part, backedge_part = line.split(backedge_symbol)
-            backedge_nodes = [u.strip() for u in backedge_part.split(", ")]
-            # Now the node can be parsed
-            node_part = node_part.rstrip()
-            prefix, node = node_part.rsplit(" ", 1)
-            node = node.strip()
-            # Add the backedges to the edge list
-            edges.extend([(u, node) for u in backedge_nodes])
-        else:
-            # No backedge, the tail of this line is the node
-            prefix, node = line.rsplit(" ", 1)
-            node = node.strip()
-
-        prev = stack.pop()
-
-        if node in glyphs["vertical_edge"]:
-            # Previous node is still the previous node, but we know it will
-            # have exactly one child, which will need to have its nesting level
-            # adjusted.
-            modified_prev = ParseStackFrame(
-                prev.node,
-                prev.indent,
-                True,
-            )
-            stack.append(modified_prev)
-            continue
-
-        # The length of the string before the node characters give us a hint
-        # about our nesting level. The only case where this doesn't work is
-        # when there are vertical chains, which is handled explicitly.
-        indent = len(prefix)
-        curr = ParseStackFrame(node, indent, None)
-
-        if prev.has_vertical_child:
-            # In this case we know prev must be the parent of our current line,
-            # so we don't have to search the stack. (which is good because the
-            # indentation check wouldn't work in this case).
-            ...
-        else:
-            # If the previous node nesting-level is greater than the current
-            # nodes nesting-level than the previous node was the end of a path,
-            # and is not our parent. We can safely pop nodes off the stack
-            # until we find one with a comparable nesting-level, which is our
-            # parent.
-            while curr.indent <= prev.indent:
-                prev = stack.pop()
-
-        if node == "...":
-            # The current previous node is no longer a valid parent,
-            # keep it popped from the stack.
-            stack.append(prev)
-        else:
-            # The previous and current nodes may still be parents, so add them
-            # back onto the stack.
-            stack.append(prev)
-            stack.append(curr)
-
-            # Add the node and the edge to its parent to the node / edge lists.
-            nodes.append(curr.node)
-            if prev.node is not noparent:
-                edges.append((prev.node, curr.node))
-
-    if is_empty:
-        # Sanity check
-        assert len(nodes) == 0
-
-    # Reconstruct the graph
-    cls = nx.DiGraph if is_directed else nx.Graph
-    new = cls()
-    new.add_nodes_from(nodes)
-    new.add_edges_from(edges)
-    return new