拓扑排序停住后，剩下的任务为什么不全在环里？

"""Kahn leftovers include cycle descendants, not just cycle members."""
from collections import deque
from graphlib import CycleError, TopologicalSorter
from itertools import product


def require(ok, message):
    if not ok:
        raise AssertionError(message)


def validate(nodes, edges):
    if not isinstance(nodes, (list, tuple)) or not 0 <= len(nodes) <= 12:
        raise ValueError("at most 12 nodes required")
    if any(type(x) is not str or not x or len(x) > 20 for x in nodes) or len(set(nodes)) != len(nodes):
        raise ValueError("distinct nonempty string node names required")
    if not isinstance(edges, (list, tuple)):
        raise ValueError("edge sequence required")
    seen = set()
    for edge in edges:
        if not isinstance(edge, (list, tuple)) or len(edge) != 2:
            raise ValueError("each edge is (prerequisite, dependent)")
        a, b = edge
        if a not in nodes or b not in nodes or (a, b) in seen:
            raise ValueError("known nodes and no duplicate edges required")
        seen.add((a, b))


def kahn(nodes, edges):
    validate(nodes, edges)
    children = {node: [] for node in nodes}
    indegree = dict.fromkeys(nodes, 0)
    for a, b in edges:
        children[a].append(b)
        indegree[b] += 1
    ready = deque(node for node in nodes if indegree[node] == 0)
    done = []
    while ready:
        node = ready.popleft()
        done.append(node)
        for child in children[node]:
            indegree[child] -= 1
            if indegree[child] == 0:
                ready.append(child)
    return done, [node for node in nodes if indegree[node] > 0]


def reachable(nodes, edges, start):
    # Paths have at least one edge: start is reached only if a cycle returns.
    found = set()
    todo = [b for a, b in edges if a == start]
    while todo:
        node = todo.pop()
        if node not in found:
            found.add(node)
            todo.extend(b for a, b in edges if a == node)
    return found


def oracle(nodes, edges):
    reach = {node: reachable(nodes, edges, node) for node in nodes}
    cyclic = {node for node in nodes if node in reach[node]}
    blocked = set(cyclic)
    for node in cyclic:
        blocked.update(reach[node])
    return cyclic, blocked


def graphlib_run(nodes, edges):
    # graphlib takes node -> predecessors; our arrows point the other way.
    predecessors = {node: set() for node in nodes}
    for a, b in edges:
        predecessors[b].add(a)
    sorter = TopologicalSorter(predecessors)
    has_cycle = False
    try:
        sorter.prepare()
    except CycleError:
        has_cycle = True
    done = []
    while sorter.is_active():
        ready = sorter.get_ready()
        require(bool(ready), "all issued ready nodes are completed each round")
        done.extend(ready)
        sorter.done(*ready)
    return done, has_cycle


def main():
    nodes = list("ABCDEF")
    edges = [("A", "B"), ("B", "A"), ("B", "C"), ("C", "D"), ("E", "F")]
    done, left = kahn(nodes, edges)
    cyclic, blocked = oracle(nodes, edges)
    actual, has_cycle = graphlib_run(nodes, edges)
    print(f"edges={edges}")
    print(f"kahn_done={done}; leftovers={left}")
    print(f"actual_cycle_members={sorted(cyclic)}; blocked_descendants={sorted(blocked - cyclic)}")
    print(f"graphlib_cycle_error={has_cycle}; still_processed={actual}")
    count = 0
    nodes = list("ABC")
    possible = list(product(nodes, repeat=2))
    for mask in range(1 << len(possible)):
        edges = [edge for i, edge in enumerate(possible) if mask & (1 << i)]
        done, left = kahn(nodes, edges)
        cyclic, blocked = oracle(nodes, edges)
        actual, has_cycle = graphlib_run(nodes, edges)
        require(set(left) == blocked, "leftovers are cycles and all their descendants")
        require(set(actual) == set(done), "graphlib processes same node set")
        require(has_cycle == bool(cyclic), "graphlib detects cycles")
        position = {node: i for i, node in enumerate(done)}
        for a, b in edges:
            if b in position:
                require(a in position and position[a] < position[b], "processed prerequisite comes first")
        count += 1
    invalid = [(["A", "A"], []), (["A"], [("A", "B")]), (["A"], [("A", "A"), ("A", "A")]), ([""], [])]
    for nodes, edges in invalid:
        try:
            kahn(nodes, edges)
        except ValueError:
            pass
        else:
            raise AssertionError("invalid input accepted")
    require(kahn([], []) == ([], []), "empty graph")
    print(f"directed_graphs_checked={count}; self_loops=included; invalid_inputs={len(invalid)}")
    print("PASS: reachability oracle, dependency order and real graphlib agree")


if __name__ == "__main__":
    main()