the-stack-go / stackgo /stackbuild /repo_graph.py
s0duku's picture
Add end-to-end stackgo pipeline
f764cdf verified
Raw History Blame Contribute Delete
3.66 kB
"""Dependency graph algorithms with cycle handling."""
from __future__ import annotations
from collections import defaultdict
import heapq
from .repo_model import DependencyEdge
def strongly_connected_components(nodes: list[str], edges: list[DependencyEdge]) -> list[tuple[str, ...]]:
"""Return SCCs using iterative Kosaraju passes to handle very deep graphs."""
node_set = set(nodes)
outgoing: dict[str, set[str]] = defaultdict(set)
incoming: dict[str, set[str]] = defaultdict(set)
for edge in edges:
if edge.status == "resolved" and edge.source in node_set and edge.target in node_set:
outgoing[edge.source].add(edge.target)
incoming[edge.target].add(edge.source)
visited: set[str] = set()
finish_order: list[str] = []
for node in sorted(nodes):
if node in visited:
continue
visited.add(node)
stack: list[tuple[str, bool]] = [(node, False)]
while stack:
current, expanded = stack.pop()
if expanded:
finish_order.append(current)
continue
stack.append((current, True))
for target in sorted(outgoing.get(current, ()), reverse=True):
if target not in visited:
visited.add(target)
stack.append((target, False))
result: list[tuple[str, ...]] = []
visited.clear()
for node in reversed(finish_order):
if node in visited:
continue
visited.add(node)
component: list[str] = []
stack = [(node, False)]
while stack:
current, _ = stack.pop()
component.append(current)
for source in sorted(incoming.get(current, ()), reverse=True):
if source not in visited:
visited.add(source)
stack.append((source, False))
result.append(tuple(sorted(component)))
return result
def dependency_first_order(nodes: list[str], edges: list[DependencyEdge]) -> tuple[str, ...]:
"""Return dependencies before dependents; stable path order breaks ties."""
components = strongly_connected_components(nodes, edges)
component_by_node = {
node: component_index
for component_index, component in enumerate(components)
for node in component
}
outgoing: dict[int, set[int]] = {index: set() for index in range(len(components))}
indegree: dict[int, int] = {index: 0 for index in range(len(components))}
for edge in edges:
if (
edge.status != "resolved"
or edge.target not in component_by_node
or edge.source not in component_by_node
):
continue
# source depends on target, so target precedes source.
dependency = component_by_node[edge.target]
dependent = component_by_node[edge.source]
if dependency != dependent and dependent not in outgoing[dependency]:
outgoing[dependency].add(dependent)
indegree[dependent] += 1
# The component tuple is sorted, so it is also a deterministic tie breaker.
ready = [(components[index], index) for index, degree in indegree.items() if degree == 0]
heapq.heapify(ready)
order: list[str] = []
while ready:
component, component_index = heapq.heappop(ready)
order.extend(component)
for dependent in sorted(outgoing[component_index], key=components.__getitem__):
indegree[dependent] -= 1
if indegree[dependent] == 0:
heapq.heappush(ready, (components[dependent], dependent))
return tuple(order)