okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/generators/tests/test_internet_as_graphs.py

@@ -1,221 +0,0 @@
-from pytest import approx
-
-import networkx as nx
-from networkx import is_connected, neighbors
-from networkx.generators.internet_as_graphs import (
-    AS_graph_generator,
-    choose_pref_attach,
-    random_internet_as_graph,
-)
-
-
-class TestInternetASTopology:
-    @classmethod
-    def setup_class(cls):
-        cls.n = 1000
-        cls.seed = 42
-        cls.G = random_internet_as_graph(cls.n, cls.seed)
-        cls.T = []
-        cls.M = []
-        cls.C = []
-        cls.CP = []
-        cls.customers = {}
-        cls.providers = {}
-
-        for i in cls.G.nodes():
-            if cls.G.nodes[i]["type"] == "T":
-                cls.T.append(i)
-            elif cls.G.nodes[i]["type"] == "M":
-                cls.M.append(i)
-            elif cls.G.nodes[i]["type"] == "C":
-                cls.C.append(i)
-            elif cls.G.nodes[i]["type"] == "CP":
-                cls.CP.append(i)
-            else:
-                raise ValueError("Inconsistent data in the graph node attributes")
-            cls.set_customers(i)
-            cls.set_providers(i)
-
-    @classmethod
-    def set_customers(cls, i):
-        if i not in cls.customers:
-            cls.customers[i] = set()
-            for j in neighbors(cls.G, i):
-                e = cls.G.edges[(i, j)]
-                if e["type"] == "transit":
-                    customer = int(e["customer"])
-                    if j == customer:
-                        cls.set_customers(j)
-                        cls.customers[i] = cls.customers[i].union(cls.customers[j])
-                        cls.customers[i].add(j)
-                    elif i != customer:
-                        raise ValueError(
-                            "Inconsistent data in the graph edge attributes"
-                        )
-
-    @classmethod
-    def set_providers(cls, i):
-        if i not in cls.providers:
-            cls.providers[i] = set()
-            for j in neighbors(cls.G, i):
-                e = cls.G.edges[(i, j)]
-                if e["type"] == "transit":
-                    customer = int(e["customer"])
-                    if i == customer:
-                        cls.set_providers(j)
-                        cls.providers[i] = cls.providers[i].union(cls.providers[j])
-                        cls.providers[i].add(j)
-                    elif j != customer:
-                        raise ValueError(
-                            "Inconsistent data in the graph edge attributes"
-                        )
-
-    def test_wrong_input(self):
-        G = random_internet_as_graph(0)
-        assert len(G.nodes()) == 0
-
-        G = random_internet_as_graph(-1)
-        assert len(G.nodes()) == 0
-
-        G = random_internet_as_graph(1)
-        assert len(G.nodes()) == 1
-
-    def test_node_numbers(self):
-        assert len(self.G.nodes()) == self.n
-        assert len(self.T) < 7
-        assert len(self.M) == round(self.n * 0.15)
-        assert len(self.CP) == round(self.n * 0.05)
-        numb = self.n - len(self.T) - len(self.M) - len(self.CP)
-        assert len(self.C) == numb
-
-    def test_connectivity(self):
-        assert is_connected(self.G)
-
-    def test_relationships(self):
-        # T nodes are not customers of anyone
-        for i in self.T:
-            assert len(self.providers[i]) == 0
-
-        # C nodes are not providers of anyone
-        for i in self.C:
-            assert len(self.customers[i]) == 0
-
-        # CP nodes are not providers of anyone
-        for i in self.CP:
-            assert len(self.customers[i]) == 0
-
-        # test whether there is a customer-provider loop
-        for i in self.G.nodes():
-            assert len(self.customers[i].intersection(self.providers[i])) == 0
-
-        # test whether there is a peering with a customer or provider
-        for i, j in self.G.edges():
-            if self.G.edges[(i, j)]["type"] == "peer":
-                assert j not in self.customers[i]
-                assert i not in self.customers[j]
-                assert j not in self.providers[i]
-                assert i not in self.providers[j]
-
-    def test_degree_values(self):
-        d_m = 0  # multihoming degree for M nodes
-        d_cp = 0  # multihoming degree for CP nodes
-        d_c = 0  # multihoming degree for C nodes
-        p_m_m = 0  # avg number of peering edges between M and M
-        p_cp_m = 0  # avg number of peering edges between CP and M
-        p_cp_cp = 0  # avg number of peering edges between CP and CP
-        t_m = 0  # probability M's provider is T
-        t_cp = 0  # probability CP's provider is T
-        t_c = 0  # probability C's provider is T
-
-        for i, j in self.G.edges():
-            e = self.G.edges[(i, j)]
-            if e["type"] == "transit":
-                cust = int(e["customer"])
-                if i == cust:
-                    prov = j
-                elif j == cust:
-                    prov = i
-                else:
-                    raise ValueError("Inconsistent data in the graph edge attributes")
-                if cust in self.M:
-                    d_m += 1
-                    if self.G.nodes[prov]["type"] == "T":
-                        t_m += 1
-                elif cust in self.C:
-                    d_c += 1
-                    if self.G.nodes[prov]["type"] == "T":
-                        t_c += 1
-                elif cust in self.CP:
-                    d_cp += 1
-                    if self.G.nodes[prov]["type"] == "T":
-                        t_cp += 1
-                else:
-                    raise ValueError("Inconsistent data in the graph edge attributes")
-            elif e["type"] == "peer":
-                if self.G.nodes[i]["type"] == "M" and self.G.nodes[j]["type"] == "M":
-                    p_m_m += 1
-                if self.G.nodes[i]["type"] == "CP" and self.G.nodes[j]["type"] == "CP":
-                    p_cp_cp += 1
-                if (
-                    self.G.nodes[i]["type"] == "M"
-                    and self.G.nodes[j]["type"] == "CP"
-                    or self.G.nodes[i]["type"] == "CP"
-                    and self.G.nodes[j]["type"] == "M"
-                ):
-                    p_cp_m += 1
-            else:
-                raise ValueError("Unexpected data in the graph edge attributes")
-
-        assert d_m / len(self.M) == approx((2 + (2.5 * self.n) / 10000), abs=1e-0)
-        assert d_cp / len(self.CP) == approx((2 + (1.5 * self.n) / 10000), abs=1e-0)
-        assert d_c / len(self.C) == approx((1 + (5 * self.n) / 100000), abs=1e-0)
-
-        assert p_m_m / len(self.M) == approx((1 + (2 * self.n) / 10000), abs=1e-0)
-        assert p_cp_m / len(self.CP) == approx((0.2 + (2 * self.n) / 10000), abs=1e-0)
-        assert p_cp_cp / len(self.CP) == approx(
-            (0.05 + (2 * self.n) / 100000), abs=1e-0
-        )
-
-        assert t_m / d_m == approx(0.375, abs=1e-1)
-        assert t_cp / d_cp == approx(0.375, abs=1e-1)
-        assert t_c / d_c == approx(0.125, abs=1e-1)
-
-
-def test_AS_graph_coverage():
-    """Add test coverage for some hard-to-hit branches."""
-    GG = AS_graph_generator(20, seed=42)
-    G = GG.generate()
-    assert len(G) == 20
-
-    # Proportion of M nodes is 0.15, so there are 3 when n = 20.
-    assert len(GG.nodes["M"]) == 3
-    m_node = nx.utils.arbitrary_element(GG.nodes["M"])
-    # Proportion of CP nodes is 0.05, so there is 1 when n = 20.
-    assert len(GG.nodes["CP"]) == 1
-    cp_node = nx.utils.arbitrary_element(GG.nodes["CP"])
-
-    # All M nodes are already connected to each other.
-    assert all(u in G[v] for u in GG.nodes["M"] for v in GG.nodes["M"] if u != v)
-
-    # Add coverage for the unsuccessful branches when adding peering links.
-    # `add_m_peering_link` cannot add edges when the nodes are already connected.
-    assert not GG.add_m_peering_link(m_node, "M")
-    # Artificially add nodes to `customers` to check customer neighbors are
-    # correctly excluded.
-    GG.customers[m_node] = set(GG.nodes["M"])
-    assert not GG.add_m_peering_link(m_node, "M")
-
-    # Artificially remove nodes from `providers` to check neighbors are
-    # correctly excluded (otherwise they might already get disqualified).
-    GG.providers[cp_node] = set()
-    assert not GG.add_cp_peering_link(cp_node, "CP")
-    assert not GG.add_cp_peering_link(cp_node, "M")
-
-    # Add coverage for trying to add a new M node where one already exists.
-    GG.add_node(m_node, "M", 1, 2, 0.5)
-    assert len(GG.nodes["M"]) == 3
-
-
-def test_choose_pref_attach():
-    """Add test coverage for the empty `degs` branch in `choose_pref_attach`."""
-    assert choose_pref_attach([], seed=42) is None

package/runtime/python/okstra_vendor/networkx/generators/tests/test_intersection.py

@@ -1,28 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-class TestIntersectionGraph:
-    def test_random_intersection_graph(self):
-        G = nx.uniform_random_intersection_graph(10, 5, 0.5)
-        assert len(G) == 10
-
-    def test_k_random_intersection_graph(self):
-        G = nx.k_random_intersection_graph(10, 5, 2)
-        assert len(G) == 10
-
-    def test_k_random_intersection_graph_seeded(self):
-        G = nx.k_random_intersection_graph(10, 5, 2, seed=1234)
-        assert len(G) == 10
-
-    def test_general_random_intersection_graph(self):
-        G = nx.general_random_intersection_graph(10, 5, [0.1, 0.2, 0.2, 0.1, 0.1])
-        assert len(G) == 10
-        pytest.raises(
-            ValueError,
-            nx.general_random_intersection_graph,
-            10,
-            5,
-            [0.1, 0.2, 0.2, 0.1],
-        )

package/runtime/python/okstra_vendor/networkx/generators/tests/test_interval_graph.py

@@ -1,144 +0,0 @@
-"""Unit tests for the :mod:`networkx.generators.interval_graph` module."""
-
-import math
-
-import pytest
-
-import networkx as nx
-from networkx.generators.interval_graph import interval_graph
-from networkx.utils import edges_equal
-
-
-class TestIntervalGraph:
-    """Unit tests for :func:`networkx.generators.interval_graph.interval_graph`"""
-
-    def test_empty(self):
-        """Tests for trivial case of empty input"""
-        assert len(interval_graph([])) == 0
-
-    def test_interval_graph_check_invalid(self):
-        """Tests for conditions that raise Exceptions"""
-
-        invalids_having_none = [None, (1, 2)]
-        with pytest.raises(TypeError):
-            interval_graph(invalids_having_none)
-
-        invalids_having_set = [{1, 2}]
-        with pytest.raises(TypeError):
-            interval_graph(invalids_having_set)
-
-        invalids_having_seq_but_not_length2 = [(1, 2, 3)]
-        with pytest.raises(TypeError):
-            interval_graph(invalids_having_seq_but_not_length2)
-
-        invalids_interval = [[3, 2]]
-        with pytest.raises(ValueError):
-            interval_graph(invalids_interval)
-
-    def test_interval_graph_0(self):
-        intervals = [(1, 2), (1, 3)]
-
-        expected_graph = nx.Graph()
-        expected_graph.add_edge(*intervals)
-
-        actual_g = interval_graph(intervals)
-
-        assert set(actual_g.nodes) == set(expected_graph.nodes)
-        assert edges_equal(expected_graph, actual_g)
-
-    def test_interval_graph_1(self):
-        intervals = [(1, 2), (2, 3), (3, 4), (1, 4)]
-
-        expected_graph = nx.Graph()
-        expected_graph.add_nodes_from(intervals)
-        e1 = ((1, 4), (1, 2))
-        e2 = ((1, 4), (2, 3))
-        e3 = ((1, 4), (3, 4))
-        e4 = ((3, 4), (2, 3))
-        e5 = ((1, 2), (2, 3))
-
-        expected_graph.add_edges_from([e1, e2, e3, e4, e5])
-
-        actual_g = interval_graph(intervals)
-
-        assert set(actual_g.nodes) == set(expected_graph.nodes)
-        assert edges_equal(expected_graph, actual_g)
-
-    def test_interval_graph_2(self):
-        intervals = [(1, 2), [3, 5], [6, 8], (9, 10)]
-
-        expected_graph = nx.Graph()
-        expected_graph.add_nodes_from([(1, 2), (3, 5), (6, 8), (9, 10)])
-
-        actual_g = interval_graph(intervals)
-
-        assert set(actual_g.nodes) == set(expected_graph.nodes)
-        assert edges_equal(expected_graph, actual_g)
-
-    def test_interval_graph_3(self):
-        intervals = [(1, 4), [3, 5], [2.5, 4]]
-
-        expected_graph = nx.Graph()
-        expected_graph.add_nodes_from([(1, 4), (3, 5), (2.5, 4)])
-        e1 = ((1, 4), (3, 5))
-        e2 = ((1, 4), (2.5, 4))
-        e3 = ((3, 5), (2.5, 4))
-
-        expected_graph.add_edges_from([e1, e2, e3])
-
-        actual_g = interval_graph(intervals)
-
-        assert set(actual_g.nodes) == set(expected_graph.nodes)
-        assert edges_equal(expected_graph, actual_g)
-
-    def test_interval_graph_4(self):
-        """test all possible overlaps"""
-        intervals = [
-            (0, 2),
-            (-2, -1),
-            (-2, 0),
-            (-2, 1),
-            (-2, 2),
-            (-2, 3),
-            (0, 1),
-            (0, 2),
-            (0, 3),
-            (1, 2),
-            (1, 3),
-            (2, 3),
-            (3, 4),
-        ]
-
-        expected_graph = nx.Graph()
-        expected_graph.add_nodes_from(intervals)
-        expected_nbrs = {
-            (-2, 0),
-            (-2, 1),
-            (-2, 2),
-            (-2, 3),
-            (0, 1),
-            (0, 2),
-            (0, 3),
-            (1, 2),
-            (1, 3),
-            (2, 3),
-        }
-        actual_g = nx.interval_graph(intervals)
-        actual_nbrs = nx.neighbors(actual_g, (0, 2))
-
-        assert set(actual_nbrs) == expected_nbrs
-
-    def test_interval_graph_5(self):
-        """this test is to see that an interval supports infinite number"""
-        intervals = {(-math.inf, 0), (-1, -1), (0.5, 0.5), (1, 1), (1, math.inf)}
-
-        expected_graph = nx.Graph()
-        expected_graph.add_nodes_from(intervals)
-        e1 = ((-math.inf, 0), (-1, -1))
-        e2 = ((1, 1), (1, math.inf))
-
-        expected_graph.add_edges_from([e1, e2])
-        actual_g = interval_graph(intervals)
-
-        assert set(actual_g.nodes) == set(expected_graph.nodes)
-        assert edges_equal(expected_graph, actual_g)

package/runtime/python/okstra_vendor/networkx/generators/tests/test_joint_degree_seq.py

@@ -1,125 +0,0 @@
-import time
-
-from networkx.algorithms.assortativity import degree_mixing_dict
-from networkx.generators import gnm_random_graph, powerlaw_cluster_graph
-from networkx.generators.joint_degree_seq import (
-    directed_joint_degree_graph,
-    is_valid_directed_joint_degree,
-    is_valid_joint_degree,
-    joint_degree_graph,
-)
-
-
-def test_is_valid_joint_degree():
-    """Tests for conditions that invalidate a joint degree dict"""
-
-    # valid joint degree that satisfies all five conditions
-    joint_degrees = {
-        1: {4: 1},
-        2: {2: 2, 3: 2, 4: 2},
-        3: {2: 2, 4: 1},
-        4: {1: 1, 2: 2, 3: 1},
-    }
-    assert is_valid_joint_degree(joint_degrees)
-
-    # test condition 1
-    # joint_degrees_1[1][4] not integer
-    joint_degrees_1 = {
-        1: {4: 1.5},
-        2: {2: 2, 3: 2, 4: 2},
-        3: {2: 2, 4: 1},
-        4: {1: 1.5, 2: 2, 3: 1},
-    }
-    assert not is_valid_joint_degree(joint_degrees_1)
-
-    # test condition 2
-    # degree_count[2] = sum(joint_degrees_2[2][j)/2, is not an int
-    # degree_count[4] = sum(joint_degrees_2[4][j)/4, is not an int
-    joint_degrees_2 = {
-        1: {4: 1},
-        2: {2: 2, 3: 2, 4: 3},
-        3: {2: 2, 4: 1},
-        4: {1: 1, 2: 3, 3: 1},
-    }
-    assert not is_valid_joint_degree(joint_degrees_2)
-
-    # test conditions 3 and 4
-    # joint_degrees_3[1][4]>degree_count[1]*degree_count[4]
-    joint_degrees_3 = {
-        1: {4: 2},
-        2: {2: 2, 3: 2, 4: 2},
-        3: {2: 2, 4: 1},
-        4: {1: 2, 2: 2, 3: 1},
-    }
-    assert not is_valid_joint_degree(joint_degrees_3)
-
-    # test condition 5
-    # joint_degrees_5[1][1] not even
-    joint_degrees_5 = {1: {1: 9}}
-    assert not is_valid_joint_degree(joint_degrees_5)
-
-
-def test_joint_degree_graph(ntimes=10):
-    for _ in range(ntimes):
-        seed = int(time.time())
-
-        n, m, p = 20, 10, 1
-        # generate random graph with model powerlaw_cluster and calculate
-        # its joint degree
-        g = powerlaw_cluster_graph(n, m, p, seed=seed)
-        joint_degrees_g = degree_mixing_dict(g, normalized=False)
-
-        # generate simple undirected graph with given joint degree
-        # joint_degrees_g
-        G = joint_degree_graph(joint_degrees_g)
-        joint_degrees_G = degree_mixing_dict(G, normalized=False)
-
-        # assert that the given joint degree is equal to the generated
-        # graph's joint degree
-        assert joint_degrees_g == joint_degrees_G
-
-
-def test_is_valid_directed_joint_degree():
-    in_degrees = [0, 1, 1, 2]
-    out_degrees = [1, 1, 1, 1]
-    nkk = {1: {1: 2, 2: 2}}
-    assert is_valid_directed_joint_degree(in_degrees, out_degrees, nkk)
-
-    # not realizable, values are not integers.
-    nkk = {1: {1: 1.5, 2: 2.5}}
-    assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk)
-
-    # not realizable, number of edges between 1-2 are insufficient.
-    nkk = {1: {1: 2, 2: 1}}
-    assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk)
-
-    # not realizable, in/out degree sequences have different number of nodes.
-    out_degrees = [1, 1, 1]
-    nkk = {1: {1: 2, 2: 2}}
-    assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk)
-
-    # not realizable, degree sequences have fewer than required nodes.
-    in_degrees = [0, 1, 2]
-    assert not is_valid_directed_joint_degree(in_degrees, out_degrees, nkk)
-
-
-def test_directed_joint_degree_graph(n=15, m=100, ntimes=1000):
-    for _ in range(ntimes):
-        # generate gnm random graph and calculate its joint degree.
-        g = gnm_random_graph(n, m, None, directed=True)
-
-        # in-degree sequence of g as a list of integers.
-        in_degrees = list(dict(g.in_degree()).values())
-        # out-degree sequence of g as a list of integers.
-        out_degrees = list(dict(g.out_degree()).values())
-        nkk = degree_mixing_dict(g)
-
-        # generate simple directed graph with given degree sequence and joint
-        # degree matrix.
-        G = directed_joint_degree_graph(in_degrees, out_degrees, nkk)
-
-        # assert degree sequence correctness.
-        assert in_degrees == list(dict(G.in_degree()).values())
-        assert out_degrees == list(dict(G.out_degree()).values())
-        # assert joint degree matrix correctness.
-        assert nkk == degree_mixing_dict(G)