okstra 0.113.0 → 0.115.0

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

@@ -1,80 +0,0 @@
-from collections import defaultdict
-
-import pytest
-
-pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-import networkx as nx
-from networkx.algorithms.communicability_alg import communicability, communicability_exp
-
-
-class TestCommunicability:
-    def test_communicability(self):
-        answer = {
-            0: {0: 1.5430806348152435, 1: 1.1752011936438012},
-            1: {0: 1.1752011936438012, 1: 1.5430806348152435},
-        }
-        #        answer={(0, 0): 1.5430806348152435,
-        #                (0, 1): 1.1752011936438012,
-        #                (1, 0): 1.1752011936438012,
-        #                (1, 1): 1.5430806348152435}
-
-        result = communicability(nx.path_graph(2))
-        for k1, val in result.items():
-            for k2 in val:
-                assert answer[k1][k2] == pytest.approx(result[k1][k2], abs=1e-7)
-
-    def test_communicability2(self):
-        answer_orig = {
-            ("1", "1"): 1.6445956054135658,
-            ("1", "Albert"): 0.7430186221096251,
-            ("1", "Aric"): 0.7430186221096251,
-            ("1", "Dan"): 1.6208126320442937,
-            ("1", "Franck"): 0.42639707170035257,
-            ("Albert", "1"): 0.7430186221096251,
-            ("Albert", "Albert"): 2.4368257358712189,
-            ("Albert", "Aric"): 1.4368257358712191,
-            ("Albert", "Dan"): 2.0472097037446453,
-            ("Albert", "Franck"): 1.8340111678944691,
-            ("Aric", "1"): 0.7430186221096251,
-            ("Aric", "Albert"): 1.4368257358712191,
-            ("Aric", "Aric"): 2.4368257358712193,
-            ("Aric", "Dan"): 2.0472097037446457,
-            ("Aric", "Franck"): 1.8340111678944691,
-            ("Dan", "1"): 1.6208126320442937,
-            ("Dan", "Albert"): 2.0472097037446453,
-            ("Dan", "Aric"): 2.0472097037446457,
-            ("Dan", "Dan"): 3.1306328496328168,
-            ("Dan", "Franck"): 1.4860372442192515,
-            ("Franck", "1"): 0.42639707170035257,
-            ("Franck", "Albert"): 1.8340111678944691,
-            ("Franck", "Aric"): 1.8340111678944691,
-            ("Franck", "Dan"): 1.4860372442192515,
-            ("Franck", "Franck"): 2.3876142275231915,
-        }
-
-        answer = defaultdict(dict)
-        for (k1, k2), v in answer_orig.items():
-            answer[k1][k2] = v
-
-        G1 = nx.Graph(
-            [
-                ("Franck", "Aric"),
-                ("Aric", "Dan"),
-                ("Dan", "Albert"),
-                ("Albert", "Franck"),
-                ("Dan", "1"),
-                ("Franck", "Albert"),
-            ]
-        )
-
-        result = communicability(G1)
-        for k1, val in result.items():
-            for k2 in val:
-                assert answer[k1][k2] == pytest.approx(result[k1][k2], abs=1e-7)
-
-        result = communicability_exp(G1)
-        for k1, val in result.items():
-            for k2 in val:
-                assert answer[k1][k2] == pytest.approx(result[k1][k2], abs=1e-7)

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

@@ -1,266 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.utils import nodes_equal
-
-
-class TestCore:
-    @classmethod
-    def setup_class(cls):
-        # G is the example graph in Figure 1 from Batagelj and
-        # Zaversnik's paper titled An O(m) Algorithm for Cores
-        # Decomposition of Networks, 2003,
-        # http://arXiv.org/abs/cs/0310049.  With nodes labeled as
-        # shown, the 3-core is given by nodes 1-8, the 2-core by nodes
-        # 9-16, the 1-core by nodes 17-20 and node 21 is in the
-        # 0-core.
-        t1 = nx.convert_node_labels_to_integers(nx.tetrahedral_graph(), 1)
-        t2 = nx.convert_node_labels_to_integers(t1, 5)
-        G = nx.union(t1, t2)
-        G.add_edges_from(
-            [
-                (3, 7),
-                (2, 11),
-                (11, 5),
-                (11, 12),
-                (5, 12),
-                (12, 19),
-                (12, 18),
-                (3, 9),
-                (7, 9),
-                (7, 10),
-                (9, 10),
-                (9, 20),
-                (17, 13),
-                (13, 14),
-                (14, 15),
-                (15, 16),
-                (16, 13),
-            ]
-        )
-        G.add_node(21)
-        cls.G = G
-
-        # Create the graph H resulting from the degree sequence
-        # [0, 1, 2, 2, 2, 2, 3] when using the Havel-Hakimi algorithm.
-
-        degseq = [0, 1, 2, 2, 2, 2, 3]
-        H = nx.havel_hakimi_graph(degseq)
-        mapping = {6: 0, 0: 1, 4: 3, 5: 6, 3: 4, 1: 2, 2: 5}
-        cls.H = nx.relabel_nodes(H, mapping)
-
-    def test_trivial(self):
-        """Empty graph"""
-        G = nx.Graph()
-        assert nx.core_number(G) == {}
-
-    def test_core_number(self):
-        core = nx.core_number(self.G)
-        nodes_by_core = [sorted(n for n in core if core[n] == val) for val in range(4)]
-        assert nodes_equal(nodes_by_core[0], [21])
-        assert nodes_equal(nodes_by_core[1], [17, 18, 19, 20])
-        assert nodes_equal(nodes_by_core[2], [9, 10, 11, 12, 13, 14, 15, 16])
-        assert nodes_equal(nodes_by_core[3], [1, 2, 3, 4, 5, 6, 7, 8])
-
-    def test_core_number2(self):
-        core = nx.core_number(self.H)
-        nodes_by_core = [sorted(n for n in core if core[n] == val) for val in range(3)]
-        assert nodes_equal(nodes_by_core[0], [0])
-        assert nodes_equal(nodes_by_core[1], [1, 3])
-        assert nodes_equal(nodes_by_core[2], [2, 4, 5, 6])
-
-    def test_core_number_multigraph(self):
-        G = nx.complete_graph(3)
-        G = nx.MultiGraph(G)
-        G.add_edge(1, 2)
-        with pytest.raises(
-            nx.NetworkXNotImplemented, match="not implemented for multigraph type"
-        ):
-            nx.core_number(G)
-
-    def test_core_number_self_loop(self):
-        G = nx.cycle_graph(3)
-        G.add_edge(0, 0)
-        with pytest.raises(
-            nx.NetworkXNotImplemented, match="Input graph has self loops"
-        ):
-            nx.core_number(G)
-
-    def test_directed_core_number(self):
-        """core number had a bug for directed graphs found in issue #1959"""
-        # small example where too timid edge removal can make cn[2] = 3
-        G = nx.DiGraph()
-        edges = [(1, 2), (2, 1), (2, 3), (2, 4), (3, 4), (4, 3)]
-        G.add_edges_from(edges)
-        assert nx.core_number(G) == {1: 2, 2: 2, 3: 2, 4: 2}
-        # small example where too aggressive edge removal can make cn[2] = 2
-        more_edges = [(1, 5), (3, 5), (4, 5), (3, 6), (4, 6), (5, 6)]
-        G.add_edges_from(more_edges)
-        assert nx.core_number(G) == {1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3}
-
-    def test_main_core(self):
-        main_core_subgraph = nx.k_core(self.H)
-        assert sorted(main_core_subgraph.nodes()) == [2, 4, 5, 6]
-
-    def test_k_core(self):
-        # k=0
-        k_core_subgraph = nx.k_core(self.H, k=0)
-        assert sorted(k_core_subgraph.nodes()) == sorted(self.H.nodes())
-        # k=1
-        k_core_subgraph = nx.k_core(self.H, k=1)
-        assert sorted(k_core_subgraph.nodes()) == [1, 2, 3, 4, 5, 6]
-        # k = 2
-        k_core_subgraph = nx.k_core(self.H, k=2)
-        assert sorted(k_core_subgraph.nodes()) == [2, 4, 5, 6]
-
-    def test_k_core_multigraph(self):
-        core_number = nx.core_number(self.H)
-        H = nx.MultiGraph(self.H)
-        with pytest.raises(nx.NetworkXNotImplemented):
-            nx.k_core(H, k=0, core_number=core_number)
-
-    def test_main_crust(self):
-        main_crust_subgraph = nx.k_crust(self.H)
-        assert sorted(main_crust_subgraph.nodes()) == [0, 1, 3]
-
-    def test_k_crust(self):
-        # k = 0
-        k_crust_subgraph = nx.k_crust(self.H, k=2)
-        assert sorted(k_crust_subgraph.nodes()) == sorted(self.H.nodes())
-        # k=1
-        k_crust_subgraph = nx.k_crust(self.H, k=1)
-        assert sorted(k_crust_subgraph.nodes()) == [0, 1, 3]
-        # k=2
-        k_crust_subgraph = nx.k_crust(self.H, k=0)
-        assert sorted(k_crust_subgraph.nodes()) == [0]
-
-    def test_k_crust_multigraph(self):
-        core_number = nx.core_number(self.H)
-        H = nx.MultiGraph(self.H)
-        with pytest.raises(nx.NetworkXNotImplemented):
-            nx.k_crust(H, k=0, core_number=core_number)
-
-    def test_main_shell(self):
-        main_shell_subgraph = nx.k_shell(self.H)
-        assert sorted(main_shell_subgraph.nodes()) == [2, 4, 5, 6]
-
-    def test_k_shell(self):
-        # k=0
-        k_shell_subgraph = nx.k_shell(self.H, k=2)
-        assert sorted(k_shell_subgraph.nodes()) == [2, 4, 5, 6]
-        # k=1
-        k_shell_subgraph = nx.k_shell(self.H, k=1)
-        assert sorted(k_shell_subgraph.nodes()) == [1, 3]
-        # k=2
-        k_shell_subgraph = nx.k_shell(self.H, k=0)
-        assert sorted(k_shell_subgraph.nodes()) == [0]
-
-    def test_k_shell_multigraph(self):
-        core_number = nx.core_number(self.H)
-        H = nx.MultiGraph(self.H)
-        with pytest.raises(nx.NetworkXNotImplemented):
-            nx.k_shell(H, k=0, core_number=core_number)
-
-    def test_k_corona(self):
-        # k=0
-        k_corona_subgraph = nx.k_corona(self.H, k=2)
-        assert sorted(k_corona_subgraph.nodes()) == [2, 4, 5, 6]
-        # k=1
-        k_corona_subgraph = nx.k_corona(self.H, k=1)
-        assert sorted(k_corona_subgraph.nodes()) == [1]
-        # k=2
-        k_corona_subgraph = nx.k_corona(self.H, k=0)
-        assert sorted(k_corona_subgraph.nodes()) == [0]
-
-    def test_k_corona_multigraph(self):
-        core_number = nx.core_number(self.H)
-        H = nx.MultiGraph(self.H)
-        with pytest.raises(nx.NetworkXNotImplemented):
-            nx.k_corona(H, k=0, core_number=core_number)
-
-    def test_k_truss(self):
-        # k=-1
-        k_truss_subgraph = nx.k_truss(self.G, -1)
-        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 21))
-        # k=0
-        k_truss_subgraph = nx.k_truss(self.G, 0)
-        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 21))
-        # k=1
-        k_truss_subgraph = nx.k_truss(self.G, 1)
-        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 21))
-        # k=2
-        k_truss_subgraph = nx.k_truss(self.G, 2)
-        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 21))
-        # k=3
-        k_truss_subgraph = nx.k_truss(self.G, 3)
-        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 13))
-
-        k_truss_subgraph = nx.k_truss(self.G, 4)
-        assert sorted(k_truss_subgraph.nodes()) == list(range(1, 9))
-
-        k_truss_subgraph = nx.k_truss(self.G, 5)
-        assert sorted(k_truss_subgraph.nodes()) == []
-
-    def test_k_truss_digraph(self):
-        G = nx.complete_graph(3)
-        G = nx.DiGraph(G)
-        G.add_edge(2, 1)
-        with pytest.raises(
-            nx.NetworkXNotImplemented, match="not implemented for directed type"
-        ):
-            nx.k_truss(G, k=1)
-
-    def test_k_truss_multigraph(self):
-        G = nx.complete_graph(3)
-        G = nx.MultiGraph(G)
-        G.add_edge(1, 2)
-        with pytest.raises(
-            nx.NetworkXNotImplemented, match="not implemented for multigraph type"
-        ):
-            nx.k_truss(G, k=1)
-
-    def test_k_truss_self_loop(self):
-        G = nx.cycle_graph(3)
-        G.add_edge(0, 0)
-        with pytest.raises(
-            nx.NetworkXNotImplemented, match="Input graph has self loops"
-        ):
-            nx.k_truss(G, k=1)
-
-    def test_onion_layers(self):
-        layers = nx.onion_layers(self.G)
-        nodes_by_layer = [
-            sorted(n for n in layers if layers[n] == val) for val in range(1, 7)
-        ]
-        assert nodes_equal(nodes_by_layer[0], [21])
-        assert nodes_equal(nodes_by_layer[1], [17, 18, 19, 20])
-        assert nodes_equal(nodes_by_layer[2], [10, 12, 13, 14, 15, 16])
-        assert nodes_equal(nodes_by_layer[3], [9, 11])
-        assert nodes_equal(nodes_by_layer[4], [1, 2, 4, 5, 6, 8])
-        assert nodes_equal(nodes_by_layer[5], [3, 7])
-
-    def test_onion_digraph(self):
-        G = nx.complete_graph(3)
-        G = nx.DiGraph(G)
-        G.add_edge(2, 1)
-        with pytest.raises(
-            nx.NetworkXNotImplemented, match="not implemented for directed type"
-        ):
-            nx.onion_layers(G)
-
-    def test_onion_multigraph(self):
-        G = nx.complete_graph(3)
-        G = nx.MultiGraph(G)
-        G.add_edge(1, 2)
-        with pytest.raises(
-            nx.NetworkXNotImplemented, match="not implemented for multigraph type"
-        ):
-            nx.onion_layers(G)
-
-    def test_onion_self_loop(self):
-        G = nx.cycle_graph(3)
-        G.add_edge(0, 0)
-        with pytest.raises(
-            nx.NetworkXNotImplemented, match="Input graph contains self loops"
-        ):
-            nx.onion_layers(G)

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

@@ -1,85 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-class TestMinEdgeCover:
-    """Tests for :func:`networkx.algorithms.min_edge_cover`"""
-
-    def test_empty_graph(self):
-        G = nx.Graph()
-        assert nx.min_edge_cover(G) == set()
-
-    def test_graph_with_loop(self):
-        G = nx.Graph()
-        G.add_edge(0, 0)
-        assert nx.min_edge_cover(G) == {(0, 0)}
-
-    def test_graph_with_isolated_v(self):
-        G = nx.Graph()
-        G.add_node(1)
-        with pytest.raises(
-            nx.NetworkXException,
-            match="Graph has a node with no edge incident on it, so no edge cover exists.",
-        ):
-            nx.min_edge_cover(G)
-
-    def test_graph_single_edge(self):
-        G = nx.Graph([(0, 1)])
-        assert nx.min_edge_cover(G) in ({(0, 1)}, {(1, 0)})
-
-    def test_graph_two_edge_path(self):
-        G = nx.path_graph(3)
-        min_cover = nx.min_edge_cover(G)
-        assert len(min_cover) == 2
-        for u, v in G.edges:
-            assert (u, v) in min_cover or (v, u) in min_cover
-
-    def test_bipartite_explicit(self):
-        G = nx.Graph()
-        G.add_nodes_from([1, 2, 3, 4], bipartite=0)
-        G.add_nodes_from(["a", "b", "c"], bipartite=1)
-        G.add_edges_from([(1, "a"), (1, "b"), (2, "b"), (2, "c"), (3, "c"), (4, "a")])
-        # Use bipartite method by prescribing the algorithm
-        min_cover = nx.min_edge_cover(
-            G, nx.algorithms.bipartite.matching.eppstein_matching
-        )
-        assert nx.is_edge_cover(G, min_cover)
-        assert len(min_cover) == 8
-        # Use the default method which is not specialized for bipartite
-        min_cover2 = nx.min_edge_cover(G)
-        assert nx.is_edge_cover(G, min_cover2)
-        assert len(min_cover2) == 4
-
-    def test_complete_graph_even(self):
-        G = nx.complete_graph(10)
-        min_cover = nx.min_edge_cover(G)
-        assert nx.is_edge_cover(G, min_cover)
-        assert len(min_cover) == 5
-
-    def test_complete_graph_odd(self):
-        G = nx.complete_graph(11)
-        min_cover = nx.min_edge_cover(G)
-        assert nx.is_edge_cover(G, min_cover)
-        assert len(min_cover) == 6
-
-
-class TestIsEdgeCover:
-    """Tests for :func:`networkx.algorithms.is_edge_cover`"""
-
-    def test_empty_graph(self):
-        G = nx.Graph()
-        assert nx.is_edge_cover(G, set())
-
-    def test_graph_with_loop(self):
-        G = nx.Graph()
-        G.add_edge(1, 1)
-        assert nx.is_edge_cover(G, {(1, 1)})
-
-    def test_graph_single_edge(self):
-        G = nx.Graph()
-        G.add_edge(0, 1)
-        assert nx.is_edge_cover(G, {(0, 0), (1, 1)})
-        assert nx.is_edge_cover(G, {(0, 1), (1, 0)})
-        assert nx.is_edge_cover(G, {(0, 1)})
-        assert not nx.is_edge_cover(G, {(0, 0)})

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

@@ -1,171 +0,0 @@
-"""Unit tests for the :mod:`networkx.algorithms.cuts` module."""
-
-import networkx as nx
-
-
-class TestCutSize:
-    """Unit tests for the :func:`~networkx.cut_size` function."""
-
-    def test_symmetric(self):
-        """Tests that the cut size is symmetric."""
-        G = nx.barbell_graph(3, 0)
-        S = {0, 1, 4}
-        T = {2, 3, 5}
-        assert nx.cut_size(G, S, T) == 4
-        assert nx.cut_size(G, T, S) == 4
-
-    def test_single_edge(self):
-        """Tests for a cut of a single edge."""
-        G = nx.barbell_graph(3, 0)
-        S = {0, 1, 2}
-        T = {3, 4, 5}
-        assert nx.cut_size(G, S, T) == 1
-        assert nx.cut_size(G, T, S) == 1
-
-    def test_directed(self):
-        """Tests that each directed edge is counted once in the cut."""
-        G = nx.barbell_graph(3, 0).to_directed()
-        S = {0, 1, 2}
-        T = {3, 4, 5}
-        assert nx.cut_size(G, S, T) == 2
-        assert nx.cut_size(G, T, S) == 2
-
-    def test_directed_symmetric(self):
-        """Tests that a cut in a directed graph is symmetric."""
-        G = nx.barbell_graph(3, 0).to_directed()
-        S = {0, 1, 4}
-        T = {2, 3, 5}
-        assert nx.cut_size(G, S, T) == 8
-        assert nx.cut_size(G, T, S) == 8
-
-    def test_multigraph(self):
-        """Tests that parallel edges are each counted for a cut."""
-        G = nx.MultiGraph(["ab", "ab"])
-        assert nx.cut_size(G, {"a"}, {"b"}) == 2
-
-
-class TestVolume:
-    """Unit tests for the :func:`~networkx.volume` function."""
-
-    def test_graph(self):
-        G = nx.cycle_graph(4)
-        assert nx.volume(G, {0, 1}) == 4
-
-    def test_digraph(self):
-        G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 0)])
-        assert nx.volume(G, {0, 1}) == 2
-
-    def test_multigraph(self):
-        edges = list(nx.cycle_graph(4).edges())
-        G = nx.MultiGraph(edges * 2)
-        assert nx.volume(G, {0, 1}) == 8
-
-    def test_multidigraph(self):
-        edges = [(0, 1), (1, 2), (2, 3), (3, 0)]
-        G = nx.MultiDiGraph(edges * 2)
-        assert nx.volume(G, {0, 1}) == 4
-
-    def test_barbell(self):
-        G = nx.barbell_graph(3, 0)
-        assert nx.volume(G, {0, 1, 2}) == 7
-        assert nx.volume(G, {3, 4, 5}) == 7
-
-
-class TestNormalizedCutSize:
-    """Unit tests for the :func:`~networkx.normalized_cut_size` function."""
-
-    def test_graph(self):
-        G = nx.path_graph(4)
-        S = {1, 2}
-        T = set(G) - S
-        size = nx.normalized_cut_size(G, S, T)
-        # The cut looks like this: o-{-o--o-}-o
-        expected = 2 * ((1 / 4) + (1 / 2))
-        assert expected == size
-        # Test with no input T
-        assert expected == nx.normalized_cut_size(G, S)
-
-    def test_directed(self):
-        G = nx.DiGraph([(0, 1), (1, 2), (2, 3)])
-        S = {1, 2}
-        T = set(G) - S
-        size = nx.normalized_cut_size(G, S, T)
-        # The cut looks like this: o-{->o-->o-}->o
-        expected = 2 * ((1 / 2) + (1 / 1))
-        assert expected == size
-        # Test with no input T
-        assert expected == nx.normalized_cut_size(G, S)
-
-
-class TestConductance:
-    """Unit tests for the :func:`~networkx.conductance` function."""
-
-    def test_graph(self):
-        G = nx.barbell_graph(5, 0)
-        # Consider the singleton sets containing the "bridge" nodes.
-        # There is only one cut edge, and each set has volume five.
-        S = {4}
-        T = {5}
-        conductance = nx.conductance(G, S, T)
-        expected = 1 / 5
-        assert expected == conductance
-        # Test with no input T
-        G2 = nx.barbell_graph(3, 0)
-        # There is only one cut edge, and each set has volume seven.
-        S2 = {0, 1, 2}
-        assert nx.conductance(G2, S2) == 1 / 7
-
-
-class TestEdgeExpansion:
-    """Unit tests for the :func:`~networkx.edge_expansion` function."""
-
-    def test_graph(self):
-        G = nx.barbell_graph(5, 0)
-        S = set(range(5))
-        T = set(G) - S
-        expansion = nx.edge_expansion(G, S, T)
-        expected = 1 / 5
-        assert expected == expansion
-        # Test with no input T
-        assert expected == nx.edge_expansion(G, S)
-
-
-class TestNodeExpansion:
-    """Unit tests for the :func:`~networkx.node_expansion` function."""
-
-    def test_graph(self):
-        G = nx.path_graph(8)
-        S = {3, 4, 5}
-        expansion = nx.node_expansion(G, S)
-        # The neighborhood of S has cardinality five, and S has
-        # cardinality three.
-        expected = 5 / 3
-        assert expected == expansion
-
-
-class TestBoundaryExpansion:
-    """Unit tests for the :func:`~networkx.boundary_expansion` function."""
-
-    def test_graph(self):
-        G = nx.complete_graph(10)
-        S = set(range(4))
-        expansion = nx.boundary_expansion(G, S)
-        # The node boundary of S has cardinality six, and S has
-        # cardinality three.
-        expected = 6 / 4
-        assert expected == expansion
-
-
-class TestMixingExpansion:
-    """Unit tests for the :func:`~networkx.mixing_expansion` function."""
-
-    def test_graph(self):
-        G = nx.barbell_graph(5, 0)
-        S = set(range(5))
-        T = set(G) - S
-        expansion = nx.mixing_expansion(G, S, T)
-        # There is one cut edge, and the total number of edges in the
-        # graph is twice the total number of edges in a clique of size
-        # five, plus one more for the bridge.
-        expected = 1 / (2 * (5 * 4 + 1))
-        assert expected == expansion