Download stackgo/stackbuild/repo_graph.py from s0duku/the-stack-go: direct link, hf CLI and curl.
- Browser
- Download file 3.66 kB
-
https://huggingface.co/datasets/s0duku/the-stack-go/resolve/main/stackgo/stackbuild/repo_graph.py
- Command line
-
hf download hf://datasets/s0duku/the-stack-go/stackgo/stackbuild/repo_graph.py
-
curl -L -o repo_graph.py https://huggingface.co/datasets/s0duku/the-stack-go/resolve/main/stackgo/stackbuild/repo_graph.py
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) | |