okstra 0.108.0 → 0.110.0

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_bridges.py

@@ -0,0 +1,144 @@
+"""Unit tests for bridge-finding algorithms."""
+
+import pytest
+
+import networkx as nx
+
+
+class TestBridges:
+    """Unit tests for the bridge-finding function."""
+
+    def test_single_bridge(self):
+        edges = [
+            # DFS tree edges.
+            (1, 2),
+            (2, 3),
+            (3, 4),
+            (3, 5),
+            (5, 6),
+            (6, 7),
+            (7, 8),
+            (5, 9),
+            (9, 10),
+            # Nontree edges.
+            (1, 3),
+            (1, 4),
+            (2, 5),
+            (5, 10),
+            (6, 8),
+        ]
+        G = nx.Graph(edges)
+        source = 1
+        bridges = list(nx.bridges(G, source))
+        assert bridges == [(5, 6)]
+
+    def test_barbell_graph(self):
+        # The (3, 0) barbell graph has two triangles joined by a single edge.
+        G = nx.barbell_graph(3, 0)
+        source = 0
+        bridges = list(nx.bridges(G, source))
+        assert bridges == [(2, 3)]
+
+    def test_multiedge_bridge(self):
+        edges = [
+            (0, 1),
+            (0, 2),
+            (1, 2),
+            (1, 2),
+            (2, 3),
+            (3, 4),
+            (3, 4),
+        ]
+        G = nx.MultiGraph(edges)
+        assert list(nx.bridges(G)) == [(2, 3)]
+
+
+class TestHasBridges:
+    """Unit tests for the has bridges function."""
+
+    def test_single_bridge(self):
+        edges = [
+            # DFS tree edges.
+            (1, 2),
+            (2, 3),
+            (3, 4),
+            (3, 5),
+            (5, 6),  # The only bridge edge
+            (6, 7),
+            (7, 8),
+            (5, 9),
+            (9, 10),
+            # Nontree edges.
+            (1, 3),
+            (1, 4),
+            (2, 5),
+            (5, 10),
+            (6, 8),
+        ]
+        G = nx.Graph(edges)
+        assert nx.has_bridges(G)  # Default root
+        assert nx.has_bridges(G, root=1)  # arbitrary root in G
+
+    def test_has_bridges_raises_root_not_in_G(self):
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3])
+        with pytest.raises(nx.NodeNotFound):
+            nx.has_bridges(G, root=6)
+
+    def test_multiedge_bridge(self):
+        edges = [
+            (0, 1),
+            (0, 2),
+            (1, 2),
+            (1, 2),
+            (2, 3),
+            (3, 4),
+            (3, 4),
+        ]
+        G = nx.MultiGraph(edges)
+        assert nx.has_bridges(G)
+        # Make every edge a multiedge
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        assert not nx.has_bridges(G)
+
+    def test_bridges_multiple_components(self):
+        G = nx.Graph()
+        nx.add_path(G, [0, 1, 2])  # One connected component
+        nx.add_path(G, [4, 5, 6])  # Another connected component
+        assert list(nx.bridges(G, root=4)) == [(4, 5), (5, 6)]
+
+
+class TestLocalBridges:
+    """Unit tests for the local_bridge function."""
+
+    @classmethod
+    def setup_class(cls):
+        cls.BB = nx.barbell_graph(4, 0)
+        cls.square = nx.cycle_graph(4)
+        cls.tri = nx.cycle_graph(3)
+
+    def test_nospan(self):
+        expected = {(3, 4), (4, 3)}
+        assert next(nx.local_bridges(self.BB, with_span=False)) in expected
+        assert set(nx.local_bridges(self.square, with_span=False)) == self.square.edges
+        assert list(nx.local_bridges(self.tri, with_span=False)) == []
+
+    def test_no_weight(self):
+        inf = float("inf")
+        expected = {(3, 4, inf), (4, 3, inf)}
+        assert next(nx.local_bridges(self.BB)) in expected
+        expected = {(u, v, 3) for u, v in self.square.edges}
+        assert set(nx.local_bridges(self.square)) == expected
+        assert list(nx.local_bridges(self.tri)) == []
+
+    def test_weight(self):
+        inf = float("inf")
+        G = self.square.copy()
+
+        G.edges[1, 2]["weight"] = 2
+        expected = {(u, v, 5 - wt) for u, v, wt in G.edges(data="weight", default=1)}
+        assert set(nx.local_bridges(G, weight="weight")) == expected
+
+        expected = {(u, v, 6) for u, v in G.edges}
+        lb = nx.local_bridges(G, weight=lambda u, v, d: 2)
+        assert set(lb) == expected

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_broadcasting.py

@@ -0,0 +1,109 @@
+"""Unit tests for the broadcasting module."""
+
+import math
+
+import pytest
+
+import networkx as nx
+
+
+def test_example_tree_broadcast():
+    """
+    Test the BROADCAST algorithm on the example in the paper titled: "Information Dissemination in Trees"
+    """
+    edge_list = [
+        (0, 1),
+        (1, 2),
+        (2, 7),
+        (3, 4),
+        (5, 4),
+        (4, 7),
+        (6, 7),
+        (7, 9),
+        (8, 9),
+        (9, 13),
+        (13, 14),
+        (14, 15),
+        (14, 16),
+        (14, 17),
+        (13, 11),
+        (11, 10),
+        (11, 12),
+        (13, 18),
+        (18, 19),
+        (18, 20),
+    ]
+    G = nx.Graph(edge_list)
+    b_T, b_C = nx.tree_broadcast_center(G)
+    assert b_T == 6
+    assert b_C == {13, 9}
+    # test broadcast time from specific vertex
+    assert nx.tree_broadcast_time(G, 17) == 8
+    assert nx.tree_broadcast_time(G, 3) == 9
+    # test broadcast time of entire tree
+    assert nx.tree_broadcast_time(G) == 10
+
+
+@pytest.mark.parametrize("n", range(2, 12))
+def test_path_broadcast(n):
+    G = nx.path_graph(n)
+    b_T, b_C = nx.tree_broadcast_center(G)
+    assert b_T == math.ceil(n / 2)
+    assert b_C == {
+        math.ceil(n / 2),
+        n // 2,
+        math.ceil(n / 2 - 1),
+        n // 2 - 1,
+    }
+    assert nx.tree_broadcast_time(G) == n - 1
+
+
+def test_empty_graph_broadcast():
+    H = nx.empty_graph(1)
+    b_T, b_C = nx.tree_broadcast_center(H)
+    assert b_T == 0
+    assert b_C == {0}
+    assert nx.tree_broadcast_time(H) == 0
+
+
+@pytest.mark.parametrize("n", range(4, 12))
+def test_star_broadcast(n):
+    G = nx.star_graph(n)
+    b_T, b_C = nx.tree_broadcast_center(G)
+    assert b_T == n
+    assert b_C == set(G.nodes())
+    assert nx.tree_broadcast_time(G) == b_T
+
+
+@pytest.mark.parametrize("n", range(2, 8))
+def test_binomial_tree_broadcast(n):
+    G = nx.binomial_tree(n)
+    b_T, b_C = nx.tree_broadcast_center(G)
+    assert b_T == n
+    assert b_C == {0, 2 ** (n - 1)}
+    assert nx.tree_broadcast_time(G) == 2 * n - 1
+
+
+@pytest.mark.parametrize("fn", [nx.tree_broadcast_center, nx.tree_broadcast_time])
+@pytest.mark.parametrize("graph_type", [nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph])
+def test_raises_graph_type(fn, graph_type):
+    """Check that broadcast functions properly raise for directed and multigraph types."""
+    G = nx.path_graph(5, create_using=graph_type)
+    with pytest.raises(nx.NetworkXNotImplemented, match=r"not implemented for"):
+        fn(G)
+
+
+@pytest.mark.parametrize("fn", [nx.tree_broadcast_center, nx.tree_broadcast_time])
+@pytest.mark.parametrize("gen", [nx.empty_graph, nx.cycle_graph])
+def test_raises_not_tree(fn, gen):
+    """Check that broadcast functions properly raise for nontree graphs."""
+    G = gen(5)
+    with pytest.raises(nx.NotATree, match=r"not a tree"):
+        fn(G)
+
+
+def test_raises_node_not_in_G():
+    """Check that `tree_broadcast_time` properly raises for invalid nodes."""
+    G = nx.path_graph(5)
+    with pytest.raises(nx.NodeNotFound, match=r"node.*not in G"):
+        nx.tree_broadcast_time(G, node=10)

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_chains.py

@@ -0,0 +1,136 @@
+"""Unit tests for the chain decomposition functions."""
+
+from itertools import cycle, islice
+
+import pytest
+
+import networkx as nx
+
+
+def cycles(seq):
+    """Yields cyclic permutations of the given sequence.
+
+    For example::
+
+        >>> list(cycles("abc"))
+        [('a', 'b', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b')]
+
+    """
+    n = len(seq)
+    cycled_seq = cycle(seq)
+    for x in seq:
+        yield tuple(islice(cycled_seq, n))
+        next(cycled_seq)
+
+
+def cyclic_equals(seq1, seq2):
+    """Decide whether two sequences are equal up to cyclic permutations.
+
+    For example::
+
+        >>> cyclic_equals("xyz", "zxy")
+        True
+        >>> cyclic_equals("xyz", "zyx")
+        False
+
+    """
+    # Cast seq2 to a tuple since `cycles()` yields tuples.
+    seq2 = tuple(seq2)
+    return any(x == tuple(seq2) for x in cycles(seq1))
+
+
+class TestChainDecomposition:
+    """Unit tests for the chain decomposition function."""
+
+    def assertContainsChain(self, chain, expected):
+        # A cycle could be expressed in two different orientations, one
+        # forward and one backward, so we need to check for cyclic
+        # equality in both orientations.
+        reversed_chain = list(reversed([tuple(reversed(e)) for e in chain]))
+        for candidate in expected:
+            if cyclic_equals(chain, candidate):
+                break
+            if cyclic_equals(reversed_chain, candidate):
+                break
+        else:
+            self.fail("chain not found")
+
+    def test_decomposition(self):
+        edges = [
+            # DFS tree edges.
+            (1, 2),
+            (2, 3),
+            (3, 4),
+            (3, 5),
+            (5, 6),
+            (6, 7),
+            (7, 8),
+            (5, 9),
+            (9, 10),
+            # Nontree edges.
+            (1, 3),
+            (1, 4),
+            (2, 5),
+            (5, 10),
+            (6, 8),
+        ]
+        G = nx.Graph(edges)
+        expected = [
+            [(1, 3), (3, 2), (2, 1)],
+            [(1, 4), (4, 3)],
+            [(2, 5), (5, 3)],
+            [(5, 10), (10, 9), (9, 5)],
+            [(6, 8), (8, 7), (7, 6)],
+        ]
+        chains = list(nx.chain_decomposition(G, root=1))
+        assert len(chains) == len(expected)
+
+    def test_barbell_graph(self):
+        # The (3, 0) barbell graph has two triangles joined by a single edge.
+        G = nx.barbell_graph(3, 0)
+        chains = list(nx.chain_decomposition(G, root=0))
+        expected = [[(0, 1), (1, 2), (2, 0)], [(3, 4), (4, 5), (5, 3)]]
+        assert len(chains) == len(expected)
+        for chain in chains:
+            self.assertContainsChain(chain, expected)
+
+    def test_disconnected_graph(self):
+        """Test for a graph with multiple connected components."""
+        G = nx.barbell_graph(3, 0)
+        H = nx.barbell_graph(3, 0)
+        mapping = dict(zip(range(6), "abcdef"))
+        nx.relabel_nodes(H, mapping, copy=False)
+        G = nx.union(G, H)
+        chains = list(nx.chain_decomposition(G))
+        expected = [
+            [(0, 1), (1, 2), (2, 0)],
+            [(3, 4), (4, 5), (5, 3)],
+            [("a", "b"), ("b", "c"), ("c", "a")],
+            [("d", "e"), ("e", "f"), ("f", "d")],
+        ]
+        assert len(chains) == len(expected)
+        for chain in chains:
+            self.assertContainsChain(chain, expected)
+
+    def test_disconnected_graph_root_node(self):
+        """Test for a single component of a disconnected graph."""
+        G = nx.barbell_graph(3, 0)
+        H = nx.barbell_graph(3, 0)
+        mapping = dict(zip(range(6), "abcdef"))
+        nx.relabel_nodes(H, mapping, copy=False)
+        G = nx.union(G, H)
+        chains = list(nx.chain_decomposition(G, root="a"))
+        expected = [
+            [("a", "b"), ("b", "c"), ("c", "a")],
+            [("d", "e"), ("e", "f"), ("f", "d")],
+        ]
+        assert len(chains) == len(expected)
+        for chain in chains:
+            self.assertContainsChain(chain, expected)
+
+    def test_chain_decomposition_root_not_in_G(self):
+        """Test chain decomposition when root is not in graph"""
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3])
+        with pytest.raises(nx.NodeNotFound):
+            nx.has_bridges(G, root=6)

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_chordal.py

@@ -0,0 +1,129 @@
+import pytest
+
+import networkx as nx
+
+
+class TestMCS:
+    @classmethod
+    def setup_class(cls):
+        # simple graph
+        connected_chordal_G = nx.Graph()
+        connected_chordal_G.add_edges_from(
+            [
+                (1, 2),
+                (1, 3),
+                (2, 3),
+                (2, 4),
+                (3, 4),
+                (3, 5),
+                (3, 6),
+                (4, 5),
+                (4, 6),
+                (5, 6),
+            ]
+        )
+        cls.connected_chordal_G = connected_chordal_G
+
+        chordal_G = nx.Graph()
+        chordal_G.add_edges_from(
+            [
+                (1, 2),
+                (1, 3),
+                (2, 3),
+                (2, 4),
+                (3, 4),
+                (3, 5),
+                (3, 6),
+                (4, 5),
+                (4, 6),
+                (5, 6),
+                (7, 8),
+            ]
+        )
+        chordal_G.add_node(9)
+        cls.chordal_G = chordal_G
+
+        non_chordal_G = nx.Graph()
+        non_chordal_G.add_edges_from([(1, 2), (1, 3), (2, 4), (2, 5), (3, 4), (3, 5)])
+        cls.non_chordal_G = non_chordal_G
+
+        self_loop_G = nx.Graph()
+        self_loop_G.add_edges_from([(1, 1)])
+        cls.self_loop_G = self_loop_G
+
+    @pytest.mark.parametrize("G", (nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()))
+    def test_is_chordal_not_implemented(self, G):
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.is_chordal(G)
+
+    def test_is_chordal(self):
+        assert not nx.is_chordal(self.non_chordal_G)
+        assert nx.is_chordal(self.chordal_G)
+        assert nx.is_chordal(self.connected_chordal_G)
+        assert nx.is_chordal(nx.Graph())
+        assert nx.is_chordal(nx.complete_graph(3))
+        assert nx.is_chordal(nx.cycle_graph(3))
+        assert not nx.is_chordal(nx.cycle_graph(5))
+        assert nx.is_chordal(self.self_loop_G)
+
+    def test_induced_nodes(self):
+        G = nx.generators.classic.path_graph(10)
+        Induced_nodes = nx.find_induced_nodes(G, 1, 9, 2)
+        assert Induced_nodes == {1, 2, 3, 4, 5, 6, 7, 8, 9}
+        pytest.raises(
+            nx.NetworkXTreewidthBoundExceeded, nx.find_induced_nodes, G, 1, 9, 1
+        )
+        Induced_nodes = nx.find_induced_nodes(self.chordal_G, 1, 6)
+        assert Induced_nodes == {1, 2, 4, 6}
+        pytest.raises(nx.NetworkXError, nx.find_induced_nodes, self.non_chordal_G, 1, 5)
+
+    def test_graph_treewidth(self):
+        with pytest.raises(nx.NetworkXError, match="Input graph is not chordal"):
+            nx.chordal_graph_treewidth(self.non_chordal_G)
+
+    def test_chordal_find_cliques(self):
+        cliques = {
+            frozenset([9]),
+            frozenset([7, 8]),
+            frozenset([1, 2, 3]),
+            frozenset([2, 3, 4]),
+            frozenset([3, 4, 5, 6]),
+        }
+        assert set(nx.chordal_graph_cliques(self.chordal_G)) == cliques
+        with pytest.raises(nx.NetworkXError, match="Input graph is not chordal"):
+            set(nx.chordal_graph_cliques(self.non_chordal_G))
+        with pytest.raises(nx.NetworkXError, match="Input graph is not chordal"):
+            set(nx.chordal_graph_cliques(self.self_loop_G))
+
+    def test_chordal_find_cliques_path(self):
+        G = nx.path_graph(10)
+        cliqueset = nx.chordal_graph_cliques(G)
+        for u, v in G.edges():
+            assert frozenset([u, v]) in cliqueset or frozenset([v, u]) in cliqueset
+
+    def test_chordal_find_cliquesCC(self):
+        cliques = {frozenset([1, 2, 3]), frozenset([2, 3, 4]), frozenset([3, 4, 5, 6])}
+        cgc = nx.chordal_graph_cliques
+        assert set(cgc(self.connected_chordal_G)) == cliques
+
+    def test_complete_to_chordal_graph(self):
+        fgrg = nx.fast_gnp_random_graph
+        test_graphs = [
+            nx.barbell_graph(6, 2),
+            nx.cycle_graph(15),
+            nx.wheel_graph(20),
+            nx.grid_graph([10, 4]),
+            nx.ladder_graph(15),
+            nx.star_graph(5),
+            nx.bull_graph(),
+            fgrg(20, 0.3, seed=1),
+        ]
+        for G in test_graphs:
+            H, a = nx.complete_to_chordal_graph(G)
+            assert nx.is_chordal(H)
+            assert len(a) == H.number_of_nodes()
+            if nx.is_chordal(G):
+                assert G.number_of_edges() == H.number_of_edges()
+                assert set(a.values()) == {0}
+            else:
+                assert len(set(a.values())) == H.number_of_nodes()