okstra 0.114.0 → 0.115.0

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

@@ -1,248 +0,0 @@
-"""Tests for the :mod:`networkx.algorithms.triads` module."""
-
-import itertools
-from collections import defaultdict
-from random import sample
-
-import pytest
-
-import networkx as nx
-
-
-def test_triadic_census():
-    """Tests the triadic_census function."""
-    G = nx.DiGraph()
-    G.add_edges_from(["01", "02", "03", "04", "05", "12", "16", "51", "56", "65"])
-    expected = {
-        "030T": 2,
-        "120C": 1,
-        "210": 0,
-        "120U": 0,
-        "012": 9,
-        "102": 3,
-        "021U": 0,
-        "111U": 0,
-        "003": 8,
-        "030C": 0,
-        "021D": 9,
-        "201": 0,
-        "111D": 1,
-        "300": 0,
-        "120D": 0,
-        "021C": 2,
-    }
-    actual = nx.triadic_census(G)
-    assert expected == actual
-
-
-def test_is_triad():
-    """Tests the is_triad function"""
-    G = nx.karate_club_graph()
-    G = G.to_directed()
-    for i in range(100):
-        nodes = sample(sorted(G.nodes()), 3)
-        G2 = G.subgraph(nodes)
-        assert nx.is_triad(G2)
-
-
-def test_all_triads():
-    """Tests the all_triads function."""
-    G = nx.DiGraph()
-    G.add_edges_from(["01", "02", "03", "04", "05", "12", "16", "51", "56", "65"])
-    expected = [
-        f"{i},{j},{k}"
-        for i in range(7)
-        for j in range(i + 1, 7)
-        for k in range(j + 1, 7)
-    ]
-    expected = [G.subgraph(x.split(",")) for x in expected]
-    actual = list(nx.all_triads(G))
-    assert all(any(nx.is_isomorphic(G1, G2) for G1 in expected) for G2 in actual)
-
-
-def test_triad_type():
-    """Tests the triad_type function."""
-    # 0 edges (1 type)
-    G = nx.DiGraph({0: [], 1: [], 2: []})
-    assert nx.triad_type(G) == "003"
-    # 1 edge (1 type)
-    G = nx.DiGraph({0: [1], 1: [], 2: []})
-    assert nx.triad_type(G) == "012"
-    # 2 edges (4 types)
-    G = nx.DiGraph([(0, 1), (0, 2)])
-    assert nx.triad_type(G) == "021D"
-    G = nx.DiGraph({0: [1], 1: [0], 2: []})
-    assert nx.triad_type(G) == "102"
-    G = nx.DiGraph([(0, 1), (2, 1)])
-    assert nx.triad_type(G) == "021U"
-    G = nx.DiGraph([(0, 1), (1, 2)])
-    assert nx.triad_type(G) == "021C"
-    # 3 edges (4 types)
-    G = nx.DiGraph([(0, 1), (1, 0), (2, 1)])
-    assert nx.triad_type(G) == "111D"
-    G = nx.DiGraph([(0, 1), (1, 0), (1, 2)])
-    assert nx.triad_type(G) == "111U"
-    G = nx.DiGraph([(0, 1), (1, 2), (0, 2)])
-    assert nx.triad_type(G) == "030T"
-    G = nx.DiGraph([(0, 1), (1, 2), (2, 0)])
-    assert nx.triad_type(G) == "030C"
-    # 4 edges (4 types)
-    G = nx.DiGraph([(0, 1), (1, 0), (2, 0), (0, 2)])
-    assert nx.triad_type(G) == "201"
-    G = nx.DiGraph([(0, 1), (1, 0), (2, 0), (2, 1)])
-    assert nx.triad_type(G) == "120D"
-    G = nx.DiGraph([(0, 1), (1, 0), (0, 2), (1, 2)])
-    assert nx.triad_type(G) == "120U"
-    G = nx.DiGraph([(0, 1), (1, 0), (0, 2), (2, 1)])
-    assert nx.triad_type(G) == "120C"
-    # 5 edges (1 type)
-    G = nx.DiGraph([(0, 1), (1, 0), (2, 1), (1, 2), (0, 2)])
-    assert nx.triad_type(G) == "210"
-    # 6 edges (1 type)
-    G = nx.DiGraph([(0, 1), (1, 0), (1, 2), (2, 1), (0, 2), (2, 0)])
-    assert nx.triad_type(G) == "300"
-
-
-def test_triads_by_type():
-    G = nx.DiGraph()
-    G.add_edges_from(["01", "02", "03", "04", "05", "12", "16", "51", "56", "65"])
-    all_triads = nx.all_triads(G)
-    expected = defaultdict(list)
-    for triad in all_triads:
-        name = nx.triad_type(triad)
-        expected[name].append(triad)
-    actual = nx.triads_by_type(G)
-    assert set(actual.keys()) == set(expected.keys())
-    for tri_type, actual_Gs in actual.items():
-        expected_Gs = expected[tri_type]
-        for a in actual_Gs:
-            assert any(nx.is_isomorphic(a, e) for e in expected_Gs)
-
-
-def test_triadic_census_short_path_nodelist():
-    G = nx.path_graph("abc", create_using=nx.DiGraph)
-    expected = {"021C": 1}
-    for nl in ["a", "b", "c", "ab", "ac", "bc", "abc"]:
-        triad_census = nx.triadic_census(G, nodelist=nl)
-        assert expected == {typ: cnt for typ, cnt in triad_census.items() if cnt > 0}
-
-
-def test_triadic_census_correct_nodelist_values():
-    G = nx.path_graph(5, create_using=nx.DiGraph)
-    msg = r"nodelist includes duplicate nodes or nodes not in G"
-    with pytest.raises(ValueError, match=msg):
-        nx.triadic_census(G, [1, 2, 2, 3])
-    with pytest.raises(ValueError, match=msg):
-        nx.triadic_census(G, [1, 2, "a", 3])
-
-
-def test_triadic_census_tiny_graphs():
-    tc = nx.triadic_census(nx.empty_graph(0, create_using=nx.DiGraph))
-    assert {} == {typ: cnt for typ, cnt in tc.items() if cnt > 0}
-    tc = nx.triadic_census(nx.empty_graph(1, create_using=nx.DiGraph))
-    assert {} == {typ: cnt for typ, cnt in tc.items() if cnt > 0}
-    tc = nx.triadic_census(nx.empty_graph(2, create_using=nx.DiGraph))
-    assert {} == {typ: cnt for typ, cnt in tc.items() if cnt > 0}
-    tc = nx.triadic_census(nx.DiGraph([(1, 2)]))
-    assert {} == {typ: cnt for typ, cnt in tc.items() if cnt > 0}
-
-
-def test_triadic_census_selfloops():
-    GG = nx.path_graph("abc", create_using=nx.DiGraph)
-    expected = {"021C": 1}
-    for n in GG:
-        G = GG.copy()
-        G.add_edge(n, n)
-        tc = nx.triadic_census(G)
-        assert expected == {typ: cnt for typ, cnt in tc.items() if cnt > 0}
-
-    GG = nx.path_graph("abcde", create_using=nx.DiGraph)
-    tbt = nx.triads_by_type(GG)
-    for n in GG:
-        GG.add_edge(n, n)
-    tc = nx.triadic_census(GG)
-    assert tc == {tt: len(tbt[tt]) for tt in tc}
-
-
-def test_triadic_census_four_path():
-    G = nx.path_graph("abcd", create_using=nx.DiGraph)
-    expected = {"012": 2, "021C": 2}
-    triad_census = nx.triadic_census(G)
-    assert expected == {typ: cnt for typ, cnt in triad_census.items() if cnt > 0}
-
-
-def test_triadic_census_four_path_nodelist():
-    G = nx.path_graph("abcd", create_using=nx.DiGraph)
-    expected_end = {"012": 2, "021C": 1}
-    expected_mid = {"012": 1, "021C": 2}
-    a_triad_census = nx.triadic_census(G, nodelist=["a"])
-    assert expected_end == {typ: cnt for typ, cnt in a_triad_census.items() if cnt > 0}
-    b_triad_census = nx.triadic_census(G, nodelist=["b"])
-    assert expected_mid == {typ: cnt for typ, cnt in b_triad_census.items() if cnt > 0}
-    c_triad_census = nx.triadic_census(G, nodelist=["c"])
-    assert expected_mid == {typ: cnt for typ, cnt in c_triad_census.items() if cnt > 0}
-    d_triad_census = nx.triadic_census(G, nodelist=["d"])
-    assert expected_end == {typ: cnt for typ, cnt in d_triad_census.items() if cnt > 0}
-
-
-def test_triadic_census_nodelist():
-    """Tests the triadic_census function."""
-    G = nx.DiGraph()
-    G.add_edges_from(["01", "02", "03", "04", "05", "12", "16", "51", "56", "65"])
-    expected = {
-        "030T": 2,
-        "120C": 1,
-        "210": 0,
-        "120U": 0,
-        "012": 9,
-        "102": 3,
-        "021U": 0,
-        "111U": 0,
-        "003": 8,
-        "030C": 0,
-        "021D": 9,
-        "201": 0,
-        "111D": 1,
-        "300": 0,
-        "120D": 0,
-        "021C": 2,
-    }
-    actual = {k: 0 for k in expected}
-    for node in G.nodes():
-        node_triad_census = nx.triadic_census(G, nodelist=[node])
-        for triad_key in expected:
-            actual[triad_key] += node_triad_census[triad_key]
-    # Divide all counts by 3
-    for k, v in actual.items():
-        actual[k] //= 3
-    assert expected == actual
-
-
-@pytest.mark.parametrize("N", [5, 10])
-def test_triadic_census_on_random_graph(N):
-    G = nx.binomial_graph(N, 0.3, directed=True, seed=42)
-    tc1 = nx.triadic_census(G)
-    tbt = nx.triads_by_type(G)
-    tc2 = {tt: len(tbt[tt]) for tt in tc1}
-    assert tc1 == tc2
-
-    for n in G:
-        tc1 = nx.triadic_census(G, nodelist={n})
-        tc2 = {tt: sum(1 for t in tbt.get(tt, []) if n in t) for tt in tc1}
-        assert tc1 == tc2
-
-    for ns in itertools.combinations(G, 2):
-        ns = set(ns)
-        tc1 = nx.triadic_census(G, nodelist=ns)
-        tc2 = {
-            tt: sum(1 for t in tbt.get(tt, []) if any(n in ns for n in t)) for tt in tc1
-        }
-        assert tc1 == tc2
-
-    for ns in itertools.combinations(G, 3):
-        ns = set(ns)
-        tc1 = nx.triadic_census(G, nodelist=ns)
-        tc2 = {
-            tt: sum(1 for t in tbt.get(tt, []) if any(n in ns for n in t)) for tt in tc1
-        }
-        assert tc1 == tc2

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

@@ -1,41 +0,0 @@
-import networkx as nx
-
-
-class TestClosenessVitality:
-    def test_unweighted(self):
-        G = nx.cycle_graph(3)
-        vitality = nx.closeness_vitality(G)
-        assert vitality == {0: 2, 1: 2, 2: 2}
-
-    def test_weighted(self):
-        G = nx.Graph()
-        nx.add_cycle(G, [0, 1, 2], weight=2)
-        vitality = nx.closeness_vitality(G, weight="weight")
-        assert vitality == {0: 4, 1: 4, 2: 4}
-
-    def test_unweighted_digraph(self):
-        G = nx.DiGraph(nx.cycle_graph(3))
-        vitality = nx.closeness_vitality(G)
-        assert vitality == {0: 4, 1: 4, 2: 4}
-
-    def test_weighted_digraph(self):
-        G = nx.DiGraph()
-        nx.add_cycle(G, [0, 1, 2], weight=2)
-        nx.add_cycle(G, [2, 1, 0], weight=2)
-        vitality = nx.closeness_vitality(G, weight="weight")
-        assert vitality == {0: 8, 1: 8, 2: 8}
-
-    def test_weighted_multidigraph(self):
-        G = nx.MultiDiGraph()
-        nx.add_cycle(G, [0, 1, 2], weight=2)
-        nx.add_cycle(G, [2, 1, 0], weight=2)
-        vitality = nx.closeness_vitality(G, weight="weight")
-        assert vitality == {0: 8, 1: 8, 2: 8}
-
-    def test_disconnecting_graph(self):
-        """Tests that the closeness vitality of a node whose removal
-        disconnects the graph is negative infinity.
-
-        """
-        G = nx.path_graph(3)
-        assert nx.closeness_vitality(G, node=1) == -float("inf")

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

@@ -1,103 +0,0 @@
-import networkx as nx
-from networkx.utils import pairwise
-
-
-class TestVoronoiCells:
-    """Unit tests for the Voronoi cells function."""
-
-    def test_isolates(self):
-        """Tests that a graph with isolated nodes has all isolates in
-        one block of the partition.
-
-        """
-        G = nx.empty_graph(5)
-        cells = nx.voronoi_cells(G, {0, 2, 4})
-        expected = {0: {0}, 2: {2}, 4: {4}, "unreachable": {1, 3}}
-        assert expected == cells
-
-    def test_undirected_unweighted(self):
-        G = nx.cycle_graph(6)
-        cells = nx.voronoi_cells(G, {0, 3})
-        expected = {0: {0, 1, 5}, 3: {2, 3, 4}}
-        assert expected == cells
-
-    def test_directed_unweighted(self):
-        # This is the singly-linked directed cycle graph on six nodes.
-        G = nx.DiGraph(pairwise(range(6), cyclic=True))
-        cells = nx.voronoi_cells(G, {0, 3})
-        expected = {0: {0, 1, 2}, 3: {3, 4, 5}}
-        assert expected == cells
-
-    def test_directed_inward(self):
-        """Tests that reversing the graph gives the "inward" Voronoi
-        partition.
-
-        """
-        # This is the singly-linked reverse directed cycle graph on six nodes.
-        G = nx.DiGraph(pairwise(range(6), cyclic=True))
-        G = G.reverse(copy=False)
-        cells = nx.voronoi_cells(G, {0, 3})
-        expected = {0: {0, 4, 5}, 3: {1, 2, 3}}
-        assert expected == cells
-
-    def test_undirected_weighted(self):
-        edges = [(0, 1, 10), (1, 2, 1), (2, 3, 1)]
-        G = nx.Graph()
-        G.add_weighted_edges_from(edges)
-        cells = nx.voronoi_cells(G, {0, 3})
-        expected = {0: {0}, 3: {1, 2, 3}}
-        assert expected == cells
-
-    def test_directed_weighted(self):
-        edges = [(0, 1, 10), (1, 2, 1), (2, 3, 1), (3, 2, 1), (2, 1, 1)]
-        G = nx.DiGraph()
-        G.add_weighted_edges_from(edges)
-        cells = nx.voronoi_cells(G, {0, 3})
-        expected = {0: {0}, 3: {1, 2, 3}}
-        assert expected == cells
-
-    def test_multigraph_unweighted(self):
-        """Tests that the Voronoi cells for a multigraph are the same as
-        for a simple graph.
-
-        """
-        edges = [(0, 1), (1, 2), (2, 3)]
-        G = nx.MultiGraph(2 * edges)
-        H = nx.Graph(G)
-        G_cells = nx.voronoi_cells(G, {0, 3})
-        H_cells = nx.voronoi_cells(H, {0, 3})
-        assert G_cells == H_cells
-
-    def test_multidigraph_unweighted(self):
-        # This is the twice-singly-linked directed cycle graph on six nodes.
-        edges = list(pairwise(range(6), cyclic=True))
-        G = nx.MultiDiGraph(2 * edges)
-        H = nx.DiGraph(G)
-        G_cells = nx.voronoi_cells(G, {0, 3})
-        H_cells = nx.voronoi_cells(H, {0, 3})
-        assert G_cells == H_cells
-
-    def test_multigraph_weighted(self):
-        edges = [(0, 1, 10), (0, 1, 10), (1, 2, 1), (1, 2, 100), (2, 3, 1), (2, 3, 100)]
-        G = nx.MultiGraph()
-        G.add_weighted_edges_from(edges)
-        cells = nx.voronoi_cells(G, {0, 3})
-        expected = {0: {0}, 3: {1, 2, 3}}
-        assert expected == cells
-
-    def test_multidigraph_weighted(self):
-        edges = [
-            (0, 1, 10),
-            (0, 1, 10),
-            (1, 2, 1),
-            (2, 3, 1),
-            (3, 2, 10),
-            (3, 2, 1),
-            (2, 1, 10),
-            (2, 1, 1),
-        ]
-        G = nx.MultiDiGraph()
-        G.add_weighted_edges_from(edges)
-        cells = nx.voronoi_cells(G, {0, 3})
-        expected = {0: {0}, 3: {1, 2, 3}}
-        assert expected == cells

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

@@ -1,54 +0,0 @@
-"""Unit tests for the :mod:`networkx.algorithms.walks` module."""
-
-import pytest
-
-import networkx as nx
-
-pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-
-def test_directed():
-    G = nx.DiGraph([(0, 1), (1, 2), (2, 0)])
-    num_walks = nx.number_of_walks(G, 3)
-    expected = {0: {0: 1, 1: 0, 2: 0}, 1: {0: 0, 1: 1, 2: 0}, 2: {0: 0, 1: 0, 2: 1}}
-    assert num_walks == expected
-
-
-def test_undirected():
-    G = nx.cycle_graph(3)
-    num_walks = nx.number_of_walks(G, 3)
-    expected = {0: {0: 2, 1: 3, 2: 3}, 1: {0: 3, 1: 2, 2: 3}, 2: {0: 3, 1: 3, 2: 2}}
-    assert num_walks == expected
-
-
-def test_non_integer_nodes():
-    G = nx.DiGraph([("A", "B"), ("B", "C"), ("C", "A")])
-    num_walks = nx.number_of_walks(G, 2)
-    expected = {
-        "A": {"A": 0, "B": 0, "C": 1},
-        "B": {"A": 1, "B": 0, "C": 0},
-        "C": {"A": 0, "B": 1, "C": 0},
-    }
-    assert num_walks == expected
-
-
-def test_zero_length():
-    G = nx.cycle_graph(3)
-    num_walks = nx.number_of_walks(G, 0)
-    expected = {0: {0: 1, 1: 0, 2: 0}, 1: {0: 0, 1: 1, 2: 0}, 2: {0: 0, 1: 0, 2: 1}}
-    assert num_walks == expected
-
-
-def test_negative_length_exception():
-    G = nx.cycle_graph(3)
-    with pytest.raises(ValueError):
-        nx.number_of_walks(G, -1)
-
-
-def test_hidden_weight_attr():
-    G = nx.cycle_graph(3)
-    G.add_edge(1, 2, weight=5)
-    num_walks = nx.number_of_walks(G, 3)
-    expected = {0: {0: 2, 1: 3, 2: 3}, 1: {0: 3, 1: 2, 2: 3}, 2: {0: 3, 1: 3, 2: 2}}
-    assert num_walks == expected

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

@@ -1,157 +0,0 @@
-import networkx as nx
-
-
-def test_wiener_index_of_disconnected_graph():
-    assert nx.wiener_index(nx.empty_graph(2)) == float("inf")
-
-
-def test_wiener_index_of_directed_graph():
-    G = nx.complete_graph(3)
-    H = nx.DiGraph(G)
-    assert (2 * nx.wiener_index(G)) == nx.wiener_index(H)
-
-
-def test_wiener_index_of_complete_graph():
-    n = 10
-    G = nx.complete_graph(n)
-    assert nx.wiener_index(G) == (n * (n - 1) / 2)
-
-
-def test_wiener_index_of_path_graph():
-    # In P_n, there are n - 1 pairs of vertices at distance one, n -
-    # 2 pairs at distance two, n - 3 at distance three, ..., 1 at
-    # distance n - 1, so the Wiener index should be
-    #
-    #     1 * (n - 1) + 2 * (n - 2) + ... + (n - 2) * 2 + (n - 1) * 1
-    #
-    # For example, in P_5,
-    #
-    #     1 * 4 + 2 * 3 + 3 * 2 + 4 * 1 = 2 (1 * 4 + 2 * 3)
-    #
-    # and in P_6,
-    #
-    #     1 * 5 + 2 * 4 + 3 * 3 + 4 * 2 + 5 * 1 = 2 (1 * 5 + 2 * 4) + 3 * 3
-    #
-    # assuming n is *odd*, this gives the formula
-    #
-    #     2 \sum_{i = 1}^{(n - 1) / 2} [i * (n - i)]
-    #
-    # assuming n is *even*, this gives the formula
-    #
-    #     2 \sum_{i = 1}^{n / 2} [i * (n - i)] - (n / 2) ** 2
-    #
-    n = 9
-    G = nx.path_graph(n)
-    expected = 2 * sum(i * (n - i) for i in range(1, (n // 2) + 1))
-    actual = nx.wiener_index(G)
-    assert expected == actual
-
-
-def test_schultz_and_gutman_index_of_disconnected_graph():
-    n = 4
-    G = nx.Graph()
-    G.add_nodes_from(list(range(1, n + 1)))
-    expected = float("inf")
-
-    G.add_edge(1, 2)
-    G.add_edge(3, 4)
-
-    actual_1 = nx.schultz_index(G)
-    actual_2 = nx.gutman_index(G)
-
-    assert expected == actual_1
-    assert expected == actual_2
-
-
-def test_schultz_and_gutman_index_of_complete_bipartite_graph_1():
-    n = 3
-    m = 3
-    cbg = nx.complete_bipartite_graph(n, m)
-
-    expected_1 = n * m * (n + m) + 2 * n * (n - 1) * m + 2 * m * (m - 1) * n
-    actual_1 = nx.schultz_index(cbg)
-
-    expected_2 = n * m * (n * m) + n * (n - 1) * m * m + m * (m - 1) * n * n
-    actual_2 = nx.gutman_index(cbg)
-
-    assert expected_1 == actual_1
-    assert expected_2 == actual_2
-
-
-def test_schultz_and_gutman_index_of_complete_bipartite_graph_2():
-    n = 2
-    m = 5
-    cbg = nx.complete_bipartite_graph(n, m)
-
-    expected_1 = n * m * (n + m) + 2 * n * (n - 1) * m + 2 * m * (m - 1) * n
-    actual_1 = nx.schultz_index(cbg)
-
-    expected_2 = n * m * (n * m) + n * (n - 1) * m * m + m * (m - 1) * n * n
-    actual_2 = nx.gutman_index(cbg)
-
-    assert expected_1 == actual_1
-    assert expected_2 == actual_2
-
-
-def test_schultz_and_gutman_index_of_complete_graph():
-    n = 5
-    cg = nx.complete_graph(n)
-
-    expected_1 = n * (n - 1) * (n - 1)
-    actual_1 = nx.schultz_index(cg)
-
-    assert expected_1 == actual_1
-
-    expected_2 = n * (n - 1) * (n - 1) * (n - 1) / 2
-    actual_2 = nx.gutman_index(cg)
-
-    assert expected_2 == actual_2
-
-
-def test_schultz_and_gutman_index_of_odd_cycle_graph():
-    k = 5
-    n = 2 * k + 1
-    ocg = nx.cycle_graph(n)
-
-    expected_1 = 2 * n * k * (k + 1)
-    actual_1 = nx.schultz_index(ocg)
-
-    expected_2 = 2 * n * k * (k + 1)
-    actual_2 = nx.gutman_index(ocg)
-
-    assert expected_1 == actual_1
-    assert expected_2 == actual_2
-
-
-def test_hyper_wiener_of_complete_graph():
-    # In a complete graph K_n, the distance is always 1.
-    # For K_n, this term is always (1 + 1^2) = 2.
-    #
-    # The number of ordered pairs is n * (n - 1).
-    # The total sum before division is (n * (n - 1)) * 2.
-    # The final result is therefore ((n * (n - 1)) * 2) / 2, which
-    # simplifies to n * (n - 1).
-    n = 5
-    G = nx.complete_graph(n)
-    assert nx.hyper_wiener_index(G) == n * (n - 1)
-
-
-def test_hyper_wiener_of_path_graph():
-    G = nx.path_graph(4)
-    assert nx.hyper_wiener_index(G) == 30.0
-
-
-def test_hyper_wiener_of_cycle_graph():
-    G = nx.cycle_graph(4)
-    assert nx.hyper_wiener_index(G) == 20.0
-
-
-def test_hyper_wiener_of_disconnected_graph():
-    G = nx.Graph([(0, 1), (2, 3)])
-    assert nx.hyper_wiener_index(G) == float("inf")
-
-
-def test_hyper_wiener_of_weighted_graph():
-    G = nx.path_graph(3)
-    G.edges[0, 1]["weight"] = 2
-    assert nx.hyper_wiener_index(G, weight="weight") == 20.0

package/runtime/python/okstra_vendor/networkx/algorithms/traversal/tests/test_beamsearch.py

@@ -1,25 +0,0 @@
-"""Unit tests for the beam search functions."""
-
-import pytest
-
-import networkx as nx
-
-
-def test_narrow():
-    """Tests that a narrow beam width may cause an incomplete search."""
-    # In this search, we enqueue only the neighbor 3 at the first
-    # step, then only the neighbor 2 at the second step. Once at
-    # node 2, the search chooses node 3, since it has a higher value
-    # than node 1, but node 3 has already been visited, so the
-    # search terminates.
-    G = nx.cycle_graph(4)
-    edges = nx.bfs_beam_edges(G, source=0, value=lambda n: n, width=1)
-    assert list(edges) == [(0, 3), (3, 2)]
-
-
-@pytest.mark.parametrize("width", (2, None))
-def test_wide(width):
-    """All nodes are searched when `width` is None or >= max degree"""
-    G = nx.cycle_graph(4)
-    edges = nx.bfs_beam_edges(G, source=0, value=lambda n: n, width=width)
-    assert list(edges) == [(0, 3), (0, 1), (3, 2)]