okstra 0.114.0 → 0.115.0

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

@@ -1,76 +0,0 @@
-import pytest
-
-pytest.importorskip("numpy")
-
-import networkx as nx
-from networkx import lattice_reference, omega, random_reference, sigma
-
-rng = 42
-
-
-def test_random_reference():
-    G = nx.connected_watts_strogatz_graph(50, 6, 0.1, seed=rng)
-    Gr = random_reference(G, niter=1, seed=rng)
-    C = nx.average_clustering(G)
-    Cr = nx.average_clustering(Gr)
-    assert C > Cr
-
-    with pytest.raises(nx.NetworkXError):
-        next(random_reference(nx.Graph()))
-    with pytest.raises(nx.NetworkXNotImplemented):
-        next(random_reference(nx.DiGraph()))
-
-    H = nx.Graph(((0, 1), (2, 3)))
-    Hl = random_reference(H, niter=1, seed=rng)
-
-
-def test_lattice_reference():
-    G = nx.connected_watts_strogatz_graph(50, 6, 1, seed=rng)
-    Gl = lattice_reference(G, niter=1, seed=rng)
-    L = nx.average_shortest_path_length(G)
-    Ll = nx.average_shortest_path_length(Gl)
-    assert Ll > L
-
-    pytest.raises(nx.NetworkXError, lattice_reference, nx.Graph())
-    pytest.raises(nx.NetworkXNotImplemented, lattice_reference, nx.DiGraph())
-
-    H = nx.Graph(((0, 1), (2, 3)))
-    Hl = lattice_reference(H, niter=1)
-
-
-def test_sigma():
-    Gs = nx.connected_watts_strogatz_graph(50, 6, 0.1, seed=rng)
-    Gr = nx.connected_watts_strogatz_graph(50, 6, 1, seed=rng)
-    sigmas = sigma(Gs, niter=1, nrand=2, seed=rng)
-    sigmar = sigma(Gr, niter=1, nrand=2, seed=rng)
-    assert sigmar < sigmas
-
-
-def test_omega():
-    Gl = nx.connected_watts_strogatz_graph(50, 6, 0, seed=rng)
-    Gr = nx.connected_watts_strogatz_graph(50, 6, 1, seed=rng)
-    Gs = nx.connected_watts_strogatz_graph(50, 6, 0.1, seed=rng)
-    omegal = omega(Gl, niter=1, nrand=1, seed=rng)
-    omegar = omega(Gr, niter=1, nrand=1, seed=rng)
-    omegas = omega(Gs, niter=1, nrand=1, seed=rng)
-    assert omegal < omegas and omegas < omegar
-
-    # Test that omega lies within the [-1, 1] bounds
-    G_barbell = nx.barbell_graph(5, 1)
-    G_karate = nx.karate_club_graph()
-
-    omega_barbell = nx.omega(G_barbell)
-    omega_karate = nx.omega(G_karate, nrand=2)
-
-    omegas = (omegal, omegar, omegas, omega_barbell, omega_karate)
-
-    for o in omegas:
-        assert -1 <= o <= 1
-
-
-@pytest.mark.parametrize("f", (nx.random_reference, nx.lattice_reference))
-def test_graph_no_edges(f):
-    G = nx.Graph()
-    G.add_nodes_from([0, 1, 2, 3])
-    with pytest.raises(nx.NetworkXError, match="Graph has fewer that 2 edges"):
-        f(G)

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

@@ -1,8 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-def test_smetric():
-    G = nx.Graph([(1, 2), (2, 3), (2, 4), (1, 4)])
-    assert nx.s_metric(G) == 19.0

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

@@ -1,138 +0,0 @@
-"""Unit tests for the sparsifier computation functions."""
-
-import pytest
-
-import networkx as nx
-from networkx.utils import py_random_state
-
-_seed = 2
-
-
-def _test_spanner(G, spanner, stretch, weight=None):
-    """Test whether a spanner is valid.
-
-    This function tests whether the given spanner is a subgraph of the
-    given graph G with the same node set. It also tests for all shortest
-    paths whether they adhere to the given stretch.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        The original graph for which the spanner was constructed.
-
-    spanner : NetworkX graph
-        The spanner to be tested.
-
-    stretch : float
-        The proclaimed stretch of the spanner.
-
-    weight : object
-        The edge attribute to use as distance.
-    """
-    # check node set
-    assert set(G.nodes()) == set(spanner.nodes())
-
-    # check edge set and weights
-    for u, v in spanner.edges():
-        assert G.has_edge(u, v)
-        if weight:
-            assert spanner[u][v][weight] == G[u][v][weight]
-
-    # check connectivity and stretch
-    original_length = dict(nx.shortest_path_length(G, weight=weight))
-    spanner_length = dict(nx.shortest_path_length(spanner, weight=weight))
-    for u in G.nodes():
-        for v in G.nodes():
-            if u in original_length and v in original_length[u]:
-                assert spanner_length[u][v] <= stretch * original_length[u][v]
-
-
-@py_random_state(1)
-def _assign_random_weights(G, seed=None):
-    """Assigns random weights to the edges of a graph.
-
-    Parameters
-    ----------
-
-    G : NetworkX graph
-        The original graph for which the spanner was constructed.
-
-    seed : integer, random_state, or None (default)
-        Indicator of random number generation state.
-        See :ref:`Randomness<randomness>`.
-    """
-    for u, v in G.edges():
-        G[u][v]["weight"] = seed.random()
-
-
-def test_spanner_trivial():
-    """Test a trivial spanner with stretch 1."""
-    G = nx.complete_graph(20)
-    spanner = nx.spanner(G, 1, seed=_seed)
-
-    for u, v in G.edges:
-        assert spanner.has_edge(u, v)
-
-
-def test_spanner_unweighted_complete_graph():
-    """Test spanner construction on a complete unweighted graph."""
-    G = nx.complete_graph(20)
-
-    spanner = nx.spanner(G, 4, seed=_seed)
-    _test_spanner(G, spanner, 4)
-
-    spanner = nx.spanner(G, 10, seed=_seed)
-    _test_spanner(G, spanner, 10)
-
-
-def test_spanner_weighted_complete_graph():
-    """Test spanner construction on a complete weighted graph."""
-    G = nx.complete_graph(20)
-    _assign_random_weights(G, seed=_seed)
-
-    spanner = nx.spanner(G, 4, weight="weight", seed=_seed)
-    _test_spanner(G, spanner, 4, weight="weight")
-
-    spanner = nx.spanner(G, 10, weight="weight", seed=_seed)
-    _test_spanner(G, spanner, 10, weight="weight")
-
-
-def test_spanner_unweighted_gnp_graph():
-    """Test spanner construction on an unweighted gnp graph."""
-    G = nx.gnp_random_graph(20, 0.4, seed=_seed)
-
-    spanner = nx.spanner(G, 4, seed=_seed)
-    _test_spanner(G, spanner, 4)
-
-    spanner = nx.spanner(G, 10, seed=_seed)
-    _test_spanner(G, spanner, 10)
-
-
-def test_spanner_weighted_gnp_graph():
-    """Test spanner construction on an weighted gnp graph."""
-    G = nx.gnp_random_graph(20, 0.4, seed=_seed)
-    _assign_random_weights(G, seed=_seed)
-
-    spanner = nx.spanner(G, 4, weight="weight", seed=_seed)
-    _test_spanner(G, spanner, 4, weight="weight")
-
-    spanner = nx.spanner(G, 10, weight="weight", seed=_seed)
-    _test_spanner(G, spanner, 10, weight="weight")
-
-
-def test_spanner_unweighted_disconnected_graph():
-    """Test spanner construction on a disconnected graph."""
-    G = nx.disjoint_union(nx.complete_graph(10), nx.complete_graph(10))
-
-    spanner = nx.spanner(G, 4, seed=_seed)
-    _test_spanner(G, spanner, 4)
-
-    spanner = nx.spanner(G, 10, seed=_seed)
-    _test_spanner(G, spanner, 10)
-
-
-def test_spanner_invalid_stretch():
-    """Check whether an invalid stretch is caught."""
-    with pytest.raises(ValueError):
-        G = nx.empty_graph()
-        nx.spanner(G, 0)

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

@@ -1,191 +0,0 @@
-"""Unit tests for the :mod:`networkx.algorithms.structuralholes` module."""
-
-import math
-
-import pytest
-
-import networkx as nx
-from networkx.classes.tests import dispatch_interface
-
-
-class TestStructuralHolesNoScipy:
-    """Unit tests for computing measures of structural holes.
-
-    The expected values for these functions were originally computed using the
-    proprietary software `UCINET`_ and the free software `IGraph`_ , and then
-    computed by hand to make sure that the results are correct.
-
-    .. _UCINET: https://sites.google.com/site/ucinetsoftware/home
-    .. _IGraph: http://igraph.org/
-
-    """
-
-    def setup_method(self):
-        self.D = nx.DiGraph()
-        self.D.add_edges_from([(0, 1), (0, 2), (1, 0), (2, 1)])
-        self.D_weights = {(0, 1): 2, (0, 2): 2, (1, 0): 1, (2, 1): 1}
-        # Example from http://www.analytictech.com/connections/v20(1)/holes.htm
-        self.G = nx.Graph()
-        self.G.add_edges_from(
-            [
-                ("A", "B"),
-                ("A", "F"),
-                ("A", "G"),
-                ("A", "E"),
-                ("E", "G"),
-                ("F", "G"),
-                ("B", "G"),
-                ("B", "D"),
-                ("D", "G"),
-                ("G", "C"),
-            ]
-        )
-        self.G_weights = {
-            ("A", "B"): 2,
-            ("A", "F"): 3,
-            ("A", "G"): 5,
-            ("A", "E"): 2,
-            ("E", "G"): 8,
-            ("F", "G"): 3,
-            ("B", "G"): 4,
-            ("B", "D"): 1,
-            ("D", "G"): 3,
-            ("G", "C"): 10,
-        }
-        self.Dnodes = list(self.D)
-        self.Gnodes = list(self.G)
-
-    def test_constraint_directed(self):
-        constraint = nx.constraint(self.D, nodes=self.Dnodes)
-        assert constraint[0] == pytest.approx(1.003, abs=1e-3)
-        assert constraint[1] == pytest.approx(1.003, abs=1e-3)
-        assert constraint[2] == pytest.approx(1.389, abs=1e-3)
-
-    def test_effective_size_directed(self):
-        effective_size = nx.effective_size(self.D, nodes=self.Dnodes)
-        assert effective_size[0] == pytest.approx(1.167, abs=1e-3)
-        assert effective_size[1] == pytest.approx(1.167, abs=1e-3)
-        assert effective_size[2] == pytest.approx(1, abs=1e-3)
-
-    def test_constraint_weighted_directed(self):
-        D = self.D.copy()
-        nx.set_edge_attributes(D, self.D_weights, "weight")
-        constraint = nx.constraint(D, weight="weight", nodes=self.Dnodes)
-        assert constraint[0] == pytest.approx(0.840, abs=1e-3)
-        assert constraint[1] == pytest.approx(1.143, abs=1e-3)
-        assert constraint[2] == pytest.approx(1.378, abs=1e-3)
-
-    def test_effective_size_weighted_directed(self):
-        D = self.D.copy()
-        nx.set_edge_attributes(D, self.D_weights, "weight")
-        effective_size = nx.effective_size(D, weight="weight", nodes=self.Dnodes)
-        assert effective_size[0] == pytest.approx(1.567, abs=1e-3)
-        assert effective_size[1] == pytest.approx(1.083, abs=1e-3)
-        assert effective_size[2] == pytest.approx(1, abs=1e-3)
-
-    def test_constraint_undirected(self):
-        constraint = nx.constraint(self.G, nodes=self.Gnodes)
-        assert constraint["G"] == pytest.approx(0.400, abs=1e-3)
-        assert constraint["A"] == pytest.approx(0.595, abs=1e-3)
-        assert constraint["C"] == pytest.approx(1, abs=1e-3)
-
-    def test_effective_size_undirected_borgatti(self):
-        effective_size = nx.effective_size(self.G, nodes=self.Gnodes)
-        assert effective_size["G"] == pytest.approx(4.67, abs=1e-2)
-        assert effective_size["A"] == pytest.approx(2.50, abs=1e-2)
-        assert effective_size["C"] == pytest.approx(1, abs=1e-2)
-
-    def test_effective_size_undirected(self):
-        G = self.G.copy()
-        nx.set_edge_attributes(G, 1, "weight")
-        effective_size = nx.effective_size(G, weight="weight", nodes=self.Gnodes)
-        assert effective_size["G"] == pytest.approx(4.67, abs=1e-2)
-        assert effective_size["A"] == pytest.approx(2.50, abs=1e-2)
-        assert effective_size["C"] == pytest.approx(1, abs=1e-2)
-
-    def test_constraint_weighted_undirected(self):
-        G = self.G.copy()
-        nx.set_edge_attributes(G, self.G_weights, "weight")
-        constraint = nx.constraint(G, weight="weight", nodes=self.Gnodes)
-        assert constraint["G"] == pytest.approx(0.299, abs=1e-3)
-        assert constraint["A"] == pytest.approx(0.795, abs=1e-3)
-        assert constraint["C"] == pytest.approx(1, abs=1e-3)
-
-    def test_effective_size_weighted_undirected(self):
-        G = self.G.copy()
-        nx.set_edge_attributes(G, self.G_weights, "weight")
-        effective_size = nx.effective_size(G, weight="weight", nodes=self.Gnodes)
-        assert effective_size["G"] == pytest.approx(5.47, abs=1e-2)
-        assert effective_size["A"] == pytest.approx(2.47, abs=1e-2)
-        assert effective_size["C"] == pytest.approx(1, abs=1e-2)
-
-    def test_constraint_isolated(self):
-        G = self.G.copy()
-        G.add_node(1)
-        constraint = nx.constraint(G, nodes=self.Gnodes + [1])
-        assert math.isnan(constraint[1])
-
-    def test_effective_size_isolated(self):
-        G = self.G.copy()
-        G.add_node(1)
-        nx.set_edge_attributes(G, self.G_weights, "weight")
-        effective_size = nx.effective_size(G, weight="weight", nodes=self.Gnodes + [1])
-        assert math.isnan(effective_size[1])
-
-    def test_effective_size_borgatti_isolated(self):
-        G = self.G.copy()
-        G.add_node(1)
-        effective_size = nx.effective_size(G, nodes=self.Gnodes + [1])
-        assert math.isnan(effective_size[1])
-
-
-class TestStructuralHoles(TestStructuralHolesNoScipy):
-    pytest.importorskip("scipy")
-    Dnodes = None
-    Gnodes = None
-
-
-@pytest.mark.parametrize("graph", (nx.Graph, nx.DiGraph))
-@pytest.mark.parametrize("nodes", (None, [0]))
-def test_effective_size_isolated_node_with_selfloop(graph, nodes):
-    """Behavior consistent with isolated node without self-loop. See gh-6916"""
-    G = graph([(0, 0)])  # Single node with one self-edge
-    assert math.isnan(nx.effective_size(G, nodes=nodes)[0])
-
-
-@pytest.mark.parametrize("graph", (nx.Graph, nx.DiGraph))
-@pytest.mark.parametrize("nodes", (None, [0]))
-def test_effective_size_isolated_node_with_selfloop_weighted(graph, nodes):
-    """Weighted self-loop. See gh-6916"""
-    G = graph()
-    G.add_weighted_edges_from([(0, 0, 10)])
-    assert math.isnan(nx.effective_size(G, nodes=nodes)[0])
-
-
-@pytest.mark.parametrize("graph", (nx.Graph, nx.DiGraph))
-def test_constraint_isolated_node_with_selfloop(graph):
-    """Behavior consistent with isolated node without self-loop. See gh-6916"""
-    G = graph([(0, 0)])  # Single node with one self-edge
-    assert math.isnan(nx.constraint(G)[0])
-
-
-@pytest.mark.parametrize("graph", (nx.Graph, nx.DiGraph))
-def test_constraint_isolated_node_with_selfloop_using_nodes_kwarg(graph):
-    """Behavior consistent with isolated node without self-loop. See gh-6916"""
-    G = graph([(0, 0)])  # Single node with one self-edge
-    assert nx.constraint(G, nodes=[0])[0] == 4
-
-
-@pytest.mark.parametrize("graph", (nx.Graph, nx.DiGraph))
-def test_constraint_isolated_node_with_selfloop_weighted(graph):
-    """Weighted self-loop. See gh-6916"""
-    G = graph()
-    G.add_weighted_edges_from([(0, 0, 10)])
-    assert math.isnan(nx.constraint(G)[0])
-
-
-@pytest.mark.parametrize("graph", (nx.Graph, nx.DiGraph))
-def test_constraint_isolated_node_with_selfloop_weighted_using_nodes_kwarg(graph):
-    G = graph()
-    G.add_weighted_edges_from([(0, 0, 10)])
-    assert nx.constraint(G, nodes=[0])[0] == 4