okstra 0.114.0 → 0.115.0

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

@@ -1,179 +0,0 @@
-"""Maximum weight clique test suite."""
-
-import pytest
-
-import networkx as nx
-
-
-class TestMaximumWeightClique:
-    def test_basic_cases(self):
-        def check_basic_case(graph_func, expected_weight, weight_accessor):
-            graph = graph_func()
-            clique, weight = nx.algorithms.max_weight_clique(graph, weight_accessor)
-            assert verify_clique(
-                graph, clique, weight, expected_weight, weight_accessor
-            )
-
-        for graph_func, (expected_weight, expected_size) in TEST_CASES.items():
-            check_basic_case(graph_func, expected_weight, "weight")
-            check_basic_case(graph_func, expected_size, None)
-
-    def test_key_error(self):
-        graph = two_node_graph()
-        with pytest.raises(KeyError):
-            nx.algorithms.max_weight_clique(graph, "nonexistent-key")
-
-    def test_error_on_non_integer_weight(self):
-        graph = two_node_graph()
-        graph.nodes[2]["weight"] = 1.5
-        with pytest.raises(ValueError):
-            nx.algorithms.max_weight_clique(graph)
-
-    def test_unaffected_by_self_loops(self):
-        graph = two_node_graph()
-        graph.add_edge(1, 1)
-        graph.add_edge(2, 2)
-        clique, weight = nx.algorithms.max_weight_clique(graph, "weight")
-        assert verify_clique(graph, clique, weight, 30, "weight")
-        graph = three_node_independent_set()
-        graph.add_edge(1, 1)
-        clique, weight = nx.algorithms.max_weight_clique(graph, "weight")
-        assert verify_clique(graph, clique, weight, 20, "weight")
-
-    def test_30_node_prob(self):
-        G = nx.Graph()
-        G.add_nodes_from(range(1, 31))
-        for i in range(1, 31):
-            G.nodes[i]["weight"] = i + 1
-        # fmt: off
-        G.add_edges_from(
-            [
-                (1, 12), (1, 13), (1, 15), (1, 16), (1, 18), (1, 19), (1, 20),
-                (1, 23), (1, 26), (1, 28), (1, 29), (1, 30), (2, 3), (2, 4),
-                (2, 5), (2, 8), (2, 9), (2, 10), (2, 14), (2, 17), (2, 18),
-                (2, 21), (2, 22), (2, 23), (2, 27), (3, 9), (3, 15), (3, 21),
-                (3, 22), (3, 23), (3, 24), (3, 27), (3, 28), (3, 29), (4, 5),
-                (4, 6), (4, 8), (4, 21), (4, 22), (4, 23), (4, 26), (4, 28),
-                (4, 30), (5, 6), (5, 8), (5, 9), (5, 13), (5, 14), (5, 15),
-                (5, 16), (5, 20), (5, 21), (5, 22), (5, 25), (5, 28), (5, 29),
-                (6, 7), (6, 8), (6, 13), (6, 17), (6, 18), (6, 19), (6, 24),
-                (6, 26), (6, 27), (6, 28), (6, 29), (7, 12), (7, 14), (7, 15),
-                (7, 16), (7, 17), (7, 20), (7, 25), (7, 27), (7, 29), (7, 30),
-                (8, 10), (8, 15), (8, 16), (8, 18), (8, 20), (8, 22), (8, 24),
-                (8, 26), (8, 27), (8, 28), (8, 30), (9, 11), (9, 12), (9, 13),
-                (9, 14), (9, 15), (9, 16), (9, 19), (9, 20), (9, 21), (9, 24),
-                (9, 30), (10, 12), (10, 15), (10, 18), (10, 19), (10, 20),
-                (10, 22), (10, 23), (10, 24), (10, 26), (10, 27), (10, 29),
-                (10, 30), (11, 13), (11, 15), (11, 16), (11, 17), (11, 18),
-                (11, 19), (11, 20), (11, 22), (11, 29), (11, 30), (12, 14),
-                (12, 17), (12, 18), (12, 19), (12, 20), (12, 21), (12, 23),
-                (12, 25), (12, 26), (12, 30), (13, 20), (13, 22), (13, 23),
-                (13, 24), (13, 30), (14, 16), (14, 20), (14, 21), (14, 22),
-                (14, 23), (14, 25), (14, 26), (14, 27), (14, 29), (14, 30),
-                (15, 17), (15, 18), (15, 20), (15, 21), (15, 26), (15, 27),
-                (15, 28), (16, 17), (16, 18), (16, 19), (16, 20), (16, 21),
-                (16, 29), (16, 30), (17, 18), (17, 21), (17, 22), (17, 25),
-                (17, 27), (17, 28), (17, 30), (18, 19), (18, 20), (18, 21),
-                (18, 22), (18, 23), (18, 24), (19, 20), (19, 22), (19, 23),
-                (19, 24), (19, 25), (19, 27), (19, 30), (20, 21), (20, 23),
-                (20, 24), (20, 26), (20, 28), (20, 29), (21, 23), (21, 26),
-                (21, 27), (21, 29), (22, 24), (22, 25), (22, 26), (22, 29),
-                (23, 25), (23, 30), (24, 25), (24, 26), (25, 27), (25, 29),
-                (26, 27), (26, 28), (26, 30), (28, 29), (29, 30),
-            ]
-        )
-        # fmt: on
-        clique, weight = nx.algorithms.max_weight_clique(G)
-        assert verify_clique(G, clique, weight, 111, "weight")
-
-
-#  ############################  Utility functions ############################
-def verify_clique(
-    graph, clique, reported_clique_weight, expected_clique_weight, weight_accessor
-):
-    for node1 in clique:
-        for node2 in clique:
-            if node1 == node2:
-                continue
-            if not graph.has_edge(node1, node2):
-                return False
-
-    if weight_accessor is None:
-        clique_weight = len(clique)
-    else:
-        clique_weight = sum(graph.nodes[v]["weight"] for v in clique)
-
-    if clique_weight != expected_clique_weight:
-        return False
-    if clique_weight != reported_clique_weight:
-        return False
-
-    return True
-
-
-#  ############################  Graph Generation ############################
-
-
-def empty_graph():
-    return nx.Graph()
-
-
-def one_node_graph():
-    graph = nx.Graph()
-    graph.add_nodes_from([1])
-    graph.nodes[1]["weight"] = 10
-    return graph
-
-
-def two_node_graph():
-    graph = nx.Graph()
-    graph.add_nodes_from([1, 2])
-    graph.add_edges_from([(1, 2)])
-    graph.nodes[1]["weight"] = 10
-    graph.nodes[2]["weight"] = 20
-    return graph
-
-
-def three_node_clique():
-    graph = nx.Graph()
-    graph.add_nodes_from([1, 2, 3])
-    graph.add_edges_from([(1, 2), (1, 3), (2, 3)])
-    graph.nodes[1]["weight"] = 10
-    graph.nodes[2]["weight"] = 20
-    graph.nodes[3]["weight"] = 5
-    return graph
-
-
-def three_node_independent_set():
-    graph = nx.Graph()
-    graph.add_nodes_from([1, 2, 3])
-    graph.nodes[1]["weight"] = 10
-    graph.nodes[2]["weight"] = 20
-    graph.nodes[3]["weight"] = 5
-    return graph
-
-
-def disconnected():
-    graph = nx.Graph()
-    graph.add_edges_from([(1, 2), (2, 3), (4, 5), (5, 6)])
-    graph.nodes[1]["weight"] = 10
-    graph.nodes[2]["weight"] = 20
-    graph.nodes[3]["weight"] = 5
-    graph.nodes[4]["weight"] = 100
-    graph.nodes[5]["weight"] = 200
-    graph.nodes[6]["weight"] = 50
-    return graph
-
-
-# --------------------------------------------------------------------------
-# Basic tests for all strategies
-# For each basic graph function, specify expected weight of max weight clique
-# and expected size of maximum clique
-TEST_CASES = {
-    empty_graph: (0, 0),
-    one_node_graph: (10, 1),
-    two_node_graph: (30, 2),
-    three_node_clique: (35, 3),
-    three_node_independent_set: (20, 1),
-    disconnected: (300, 2),
-}

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

@@ -1,62 +0,0 @@
-"""
-Tests for maximal (not maximum) independent sets.
-
-"""
-
-import random
-
-import pytest
-
-import networkx as nx
-
-
-def test_random_seed():
-    G = nx.empty_graph(5)
-    assert nx.maximal_independent_set(G, seed=1) == [1, 0, 3, 2, 4]
-
-
-@pytest.mark.parametrize("graph", [nx.complete_graph(5), nx.complete_graph(55)])
-def test_K5(graph):
-    """Maximal independent set for complete graphs"""
-    assert all(nx.maximal_independent_set(graph, [n]) == [n] for n in graph)
-
-
-def test_exceptions():
-    """Bad input should raise exception."""
-    G = nx.florentine_families_graph()
-    pytest.raises(nx.NetworkXUnfeasible, nx.maximal_independent_set, G, ["Smith"])
-    pytest.raises(
-        nx.NetworkXUnfeasible, nx.maximal_independent_set, G, ["Salviati", "Pazzi"]
-    )
-    # MaximalIndependentSet is not implemented for directed graphs
-    pytest.raises(nx.NetworkXNotImplemented, nx.maximal_independent_set, nx.DiGraph(G))
-
-
-def test_florentine_family():
-    G = nx.florentine_families_graph()
-    indep = nx.maximal_independent_set(G, ["Medici", "Bischeri"])
-    assert set(indep) == {
-        "Medici",
-        "Bischeri",
-        "Castellani",
-        "Pazzi",
-        "Ginori",
-        "Lamberteschi",
-    }
-
-
-def test_bipartite():
-    G = nx.complete_bipartite_graph(12, 34)
-    indep = nx.maximal_independent_set(G, [4, 5, 9, 10])
-    assert sorted(indep) == list(range(12))
-
-
-def test_random_graphs():
-    """Generate 5 random graphs of different types and sizes and
-    make sure that all sets are independent and maximal."""
-    for i in range(0, 50, 10):
-        G = nx.erdos_renyi_graph(i * 10 + 1, random.random())
-        IS = nx.maximal_independent_set(G)
-        assert G.subgraph(IS).number_of_edges() == 0
-        nbrs_of_MIS = set.union(*(set(G.neighbors(v)) for v in IS))
-        assert all(v in nbrs_of_MIS for v in set(G.nodes()).difference(IS))

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

@@ -1,15 +0,0 @@
-import networkx as nx
-from networkx.algorithms.moral import moral_graph
-
-
-def test_get_moral_graph():
-    graph = nx.DiGraph()
-    graph.add_nodes_from([1, 2, 3, 4, 5, 6, 7])
-    graph.add_edges_from([(1, 2), (3, 2), (4, 1), (4, 5), (6, 5), (7, 5)])
-    H = moral_graph(graph)
-    assert not H.is_directed()
-    assert H.has_edge(1, 3)
-    assert H.has_edge(4, 6)
-    assert H.has_edge(6, 7)
-    assert H.has_edge(4, 7)
-    assert not H.has_edge(1, 5)

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

@@ -1,140 +0,0 @@
-import pytest
-
-pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-import networkx as nx
-from networkx.algorithms import node_classification
-
-
-class TestHarmonicFunction:
-    def test_path_graph(self):
-        G = nx.path_graph(4)
-        label_name = "label"
-        G.nodes[0][label_name] = "A"
-        G.nodes[3][label_name] = "B"
-        predicted = node_classification.harmonic_function(G, label_name=label_name)
-        assert predicted[0] == "A"
-        assert predicted[1] == "A"
-        assert predicted[2] == "B"
-        assert predicted[3] == "B"
-
-    def test_no_labels(self):
-        with pytest.raises(nx.NetworkXError):
-            G = nx.path_graph(4)
-            node_classification.harmonic_function(G)
-
-    def test_no_nodes(self):
-        with pytest.raises(nx.NetworkXError):
-            G = nx.Graph()
-            node_classification.harmonic_function(G)
-
-    def test_no_edges(self):
-        with pytest.raises(nx.NetworkXError):
-            G = nx.Graph()
-            G.add_node(1)
-            G.add_node(2)
-            node_classification.harmonic_function(G)
-
-    def test_digraph(self):
-        with pytest.raises(nx.NetworkXNotImplemented):
-            G = nx.DiGraph()
-            G.add_edge(0, 1)
-            G.add_edge(1, 2)
-            G.add_edge(2, 3)
-            label_name = "label"
-            G.nodes[0][label_name] = "A"
-            G.nodes[3][label_name] = "B"
-            node_classification.harmonic_function(G)
-
-    def test_one_labeled_node(self):
-        G = nx.path_graph(4)
-        label_name = "label"
-        G.nodes[0][label_name] = "A"
-        predicted = node_classification.harmonic_function(G, label_name=label_name)
-        assert predicted[0] == "A"
-        assert predicted[1] == "A"
-        assert predicted[2] == "A"
-        assert predicted[3] == "A"
-
-    def test_nodes_all_labeled(self):
-        G = nx.karate_club_graph()
-        label_name = "club"
-        predicted = node_classification.harmonic_function(G, label_name=label_name)
-        for i in range(len(G)):
-            assert predicted[i] == G.nodes[i][label_name]
-
-    def test_labeled_nodes_are_not_changed(self):
-        G = nx.karate_club_graph()
-        label_name = "club"
-        label_removed = {0, 1, 2, 3, 4, 5, 6, 7}
-        for i in label_removed:
-            del G.nodes[i][label_name]
-        predicted = node_classification.harmonic_function(G, label_name=label_name)
-        label_not_removed = set(range(len(G))) - label_removed
-        for i in label_not_removed:
-            assert predicted[i] == G.nodes[i][label_name]
-
-
-class TestLocalAndGlobalConsistency:
-    def test_path_graph(self):
-        G = nx.path_graph(4)
-        label_name = "label"
-        G.nodes[0][label_name] = "A"
-        G.nodes[3][label_name] = "B"
-        predicted = node_classification.local_and_global_consistency(
-            G, label_name=label_name
-        )
-        assert predicted[0] == "A"
-        assert predicted[1] == "A"
-        assert predicted[2] == "B"
-        assert predicted[3] == "B"
-
-    def test_no_labels(self):
-        with pytest.raises(nx.NetworkXError):
-            G = nx.path_graph(4)
-            node_classification.local_and_global_consistency(G)
-
-    def test_no_nodes(self):
-        with pytest.raises(nx.NetworkXError):
-            G = nx.Graph()
-            node_classification.local_and_global_consistency(G)
-
-    def test_no_edges(self):
-        with pytest.raises(nx.NetworkXError):
-            G = nx.Graph()
-            G.add_node(1)
-            G.add_node(2)
-            node_classification.local_and_global_consistency(G)
-
-    def test_digraph(self):
-        with pytest.raises(nx.NetworkXNotImplemented):
-            G = nx.DiGraph()
-            G.add_edge(0, 1)
-            G.add_edge(1, 2)
-            G.add_edge(2, 3)
-            label_name = "label"
-            G.nodes[0][label_name] = "A"
-            G.nodes[3][label_name] = "B"
-            node_classification.harmonic_function(G)
-
-    def test_one_labeled_node(self):
-        G = nx.path_graph(4)
-        label_name = "label"
-        G.nodes[0][label_name] = "A"
-        predicted = node_classification.local_and_global_consistency(
-            G, label_name=label_name
-        )
-        assert predicted[0] == "A"
-        assert predicted[1] == "A"
-        assert predicted[2] == "A"
-        assert predicted[3] == "A"
-
-    def test_nodes_all_labeled(self):
-        G = nx.karate_club_graph()
-        label_name = "club"
-        predicted = node_classification.local_and_global_consistency(
-            G, alpha=0, label_name=label_name
-        )
-        for i in range(len(G)):
-            assert predicted[i] == G.nodes[i][label_name]

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

@@ -1,60 +0,0 @@
-import pytest
-
-import networkx as nx
-
-np = pytest.importorskip("numpy")
-
-
-@pytest.mark.parametrize(
-    "k, weight, expected",
-    [
-        (None, None, 7.21),  # infers 3 communities
-        (2, None, 11.7),
-        (None, "weight", 25.45),
-        (2, "weight", 38.8),
-    ],
-)
-def test_non_randomness(k, weight, expected):
-    G = nx.karate_club_graph()
-    np.testing.assert_almost_equal(
-        nx.non_randomness(G, k, weight)[0], expected, decimal=2
-    )
-
-
-def test_non_connected():
-    G = nx.Graph([(1, 2)])
-    G.add_node(3)
-    with pytest.raises(nx.NetworkXException, match="Non connected"):
-        nx.non_randomness(G)
-
-
-def test_self_loops():
-    G = nx.Graph()
-    G.add_edge(1, 2)
-    G.add_edge(1, 1)
-    with pytest.raises(nx.NetworkXError, match="Graph must not contain self-loops"):
-        nx.non_randomness(G)
-
-
-def test_empty_graph():
-    G = nx.empty_graph(1)
-    with pytest.raises(nx.NetworkXError, match=".*not applicable to empty graphs"):
-        nx.non_randomness(G)
-
-
-@pytest.mark.parametrize("k", [-1, 0, 2, 5])
-def test_value_error(k):
-    """
-    Check that invalid values of k raise (must be between 1 and n - 1, inclusive,
-    and such that the probability is between 0 and 1, exclusive).
-    """
-    G = nx.path_graph(5)
-    with pytest.raises(ValueError, match=r"invalid number of communities"):
-        nx.non_randomness(G, k=k)
-
-
-@pytest.mark.parametrize("G", [nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()])
-def test_not_implemented(G):
-    """Check that non-randomness is not implemented for directed or multigraphs."""
-    with pytest.raises(nx.NetworkXNotImplemented, match=r"not implemented for"):
-        nx.non_randomness(G)

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

@@ -1,27 +0,0 @@
-import networkx as nx
-
-
-def test_chordal_graph():
-    G = nx.complete_graph(5)
-    assert nx.is_perfect_graph(G)
-
-
-def test_odd_cycle():
-    G = nx.cycle_graph(5)  # Induced odd cycle
-    assert not nx.is_perfect_graph(G)
-
-
-def test_even_cycle():
-    G = nx.cycle_graph(6)  # Even cycle is perfect
-    assert nx.is_perfect_graph(G)
-
-
-def test_complement_of_odd_cycle():
-    G = nx.cycle_graph(7)
-    GC = nx.complement(G)
-    assert not nx.is_perfect_graph(GC)
-
-
-def test_disconnected_union_of_cliques():
-    G = nx.disjoint_union(nx.complete_graph(3), nx.complete_graph(4))
-    assert nx.is_perfect_graph(G)