pyfect-dev 0.1.0__py3-none-any.whl

pyfect/graph/_graph.py

@@ -0,0 +1,269 @@
+"""``Graph`` (immutable, compared by structure) and ``MutableGraph`` (a
+mutation handle, compared by identity), and the constructors."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from typing import Any, Literal, Never, TypeIs
+
+from pyfect._equal import equal_key, equals
+from pyfect.graph import _combine, _mutate
+from pyfect.graph._errors import fail
+from pyfect.graph._records import Directed, Edge, Kind, Snapshot, TraversalDirection, Undirected
+from pyfect.graph._snapshot import from_snapshot as _from_snapshot
+from pyfect.graph._store import Store
+from pyfect.graph._view import GraphView
+from pyfect.option import Option
+
+
+class Graph[N, E, K: Kind = Literal["directed"]](GraphView[N, E, K]):
+    """An immutable graph of nodes ``N`` and edges ``E``. Change one with
+    ``mutate`` (or ``begin_mutation`` / ``end_mutation``), which returns a
+    new graph. Two graphs are ``==`` when they have the same kind and the
+    same nodes and edges at the same indexes (payloads compared as Effect's
+    ``Equal`` does; an undirected edge either way round)."""
+
+    __slots__ = ()
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Graph):
+            return NotImplemented
+        a, b = self._store, other._store
+        if a is b:
+            return True
+        if a.kind != b.kind or len(a.nodes) != len(b.nodes) or len(a.edges) != len(b.edges):
+            return False
+        for index, data in a.nodes.items():
+            if index not in b.nodes or not equals(data, b.nodes[index]):
+                return False
+        for index, edge in a.edges.items():
+            found = b.edges.get(index)
+            if found is None or not _same_edge(a.kind, edge, found):
+                return False
+        return True
+
+    def __hash__(self) -> int:
+        store = self._store
+        return hash(
+            (
+                store.kind,
+                tuple((index, equal_key(data)) for index, data in store.nodes.items()),
+                tuple(
+                    (index, _ends_key(store.kind, edge), equal_key(edge.data))
+                    for index, edge in store.edges.items()
+                ),
+            )
+        )
+
+    # --- mutation -------------------------------------------------------------------
+
+    def begin_mutation[N2, E2, K2: Kind](self: Graph[N2, E2, K2]) -> MutableGraph[N2, E2, K2]:
+        """A mutable copy; this graph never changes."""
+        return MutableGraph(self._store.clone(True))
+
+    def mutate[N2, E2, K2: Kind](
+        self: Graph[N2, E2, K2], f: Callable[[MutableGraph[N2, E2, K2]], object]
+    ) -> Graph[N2, E2, K2]:
+        """The graph ``f`` makes of a mutable copy of this one. The handle is
+        finalized afterwards, also when ``f`` raises."""
+        return _scoped(self.begin_mutation(), f)
+
+    # --- combinations ---------------------------------------------------------------
+
+    def compose[N2, E2, K2: Kind](
+        self: Graph[N2, E2, K2],
+        that: Graph[N2, E2, K2],
+        *,
+        node_identity: Callable[[N2], object] | None = None,
+        edge_identity: Callable[[E2], object] | None = None,
+    ) -> Graph[N2, E2, K2]:
+        """The union of both graphs, nodes and edges matched by identity
+        (default: their data); ``that``'s payloads win."""
+        return Graph(_combine.compose(self._store, that._store, node_identity, edge_identity))
+
+    def intersection[N2, E2, K2: Kind](
+        self: Graph[N2, E2, K2],
+        that: Graph[N2, E2, K2],
+        *,
+        node_identity: Callable[[N2], object] | None = None,
+        edge_identity: Callable[[E2], object] | None = None,
+    ) -> Graph[N2, E2, K2]:
+        """The nodes (this graph's payloads) and edges (``that``'s) in both."""
+        return Graph(_combine.intersection(self._store, that._store, node_identity, edge_identity))
+
+    def difference[N2, E2, K2: Kind](
+        self: Graph[N2, E2, K2],
+        that: Graph[N2, E2, K2],
+        *,
+        node_identity: Callable[[N2], object] | None = None,
+        edge_identity: Callable[[E2], object] | None = None,
+    ) -> Graph[N2, E2, K2]:
+        """Every node of this graph, and its edges ``that`` lacks."""
+        return Graph(_combine.difference(self._store, that._store, node_identity, edge_identity))
+
+    def symmetric_difference[N2, E2, K2: Kind](
+        self: Graph[N2, E2, K2],
+        that: Graph[N2, E2, K2],
+        *,
+        node_identity: Callable[[N2], object] | None = None,
+        edge_identity: Callable[[E2], object] | None = None,
+    ) -> Graph[N2, E2, K2]:
+        """Every node of both, and the edges in exactly one."""
+        return Graph(
+            _combine.symmetric_difference(self._store, that._store, node_identity, edge_identity)
+        )
+
+    def complement[N2, E2, K2: Kind](
+        self: Graph[N2, E2, K2], create_edge: Callable[[N2, N2], E2]
+    ) -> Graph[N2, E2, K2]:
+        """The same nodes, with an edge (from ``create_edge(source, target)``)
+        wherever this graph has none; no self-loops."""
+        return Graph(_combine.complement(self._store, create_edge))
+
+    def neighborhood(
+        self,
+        node: int,
+        *,
+        radius: float | None = None,
+        direction: TraversalDirection = "outgoing",
+    ) -> Graph[N, E, K]:
+        """The subgraph of the nodes within ``radius`` (default 1) edges of
+        ``node``, re-indexed in breadth-first order."""
+        return Graph(_combine.neighborhood(self._store, node, radius, direction))
+
+    def induced_subgraph(self, nodes: Iterable[int]) -> Graph[N, E, K]:
+        """The given nodes and the edges among them, indexes kept."""
+        return Graph(_combine.induced_subgraph(self._store, nodes))
+
+    def sum[N2, E2, K2: Kind](
+        self: Graph[N2, E2, K2], that: Graph[N2, E2, K2]
+    ) -> Graph[N2, E2, K2]:
+        """This graph and ``that`` side by side, ``that`` re-indexed after it."""
+        return Graph(_combine.disjoint_sum(self._store, that._store))
+
+
+def _same_edge(kind: Kind, a: Edge[Any], b: Edge[Any]) -> bool:
+    ends = (a.source == b.source and a.target == b.target) or (
+        kind == "undirected" and a.source == b.target and a.target == b.source
+    )
+    return ends and equals(a.data, b.data)
+
+
+def _ends_key(kind: Kind, edge: Edge[Any]) -> object:
+    if kind == "directed":
+        return (edge.source, edge.target)
+    return (min(edge.source, edge.target), max(edge.source, edge.target))
+
+
+class MutableGraph[N, E, K: Kind = Literal["directed"]](GraphView[N, E, K]):
+    """A mutation handle: a private copy changed in place until
+    ``end_mutation`` turns it into a ``Graph``. After that every mutation
+    raises ``GraphError``; so does one made from inside a callback the
+    graph is running (a ``map_nodes`` function, a ``cost``, a walker's
+    ``visit``)."""
+
+    __slots__ = ()
+
+    def add_node(self, data: N) -> int:
+        """The new node's index: one past the highest ever allocated."""
+        return _mutate.add_node(self._store, data)
+
+    def add_edge(self, source: int, target: int, data: E) -> int:
+        return _mutate.add_edge(self._store, source, target, data)
+
+    def remove_node(self, node: int) -> None:
+        """Removes the node and its edges; a missing node is ignored."""
+        _mutate.remove_node(self._store, node)
+
+    def remove_nodes(self, nodes: Iterable[int]) -> None:
+        """``nodes`` is read in full first, so it may be a walker over this graph."""
+        _mutate.remove_nodes(self._store, nodes)
+
+    def remove_edge(self, edge: int) -> None:
+        _mutate.remove_edge(self._store, edge)
+
+    def remove_edges(self, edges: Iterable[int]) -> None:
+        _mutate.remove_edges(self._store, edges)
+
+    def update_node(self, node: int, f: Callable[[N], N]) -> None:
+        """Replaces the data of ``node`` with ``f(data)``; a missing node is ignored."""
+        _mutate.update_node(self._store, node, f)
+
+    def update_edge(self, edge: int, f: Callable[[E], E]) -> None:
+        _mutate.update_edge(self._store, edge, f)
+
+    def map_nodes(self, f: Callable[[N], N]) -> None:
+        _mutate.map_nodes(self._store, f)
+
+    def map_edges(self, f: Callable[[E], E]) -> None:
+        _mutate.map_edges(self._store, f)
+
+    def filter_map_nodes(self, f: Callable[[N], Option[N]]) -> None:
+        """Keeps ``Some`` results as the new data; removes the node (and
+        its edges) for ``None``."""
+        _mutate.filter_map_nodes(self._store, f)
+
+    def filter_map_edges(self, f: Callable[[E], Option[E]]) -> None:
+        _mutate.filter_map_edges(self._store, f)
+
+    def filter_nodes(self, predicate: Callable[[N], bool]) -> None:
+        _mutate.filter_nodes(self._store, predicate)
+
+    def filter_edges(self, predicate: Callable[[E], bool]) -> None:
+        _mutate.filter_edges(self._store, predicate)
+
+    def reverse(self) -> None:
+        """Turns every directed edge around; an undirected graph is unchanged."""
+        _mutate.reverse(self._store)
+
+    def end_mutation(self) -> Graph[N, E, K]:
+        """The finished graph; this handle stays readable but no longer mutable."""
+        _mutate.end_mutation(self._store)
+        return Graph(self._store)
+
+
+def _scoped[N, E, K: Kind](
+    mutable: MutableGraph[N, E, K], f: Callable[[MutableGraph[N, E, K]], object]
+) -> Graph[N, E, K]:
+    try:
+        f(mutable)
+    except BaseException:
+        if mutable.mutable:
+            mutable.end_mutation()
+        raise
+    return mutable.end_mutation()
+
+
+def make[K: Kind, N = Never, E = Never](
+    kind: K, build: Callable[[MutableGraph[N, E, K]], object] | None = None
+) -> Graph[N, E, K]:
+    """An empty graph of ``kind``, or the graph ``build`` makes of one."""
+    if kind not in ("directed", "undirected"):
+        fail("Graph type must be directed or undirected")
+    if build is None:
+        return Graph(Store(kind, False))
+    return _scoped(MutableGraph(Store(kind, True)), build)
+
+
+def directed[N = Never, E = Never](
+    build: Callable[[MutableGraph[N, E, Directed]], object] | None = None,
+) -> Graph[N, E, Directed]:
+    """``make("directed", build)``."""
+    return make("directed", build)
+
+
+def undirected[N = Never, E = Never](
+    build: Callable[[MutableGraph[N, E, Undirected]], object] | None = None,
+) -> Graph[N, E, Undirected]:
+    """``make("undirected", build)``."""
+    return make("undirected", build)
+
+
+def from_snapshot[N, E, K: Kind](snapshot: Snapshot[N, E, K]) -> Graph[N, E, K]:
+    """The graph of a snapshot, its indexes kept; raises ``GraphError``
+    for a malformed one. New nodes and edges get indexes past the highest."""
+    return Graph(_from_snapshot(snapshot))
+
+
+def is_graph(value: object) -> TypeIs[Graph[Any, Any, Kind] | MutableGraph[Any, Any, Kind]]:
+    return isinstance(value, GraphView)

pyfect/graph/_lowlink.py

@@ -0,0 +1,98 @@
+"""Bridges, articulation points and biconnected components of an
+undirected graph, from one iterative low-link depth-first search."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pyfect.graph._compact import view
+from pyfect.graph._errors import fail
+from pyfect.graph._store import Store
+
+
+@dataclass(frozen=True, slots=True)
+class LowLinks:
+    bridges: list[int]
+    articulation_points: list[int]
+    biconnected_components: list[list[int]]
+
+
+def analyze(store: Store) -> LowLinks:  # noqa: PLR0912, PLR0915
+    if store.kind == "directed":
+        fail("Cannot analyze undirected connectivity of directed graph")
+    compact = view(store)
+    neighbors, edge_rows = compact.outgoing, compact.edge_rows
+    sources, targets = compact.endpoints
+    size = len(compact)
+    discovered = [-1] * size
+    low = [0] * size
+    parent_node = [-1] * size
+    parent_edge = [-1] * size
+    children = [0] * size
+    bridge = [False] * len(compact.edge_ids)
+    articulation = [False] * size
+    edge_stack: list[int] = []
+    components: list[list[int]] = []
+    loops: dict[int, None] = {}
+    time = 0
+
+    def pop_component(stop: int) -> None:
+        nodes: set[int] = set()
+        while edge_stack:
+            edge = edge_stack.pop()
+            nodes.update((sources[edge], targets[edge]))
+            if edge == stop:
+                break
+        if nodes:
+            components.append(sorted(nodes))
+
+    for start in range(size):
+        if discovered[start] != -1:
+            continue
+        discovered[start] = low[start] = time
+        time += 1
+        stack = [[start, 0]]
+        while stack:
+            frame = stack[-1]
+            node = frame[0]
+            if frame[1] < len(neighbors[node]):
+                neighbor, edge = neighbors[node][frame[1]], edge_rows[node][frame[1]]
+                frame[1] += 1
+                if neighbor == node:
+                    loops[node] = None
+                elif edge == parent_edge[node]:
+                    pass
+                elif discovered[neighbor] == -1:
+                    children[node] += 1
+                    parent_node[neighbor] = node
+                    parent_edge[neighbor] = edge
+                    discovered[neighbor] = low[neighbor] = time
+                    time += 1
+                    edge_stack.append(edge)
+                    stack.append([neighbor, 0])
+                elif discovered[neighbor] < discovered[node]:
+                    low[node] = min(low[node], discovered[neighbor])
+                    edge_stack.append(edge)
+                continue
+            stack.pop()
+            parent = parent_node[node]
+            if parent == -1:
+                if children[node] > 1:
+                    articulation[node] = True
+                continue
+            low[parent] = min(low[parent], low[node])
+            if low[node] > discovered[parent]:
+                bridge[parent_edge[node]] = True
+            if low[node] >= discovered[parent]:
+                if parent_node[parent] != -1:
+                    articulation[parent] = True
+                pop_component(parent_edge[node])
+
+    components += [[node] for node in loops]
+    components.sort()
+    ids = compact.node_ids
+    return LowLinks(
+        [compact.edge_ids[e] for e, marked in enumerate(bridge) if marked],
+        [ids[n] for n, marked in enumerate(articulation) if marked],
+        [[ids[n] for n in component] for component in components],
+    )

pyfect/graph/_matching.py

@@ -0,0 +1,101 @@
+"""Maximum bipartite matching (Hopcroft-Karp), in Effect's order: the
+left side is color 0 of the breadth-first two-coloring, each left node
+tries its right neighbors in first-edge order, and a parallel edge after
+the first is never used."""
+
+from __future__ import annotations
+
+from collections import deque
+
+from pyfect.graph._cycles import two_coloring
+from pyfect.graph._errors import fail
+from pyfect.graph._records import BipartiteMatch
+from pyfect.graph._store import Store
+
+_UNMATCHED = -1
+_FAR = 0x7FFFFFFF
+
+
+def maximum_bipartite_matching(store: Store) -> list[BipartiteMatch]:  # noqa: PLR0915
+    colored = two_coloring(store, "find bipartite matching")
+    if colored is None:
+        fail("Cannot find bipartite matching of non-bipartite graph")
+    compact, colors = colored
+    size = len(compact)
+    sources, targets = compact.endpoints
+    # arcs[left]: (right, edge) for each distinct right neighbor.
+    arcs: list[list[tuple[int, int]]] = [[] for _ in range(size)]
+    seen: list[set[int]] = [set() for _ in range(size)]
+    for edge, (source, target) in enumerate(zip(sources, targets, strict=True)):
+        left, right = (source, target) if colors[source] == 0 else (target, source)
+        if right not in seen[left]:
+            seen[left].add(right)
+            arcs[left].append((right, edge))
+
+    match_left = [_UNMATCHED] * size
+    match_right = [_UNMATCHED] * size
+    match_edge = [_UNMATCHED] * size
+    distance = [0] * size
+    shortest = _FAR
+    lefts = [node for node in range(size) if colors[node] == 0]
+
+    def has_layer() -> bool:
+        nonlocal shortest
+        shortest = _FAR
+        queue: deque[int] = deque()
+        for left in lefts:
+            if match_left[left] == _UNMATCHED:
+                distance[left] = 0
+                queue.append(left)
+            else:
+                distance[left] = _FAR
+        while queue:
+            left = queue.popleft()
+            if distance[left] >= shortest:
+                continue
+            for right, _ in arcs[left]:
+                following = match_right[right]
+                if following == _UNMATCHED:
+                    shortest = distance[left] + 1
+                elif distance[following] == _FAR:
+                    distance[following] = distance[left] + 1
+                    queue.append(following)
+        return shortest != _FAR
+
+    def augment(start: int) -> None:
+        # A frame: [left, next arc, the right node and edge it was reached by].
+        stack = [[start, 0, _UNMATCHED, _UNMATCHED]]
+        while stack:
+            frame = stack[-1]
+            left = frame[0]
+            if frame[1] >= len(arcs[left]):
+                distance[left] = _FAR
+                stack.pop()
+                continue
+            right, edge = arcs[left][frame[1]]
+            frame[1] += 1
+            following = match_right[right]
+            if following == _UNMATCHED and distance[left] + 1 == shortest:
+                match_left[left], match_right[right], match_edge[left] = right, left, edge
+                for child, parent in zip(stack[:0:-1], stack[-2::-1], strict=True):
+                    match_left[parent[0]] = child[2]
+                    match_right[child[2]] = parent[0]
+                    match_edge[parent[0]] = child[3]
+                return
+            if following != _UNMATCHED and distance[following] == distance[left] + 1:
+                stack.append([following, 0, right, edge])
+
+    while has_layer():
+        for left in lefts:
+            if match_left[left] == _UNMATCHED:
+                augment(left)
+
+    return [
+        BipartiteMatch(
+            compact.node_ids[left],
+            compact.node_ids[match_left[left]],
+            compact.edge_ids[match_edge[left]],
+        )
+        for left in range(size)
+        if match_left[left] != _UNMATCHED
+    ]

pyfect/graph/_mutate.py

@@ -0,0 +1,211 @@
+"""Mutations of a mutable store. Each checks the store is writable (not
+finalized, not inside a callback) and drops its cached view first; user
+callbacks run with the store marked as transforming."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from typing import Any
+
+from pyfect.graph._errors import MAX_SAFE_INDEX, fail, missing_node
+from pyfect.graph._records import Edge
+from pyfect.graph._store import Store
+from pyfect.option import Option, Some
+
+
+def add_node(store: Store, data: object) -> int:
+    store.for_mutation()
+    index = store.next_node
+    if index > MAX_SAFE_INDEX:
+        fail("Graph has exhausted safe node indexes")
+    store.nodes[index] = data
+    store.adjacency[index] = []
+    store.reverse[index] = []
+    store.next_node = index + 1
+    return index
+
+
+def add_edge(store: Store, source: int, target: int, data: object) -> int:
+    store.for_mutation()
+    if source not in store.nodes:
+        raise missing_node(source)
+    if target not in store.nodes:
+        raise missing_node(target)
+    index = store.next_edge
+    if index > MAX_SAFE_INDEX:
+        fail("Graph has exhausted safe edge indexes")
+    store.edges[index] = Edge(source, target, data)
+    store.adjacency[source].append(index)
+    store.reverse[target].append(index)
+    if store.kind == "undirected":
+        store.adjacency[target].append(index)
+        store.reverse[source].append(index)
+    store.next_edge = index + 1
+    if store.acyclic is True:
+        store.acyclic = None
+    return index
+
+
+def _removed(store: Store) -> None:
+    if store.acyclic is False:
+        store.acyclic = None
+
+
+def _remove_node(store: Store, node: int) -> bool:
+    if node not in store.nodes:
+        return False
+    incident = dict.fromkeys(store.adjacency[node])
+    incident.update(dict.fromkeys(store.reverse[node]))
+    for index in incident:
+        edge = store.edges[index]
+        if edge.source != node:
+            store.adjacency[edge.source].remove(index)
+            if store.kind == "undirected":
+                store.reverse[edge.source].remove(index)
+        if edge.target != node:
+            store.reverse[edge.target].remove(index)
+            if store.kind == "undirected":
+                store.adjacency[edge.target].remove(index)
+        del store.edges[index]
+    del store.nodes[node]
+    del store.adjacency[node]
+    del store.reverse[node]
+    return True
+
+
+def _drop(lists: dict[int, list[int]], node: int, index: int) -> None:
+    edges = lists.get(node)
+    if edges is not None and index in edges:
+        edges.remove(index)
+
+
+def _remove_edge(store: Store, index: int) -> bool:
+    edge = store.edges.get(index)
+    if edge is None:
+        return False
+    _drop(store.adjacency, edge.source, index)
+    _drop(store.reverse, edge.target, index)
+    if store.kind == "undirected":
+        _drop(store.adjacency, edge.target, index)
+        _drop(store.reverse, edge.source, index)
+    del store.edges[index]
+    return True
+
+
+def remove_node(store: Store, node: int) -> None:
+    store.for_mutation()
+    if _remove_node(store, node):
+        _removed(store)
+
+
+def remove_edge(store: Store, index: int) -> None:
+    store.for_mutation()
+    if _remove_edge(store, index):
+        _removed(store)
+
+
+def _collect(store: Store, indices: Iterable[int]) -> list[int]:
+    """The indices, read before anything is removed (they may be a walker
+    over this very graph); reading them may not mutate it."""
+    store.check_writable()
+    with store.transformation():
+        collected = list(indices)
+    store.for_mutation()
+    return collected
+
+
+def remove_nodes(store: Store, nodes: Iterable[int]) -> None:
+    removed = [_remove_node(store, node) for node in _collect(store, nodes)]
+    if any(removed):
+        _removed(store)
+
+
+def remove_edges(store: Store, edges: Iterable[int]) -> None:
+    removed = [_remove_edge(store, edge) for edge in _collect(store, edges)]
+    if any(removed):
+        _removed(store)
+
+
+def update_node(store: Store, node: int, f: Callable[[Any], object]) -> None:
+    store.for_mutation()
+    with store.transformation():
+        if node in store.nodes:
+            store.nodes[node] = f(store.nodes[node])
+
+
+def update_edge(store: Store, index: int, f: Callable[[Any], object]) -> None:
+    store.for_mutation()
+    with store.transformation():
+        edge = store.edges.get(index)
+        if edge is not None:
+            store.edges[index] = Edge(edge.source, edge.target, f(edge.data))
+
+
+def map_nodes(store: Store, f: Callable[[Any], object]) -> None:
+    store.for_mutation()
+    with store.transformation():
+        for node, data in store.nodes.items():
+            store.nodes[node] = f(data)
+
+
+def map_edges(store: Store, f: Callable[[Any], object]) -> None:
+    store.for_mutation()
+    with store.transformation():
+        for index, edge in store.edges.items():
+            store.edges[index] = Edge(edge.source, edge.target, f(edge.data))
+
+
+def filter_map_nodes(store: Store, f: Callable[[Any], Option[object]]) -> None:
+    store.for_mutation()
+    remove: list[int] = []
+    with store.transformation():
+        for node, data in store.nodes.items():
+            match f(data):
+                case Some(value):
+                    store.nodes[node] = value
+                case None:
+                    remove.append(node)
+    remove_nodes(store, remove)
+
+
+def filter_map_edges(store: Store, f: Callable[[Any], Option[object]]) -> None:
+    store.for_mutation()
+    remove: list[int] = []
+    with store.transformation():
+        for index, edge in store.edges.items():
+            match f(edge.data):
+                case Some(value):
+                    store.edges[index] = Edge(edge.source, edge.target, value)
+                case None:
+                    remove.append(index)
+    remove_edges(store, remove)
+
+
+def filter_nodes(store: Store, predicate: Callable[[Any], bool]) -> None:
+    store.for_mutation()
+    with store.transformation():
+        remove = [node for node, data in store.nodes.items() if not predicate(data)]
+    remove_nodes(store, remove)
+
+
+def filter_edges(store: Store, predicate: Callable[[Any], bool]) -> None:
+    store.for_mutation()
+    with store.transformation():
+        remove = [index for index, edge in store.edges.items() if not predicate(edge.data)]
+    remove_edges(store, remove)
+
+
+def reverse(store: Store) -> None:
+    store.for_mutation()
+    if store.kind == "undirected":
+        return
+    for index, edge in store.edges.items():
+        store.edges[index] = Edge(edge.target, edge.source, edge.data)
+    store.adjacency, store.reverse = store.reverse, store.adjacency
+    store.acyclic = None
+
+
+def end_mutation(store: Store) -> None:
+    store.check_writable()
+    store.compact = None
+    store.mutable = False