okstra 0.108.0 → 0.110.0

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

@@ -0,0 +1,85 @@
+import pytest
+
+import networkx as nx
+from networkx import is_strongly_regular
+
+
+@pytest.mark.parametrize(
+    "f", (nx.is_distance_regular, nx.intersection_array, nx.is_strongly_regular)
+)
+@pytest.mark.parametrize("graph_constructor", (nx.DiGraph, nx.MultiGraph))
+def test_raises_on_directed_and_multigraphs(f, graph_constructor):
+    G = graph_constructor([(0, 1), (1, 2)])
+    with pytest.raises(nx.NetworkXNotImplemented):
+        f(G)
+
+
+class TestDistanceRegular:
+    def test_is_distance_regular(self):
+        assert nx.is_distance_regular(nx.icosahedral_graph())
+        assert nx.is_distance_regular(nx.petersen_graph())
+        assert nx.is_distance_regular(nx.cubical_graph())
+        assert nx.is_distance_regular(nx.complete_bipartite_graph(3, 3))
+        assert nx.is_distance_regular(nx.tetrahedral_graph())
+        assert nx.is_distance_regular(nx.dodecahedral_graph())
+        assert nx.is_distance_regular(nx.pappus_graph())
+        assert nx.is_distance_regular(nx.heawood_graph())
+        assert nx.is_distance_regular(nx.cycle_graph(3))
+        # no distance regular
+        assert not nx.is_distance_regular(nx.path_graph(4))
+
+    def test_not_connected(self):
+        G = nx.cycle_graph(4)
+        nx.add_cycle(G, [5, 6, 7])
+        assert not nx.is_distance_regular(G)
+
+    def test_global_parameters(self):
+        b, c = nx.intersection_array(nx.cycle_graph(5))
+        g = nx.global_parameters(b, c)
+        assert list(g) == [(0, 0, 2), (1, 0, 1), (1, 1, 0)]
+        b, c = nx.intersection_array(nx.cycle_graph(3))
+        g = nx.global_parameters(b, c)
+        assert list(g) == [(0, 0, 2), (1, 1, 0)]
+
+    def test_intersection_array(self):
+        b, c = nx.intersection_array(nx.cycle_graph(5))
+        assert b == [2, 1]
+        assert c == [1, 1]
+        b, c = nx.intersection_array(nx.dodecahedral_graph())
+        assert b == [3, 2, 1, 1, 1]
+        assert c == [1, 1, 1, 2, 3]
+        b, c = nx.intersection_array(nx.icosahedral_graph())
+        assert b == [5, 2, 1]
+        assert c == [1, 2, 5]
+
+
+@pytest.mark.parametrize("f", (nx.is_distance_regular, nx.is_strongly_regular))
+def test_empty_graph_raises(f):
+    G = nx.Graph()
+    with pytest.raises(nx.NetworkXPointlessConcept, match="Graph has no nodes"):
+        f(G)
+
+
+class TestStronglyRegular:
+    """Unit tests for the :func:`~networkx.is_strongly_regular`
+    function.
+
+    """
+
+    def test_cycle_graph(self):
+        """Tests that the cycle graph on five vertices is strongly
+        regular.
+
+        """
+        G = nx.cycle_graph(5)
+        assert is_strongly_regular(G)
+
+    def test_petersen_graph(self):
+        """Tests that the Petersen graph is strongly regular."""
+        G = nx.petersen_graph()
+        assert is_strongly_regular(G)
+
+    def test_path_graph(self):
+        """Tests that the path graph is not strongly regular."""
+        G = nx.path_graph(4)
+        assert not is_strongly_regular(G)

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

@@ -0,0 +1,299 @@
+import pytest
+
+import networkx as nx
+
+
+class TestImmediateDominators:
+    @pytest.mark.parametrize("G", [nx.Graph(), nx.MultiGraph()])
+    def test_raises_undirected(self, G):
+        """Check that `immediate_dominators` raises for undirected graphs."""
+        with pytest.raises(
+            nx.NetworkXNotImplemented, match=r"not implemented for undirected"
+        ):
+            nx.immediate_dominators(G, 0)
+
+    def test_raises_node(self):
+        """Check that `immediate_dominators` raises when `start` is not in the graph."""
+        G = nx.empty_graph(1, create_using=nx.DiGraph)
+        with pytest.raises(nx.NetworkXError, match=r"not in G"):
+            nx.immediate_dominators(G, 1)
+
+    def test_singleton(self):
+        G = nx.DiGraph()
+        G.add_node(0)
+        assert nx.immediate_dominators(G, 0) == {}
+        G.add_edge(0, 0)
+        assert nx.immediate_dominators(G, 0) == {}
+
+    @pytest.mark.parametrize("gen", [nx.path_graph, nx.cycle_graph])
+    @pytest.mark.parametrize("n", [5, 10, 20])
+    def test_path_and_cycle(self, gen, n):
+        """Check `immediate_dominators` is correct for path and cycle graphs."""
+        G = gen(n, create_using=nx.DiGraph())
+        idom = nx.immediate_dominators(G, 0)
+        assert idom == {i: i - 1 for i in range(1, n)}
+
+    def test_unreachable(self):
+        n = 5
+        G = nx.path_graph(n, create_using=nx.DiGraph())
+        idom = nx.immediate_dominators(G, 1)
+        assert idom == {i: i - 1 for i in range(2, n)}
+
+    @pytest.mark.parametrize(
+        ["edgelist", "start"],
+        [
+            ([(1, 2), (2, 1), (3, 2), (4, 1), (5, 3), (5, 4)], 5),
+            (
+                [
+                    (1, 2),
+                    (2, 1),
+                    (2, 3),
+                    (3, 2),
+                    (4, 2),
+                    (4, 3),
+                    (5, 1),
+                    (6, 4),
+                    (6, 5),
+                ],
+                6,
+            ),
+        ],
+    )
+    def test_irreducible(self, edgelist, start):
+        """
+        Check `immediate_dominators` on irreducible reference graphs.
+
+        Graphs taken from figures 2 and 4 of "A simple, fast dominance algorithm." (2006).
+        https://hdl.handle.net/1911/96345
+        """
+        G = nx.DiGraph(edgelist)
+        idom = nx.immediate_dominators(G, start)
+        assert idom == dict.fromkeys(range(1, start), start)
+
+    def test_domrel_png(self):
+        # Graph taken from https://commons.wikipedia.org/wiki/File:Domrel.png
+        edges = [(1, 2), (2, 3), (2, 4), (2, 6), (3, 5), (4, 5), (5, 2)]
+        G = nx.DiGraph(edges)
+        result = nx.immediate_dominators(G, 1)
+        assert result == {2: 1, 3: 2, 4: 2, 5: 2, 6: 2}
+        # Test postdominance.
+        result = nx.immediate_dominators(G.reverse(copy=False), 6)
+        assert result == {1: 2, 2: 6, 3: 5, 4: 5, 5: 2}
+
+    def test_boost_example(self):
+        # Graph taken from Figure 1 of
+        # http://www.boost.org/doc/libs/1_56_0/libs/graph/doc/lengauer_tarjan_dominator.htm
+        edges = [(0, 1), (1, 2), (1, 3), (2, 7), (3, 4), (4, 5), (4, 6), (5, 7), (6, 4)]
+        G = nx.DiGraph(edges)
+        result = nx.immediate_dominators(G, 0)
+        assert result == {1: 0, 2: 1, 3: 1, 4: 3, 5: 4, 6: 4, 7: 1}
+        # Test postdominance.
+        result = nx.immediate_dominators(G.reverse(copy=False), 7)
+        assert result == {0: 1, 1: 7, 2: 7, 3: 4, 4: 5, 5: 7, 6: 4}
+
+
+class TestDominanceFrontiers:
+    @pytest.mark.parametrize("G", [nx.Graph(), nx.MultiGraph()])
+    def test_raises_undirected(self, G):
+        """Check that `dominance_frontiers` raises for undirected graphs."""
+        with pytest.raises(
+            nx.NetworkXNotImplemented, match=r"not implemented for undirected"
+        ):
+            nx.dominance_frontiers(G, 0)
+
+    def test_raises_node(self):
+        """Check that `dominance_frontiers` raises when `start` is not in the graph."""
+        G = nx.empty_graph(1, create_using=nx.DiGraph)
+        with pytest.raises(nx.NetworkXError, match=r"not in G"):
+            nx.dominance_frontiers(G, 1)
+
+    def test_singleton(self):
+        G = nx.DiGraph()
+        G.add_node(0)
+        assert nx.dominance_frontiers(G, 0) == {0: set()}
+        G.add_edge(0, 0)
+        assert nx.dominance_frontiers(G, 0) == {0: {0}}
+
+    @pytest.mark.parametrize("gen, df", [(nx.path_graph, set()), (nx.cycle_graph, {0})])
+    @pytest.mark.parametrize("n", [5, 10, 20])
+    def test_path_and_cycle(self, gen, df, n):
+        """Check that `dominance_frontiers` is correct for path and cycle graphs."""
+        G = gen(n, create_using=nx.DiGraph())
+        assert nx.dominance_frontiers(G, 0) == dict.fromkeys(range(n), df)
+
+    def test_unreachable(self):
+        n = 5
+        G = nx.path_graph(n, create_using=nx.DiGraph())
+        assert nx.dominance_frontiers(G, 1) == dict.fromkeys(range(1, n), set())
+
+    def test_irreducible1(self):
+        """
+        Graph taken from figure 2 of "A simple, fast dominance algorithm." (2006).
+        https://hdl.handle.net/1911/96345
+        """
+        edges = [(1, 2), (2, 1), (3, 2), (4, 1), (5, 3), (5, 4)]
+        G = nx.DiGraph(edges)
+        assert nx.dominance_frontiers(G, 5) == {
+            1: {2},
+            2: {1},
+            3: {2},
+            4: {1},
+            5: set(),
+        }
+
+    def test_irreducible2(self):
+        """
+        Graph taken from figure 4 of "A simple, fast dominance algorithm." (2006).
+        https://hdl.handle.net/1911/96345
+        """
+        edges = [(1, 2), (2, 1), (2, 3), (3, 2), (4, 2), (4, 3), (5, 1), (6, 4), (6, 5)]
+        G = nx.DiGraph(edges)
+        assert nx.dominance_frontiers(G, 6) == {
+            1: {2},
+            2: {1, 3},
+            3: {2},
+            4: {2, 3},
+            5: {1},
+            6: set(),
+        }
+
+    def test_domrel_png(self):
+        # Graph taken from https://commons.wikipedia.org/wiki/File:Domrel.png
+        edges = [(1, 2), (2, 3), (2, 4), (2, 6), (3, 5), (4, 5), (5, 2)]
+        G = nx.DiGraph(edges)
+        assert nx.dominance_frontiers(G, 1) == {
+            1: set(),
+            2: {2},
+            3: {5},
+            4: {5},
+            5: {2},
+            6: set(),
+        }
+        # Test postdominance.
+        result = nx.dominance_frontiers(G.reverse(copy=False), 6)
+        assert result == {1: set(), 2: {2}, 3: {2}, 4: {2}, 5: {2}, 6: set()}
+
+    def test_boost_example(self):
+        # Graph taken from Figure 1 of
+        # http://www.boost.org/doc/libs/1_56_0/libs/graph/doc/lengauer_tarjan_dominator.htm
+        edges = [(0, 1), (1, 2), (1, 3), (2, 7), (3, 4), (4, 5), (4, 6), (5, 7), (6, 4)]
+        G = nx.DiGraph(edges)
+        assert nx.dominance_frontiers(G, 0) == {
+            0: set(),
+            1: set(),
+            2: {7},
+            3: {7},
+            4: {4, 7},
+            5: {7},
+            6: {4},
+            7: set(),
+        }
+        # Test postdominance.
+        result = nx.dominance_frontiers(G.reverse(copy=False), 7)
+        expected = {
+            0: set(),
+            1: set(),
+            2: {1},
+            3: {1},
+            4: {1, 4},
+            5: {1},
+            6: {4},
+            7: set(),
+        }
+        assert result == expected
+
+    def test_discard_issue(self):
+        # https://github.com/networkx/networkx/issues/2071
+        g = nx.DiGraph()
+        g.add_edges_from(
+            [
+                ("b0", "b1"),
+                ("b1", "b2"),
+                ("b2", "b3"),
+                ("b3", "b1"),
+                ("b1", "b5"),
+                ("b5", "b6"),
+                ("b5", "b8"),
+                ("b6", "b7"),
+                ("b8", "b7"),
+                ("b7", "b3"),
+                ("b3", "b4"),
+            ]
+        )
+        df = nx.dominance_frontiers(g, "b0")
+        assert df == {
+            "b4": set(),
+            "b5": {"b3"},
+            "b6": {"b7"},
+            "b7": {"b3"},
+            "b0": set(),
+            "b1": {"b1"},
+            "b2": {"b3"},
+            "b3": {"b1"},
+            "b8": {"b7"},
+        }
+
+    def test_loop(self):
+        g = nx.DiGraph()
+        g.add_edges_from([("a", "b"), ("b", "c"), ("b", "a")])
+        df = nx.dominance_frontiers(g, "a")
+        assert df == {"a": {"a"}, "b": {"a"}, "c": set()}
+
+    def test_missing_immediate_doms(self):
+        # see https://github.com/networkx/networkx/issues/2070
+        g = nx.DiGraph()
+        edges = [
+            ("entry_1", "b1"),
+            ("b1", "b2"),
+            ("b2", "b3"),
+            ("b3", "exit"),
+            ("entry_2", "b3"),
+        ]
+
+        # entry_1
+        #   |
+        #   b1
+        #   |
+        #   b2  entry_2
+        #    |  /
+        #    b3
+        #    |
+        #   exit
+
+        g.add_edges_from(edges)
+        # formerly raised KeyError on entry_2 when parsing b3
+        # because entry_2 does not have immediate doms (no path)
+        nx.dominance_frontiers(g, "entry_1")
+
+    def test_loops_larger(self):
+        # from
+        # http://ecee.colorado.edu/~waite/Darmstadt/motion.html
+        g = nx.DiGraph()
+        edges = [
+            ("entry", "exit"),
+            ("entry", "1"),
+            ("1", "2"),
+            ("2", "3"),
+            ("3", "4"),
+            ("4", "5"),
+            ("5", "6"),
+            ("6", "exit"),
+            ("6", "2"),
+            ("5", "3"),
+            ("4", "4"),
+        ]
+
+        g.add_edges_from(edges)
+        df = nx.dominance_frontiers(g, "entry")
+        answer = {
+            "entry": set(),
+            "1": {"exit"},
+            "2": {"exit", "2"},
+            "3": {"exit", "3", "2"},
+            "4": {"exit", "4", "3", "2"},
+            "5": {"exit", "3", "2"},
+            "6": {"exit", "2"},
+            "exit": set(),
+        }
+        for n in df:
+            assert set(df[n]) == set(answer[n])

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

@@ -0,0 +1,115 @@
+import pytest
+
+import networkx as nx
+
+
+def test_dominating_set():
+    G = nx.gnp_random_graph(100, 0.1)
+    D = nx.dominating_set(G)
+    assert nx.is_dominating_set(G, D)
+    D = nx.dominating_set(G, start_with=0)
+    assert nx.is_dominating_set(G, D)
+
+
+def test_complete():
+    """In complete graphs each node is a dominating set.
+    Thus the dominating set has to be of cardinality 1.
+    """
+    K4 = nx.complete_graph(4)
+    assert len(nx.dominating_set(K4)) == 1
+    K5 = nx.complete_graph(5)
+    assert len(nx.dominating_set(K5)) == 1
+
+
+def test_raise_dominating_set():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.path_graph(4)
+        D = nx.dominating_set(G, start_with=10)
+
+
+def test_is_dominating_set():
+    G = nx.path_graph(4)
+    d = {1, 3}
+    assert nx.is_dominating_set(G, d)
+    d = {0, 2}
+    assert nx.is_dominating_set(G, d)
+    d = {1}
+    assert not nx.is_dominating_set(G, d)
+
+
+def test_wikipedia_is_dominating_set():
+    """Example from https://en.wikipedia.org/wiki/Dominating_set"""
+    G = nx.cycle_graph(4)
+    G.add_edges_from([(0, 4), (1, 4), (2, 5)])
+    assert nx.is_dominating_set(G, {4, 3, 5})
+    assert nx.is_dominating_set(G, {0, 2})
+    assert nx.is_dominating_set(G, {1, 2})
+
+
+def test_is_connected_dominating_set():
+    G = nx.path_graph(4)
+    D = {1, 2}
+    assert nx.is_connected_dominating_set(G, D)
+    D = {1, 3}
+    assert not nx.is_connected_dominating_set(G, D)
+    D = {2, 3}
+    assert nx.is_connected(nx.subgraph(G, D))
+    assert not nx.is_connected_dominating_set(G, D)
+
+
+def test_null_graph_connected_dominating_set():
+    G = nx.Graph()
+    assert 0 == len(nx.connected_dominating_set(G))
+
+
+def test_single_node_graph_connected_dominating_set():
+    G = nx.Graph()
+    G.add_node(1)
+    CD = nx.connected_dominating_set(G)
+    assert nx.is_connected_dominating_set(G, CD)
+
+
+def test_raise_disconnected_graph_connected_dominating_set():
+    with pytest.raises(nx.NetworkXError):
+        G = nx.Graph()
+        G.add_node(1)
+        G.add_node(2)
+        nx.connected_dominating_set(G)
+
+
+def test_complete_graph_connected_dominating_set():
+    K5 = nx.complete_graph(5)
+    assert 1 == len(nx.connected_dominating_set(K5))
+    K7 = nx.complete_graph(7)
+    assert 1 == len(nx.connected_dominating_set(K7))
+
+
+def test_docstring_example_connected_dominating_set():
+    G = nx.Graph(
+        [
+            (1, 2),
+            (1, 3),
+            (1, 4),
+            (1, 5),
+            (1, 6),
+            (2, 7),
+            (3, 8),
+            (4, 9),
+            (5, 10),
+            (6, 11),
+            (7, 12),
+            (8, 12),
+            (9, 12),
+            (10, 12),
+            (11, 12),
+        ]
+    )
+    assert {1, 2, 3, 4, 5, 6, 7} == nx.connected_dominating_set(G)
+
+
+@pytest.mark.parametrize("seed", [1, 13, 29])
+@pytest.mark.parametrize("n,k,p", [(10, 3, 0.2), (100, 10, 0.7), (1000, 50, 0.5)])
+def test_connected_watts_strogatz_graph_connected_dominating_set(n, k, p, seed):
+    G = nx.connected_watts_strogatz_graph(n, k, p, seed=seed)
+    D = nx.connected_dominating_set(G)
+    assert nx.is_connected_dominating_set(G, D)

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

@@ -0,0 +1,58 @@
+"""Unit tests for the :mod:`networkx.algorithms.efficiency` module."""
+
+import networkx as nx
+
+
+class TestEfficiency:
+    def setup_method(self):
+        # G1 is a disconnected graph
+        self.G1 = nx.Graph()
+        self.G1.add_nodes_from([1, 2, 3])
+        # G2 is a cycle graph
+        self.G2 = nx.cycle_graph(4)
+        # G3 is the triangle graph with one additional edge
+        self.G3 = nx.lollipop_graph(3, 1)
+
+    def test_efficiency_disconnected_nodes(self):
+        """
+        When nodes are disconnected, efficiency is 0
+        """
+        assert nx.efficiency(self.G1, 1, 2) == 0
+
+    def test_local_efficiency_disconnected_graph(self):
+        """
+        In a disconnected graph the efficiency is 0
+        """
+        assert nx.local_efficiency(self.G1) == 0
+
+    def test_efficiency(self):
+        assert nx.efficiency(self.G2, 0, 1) == 1
+        assert nx.efficiency(self.G2, 0, 2) == 1 / 2
+
+    def test_global_efficiency(self):
+        assert nx.global_efficiency(self.G2) == 5 / 6
+
+    def test_global_efficiency_complete_graph(self):
+        """
+        Tests that the average global efficiency of the complete graph is one.
+        """
+        for n in range(2, 10):
+            G = nx.complete_graph(n)
+            assert nx.global_efficiency(G) == 1
+
+    def test_local_efficiency_complete_graph(self):
+        """
+        Test that the local efficiency for a complete graph with at least 3
+        nodes should be one. For a graph with only 2 nodes, the induced
+        subgraph has no edges.
+        """
+        for n in range(3, 10):
+            G = nx.complete_graph(n)
+            assert nx.local_efficiency(G) == 1
+
+    def test_using_ego_graph(self):
+        """
+        Test that the ego graph is used when computing local efficiency.
+        For more information, see GitHub issue #2710.
+        """
+        assert nx.local_efficiency(self.G3) == 7 / 12