okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/algorithms/isomorphism/tests/test_vf2userfunc.py

@@ -1,196 +0,0 @@
-"""
-Tests for VF2 isomorphism algorithm for weighted graphs.
-"""
-
-import math
-from operator import eq
-
-import networkx as nx
-import networkx.algorithms.isomorphism as iso
-
-
-def test_simple():
-    # 16 simple tests
-    w = "weight"
-    edges = [(0, 0, 1), (0, 0, 1.5), (0, 1, 2), (1, 0, 3)]
-    for g1 in [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]:
-        g1.add_weighted_edges_from(edges)
-        g2 = g1.subgraph(g1.nodes())
-        if g1.is_multigraph():
-            em = iso.numerical_multiedge_match("weight", 1)
-        else:
-            em = iso.numerical_edge_match("weight", 1)
-        assert nx.is_isomorphic(g1, g2, edge_match=em)
-
-        for mod1, mod2 in [(False, True), (True, False), (True, True)]:
-            # mod1 tests a regular edge
-            # mod2 tests a selfloop
-            if g2.is_multigraph():
-                if mod1:
-                    data1 = {0: {"weight": 10}}
-                if mod2:
-                    data2 = {0: {"weight": 1}, 1: {"weight": 2.5}}
-            else:
-                if mod1:
-                    data1 = {"weight": 10}
-                if mod2:
-                    data2 = {"weight": 2.5}
-
-            g2 = g1.subgraph(g1.nodes()).copy()
-            if mod1:
-                if not g1.is_directed():
-                    g2._adj[1][0] = data1
-                    g2._adj[0][1] = data1
-                else:
-                    g2._succ[1][0] = data1
-                    g2._pred[0][1] = data1
-            if mod2:
-                if not g1.is_directed():
-                    g2._adj[0][0] = data2
-                else:
-                    g2._succ[0][0] = data2
-                    g2._pred[0][0] = data2
-
-            assert not nx.is_isomorphic(g1, g2, edge_match=em)
-
-
-def test_weightkey():
-    g1 = nx.DiGraph()
-    g2 = nx.DiGraph()
-
-    g1.add_edge("A", "B", weight=1)
-    g2.add_edge("C", "D", weight=0)
-
-    assert nx.is_isomorphic(g1, g2)
-    em = iso.numerical_edge_match("nonexistent attribute", 1)
-    assert nx.is_isomorphic(g1, g2, edge_match=em)
-    em = iso.numerical_edge_match("weight", 1)
-    assert not nx.is_isomorphic(g1, g2, edge_match=em)
-
-    g2 = nx.DiGraph()
-    g2.add_edge("C", "D")
-    assert nx.is_isomorphic(g1, g2, edge_match=em)
-
-
-class TestMatch_Graph:
-    def setup_method(self):
-        self.g1 = nx.Graph()
-        self.g2 = nx.Graph()
-        self.build()
-
-    def build(self):
-        self.nm = iso.categorical_node_match("color", "")
-        self.em = iso.numerical_edge_match("weight", 1)
-
-        self.g1.add_node("A", color="red")
-        self.g2.add_node("C", color="blue")
-
-        self.g1.add_edge("A", "B", weight=1)
-        self.g2.add_edge("C", "D", weight=1)
-
-    def test_noweight_nocolor(self):
-        assert nx.is_isomorphic(self.g1, self.g2)
-
-    def test_color1(self):
-        assert not nx.is_isomorphic(self.g1, self.g2, node_match=self.nm)
-
-    def test_color2(self):
-        self.g1.nodes["A"]["color"] = "blue"
-        assert nx.is_isomorphic(self.g1, self.g2, node_match=self.nm)
-
-    def test_weight1(self):
-        assert nx.is_isomorphic(self.g1, self.g2, edge_match=self.em)
-
-    def test_weight2(self):
-        self.g1.add_edge("A", "B", weight=2)
-        assert not nx.is_isomorphic(self.g1, self.g2, edge_match=self.em)
-
-    def test_colorsandweights1(self):
-        assert not nx.is_isomorphic(
-            self.g1, self.g2, node_match=self.nm, edge_match=self.em
-        )
-
-    def test_colorsandweights2(self):
-        self.g1.nodes["A"]["color"] = "blue"
-        assert nx.is_isomorphic(
-            self.g1, self.g2, node_match=self.nm, edge_match=self.em
-        )
-
-    def test_colorsandweights3(self):
-        # make the colors agree and the weights disagree
-        self.g1.nodes["A"]["color"] = "blue"
-        self.g1.add_edge("A", "B", weight=2)
-        assert not nx.is_isomorphic(
-            self.g1, self.g2, node_match=self.nm, edge_match=self.em
-        )
-
-
-class TestMatch_DiGraph(TestMatch_Graph):
-    def setup_method(self):
-        self.g1 = nx.DiGraph()
-        self.g2 = nx.DiGraph()
-        self.build()
-
-
-class TestMatch_MultiGraph:
-    def setup_method(self):
-        self.g1 = nx.MultiGraph()
-        self.g2 = nx.MultiGraph()
-        self.GM = iso.MultiGraphMatcher
-        self.build()
-
-    def build(self):
-        g1 = self.g1
-        g2 = self.g2
-
-        # We will assume integer weights only.
-        g1.add_edge("A", "B", color="green", weight=0, size=0.5)
-        g1.add_edge("A", "B", color="red", weight=1, size=0.35)
-        g1.add_edge("A", "B", color="red", weight=2, size=0.65)
-
-        g2.add_edge("C", "D", color="green", weight=1, size=0.5)
-        g2.add_edge("C", "D", color="red", weight=0, size=0.45)
-        g2.add_edge("C", "D", color="red", weight=2, size=0.65)
-
-        if g1.is_multigraph():
-            self.em = iso.numerical_multiedge_match("weight", 1)
-            self.emc = iso.categorical_multiedge_match("color", "")
-            self.emcm = iso.categorical_multiedge_match(["color", "weight"], ["", 1])
-            self.emg1 = iso.generic_multiedge_match("color", "red", eq)
-            self.emg2 = iso.generic_multiedge_match(
-                ["color", "weight", "size"],
-                ["red", 1, 0.5],
-                [eq, eq, math.isclose],
-            )
-
-    def test_weights_only(self):
-        assert nx.is_isomorphic(self.g1, self.g2, edge_match=self.em)
-
-    def test_colors_only(self):
-        gm = self.GM(self.g1, self.g2, edge_match=self.emc)
-        assert gm.is_isomorphic()
-
-    def test_colorsandweights(self):
-        gm = self.GM(self.g1, self.g2, edge_match=self.emcm)
-        assert not gm.is_isomorphic()
-
-    def test_generic_color_only(self):
-        gm = self.GM(self.g1, self.g2, edge_match=self.emg1)
-        assert gm.is_isomorphic()
-
-    def test_generic_all_3_attr(self):
-        gm = self.GM(self.g1, self.g2, edge_match=self.emg2)
-        assert not gm.is_isomorphic()
-
-        self.g2.edges["C", "D", 0]["weight"] = 0
-        self.g2.edges["C", "D", 1]["weight"] = 1
-        self.g2.edges["C", "D", 1]["size"] = 0.35
-        assert gm.is_isomorphic()
-
-
-class TestMatch_MultiDiGraph(TestMatch_MultiGraph):
-    def setup_method(self):
-        self.g1 = nx.MultiDiGraph()
-        self.g2 = nx.MultiDiGraph()
-        self.GM = iso.MultiDiGraphMatcher
-        self.build()

package/runtime/python/okstra_vendor/networkx/algorithms/link_analysis/tests/test_hits.py

@@ -1,77 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.algorithms.link_analysis.hits_alg import (
-    _hits_numpy,
-    _hits_python,
-    _hits_scipy,
-)
-
-np = pytest.importorskip("numpy")
-sp = pytest.importorskip("scipy")
-
-# Example from
-# A. Langville and C. Meyer, "A survey of eigenvector methods of web
-# information retrieval."  http://citeseer.ist.psu.edu/713792.html
-
-
-class TestHITS:
-    @classmethod
-    def setup_class(cls):
-        G = nx.DiGraph()
-
-        edges = [(1, 3), (1, 5), (2, 1), (3, 5), (5, 4), (5, 3), (6, 5)]
-
-        G.add_edges_from(edges, weight=1)
-        cls.G = G
-        cls.G.a = dict(
-            zip(sorted(G), [0.000000, 0.000000, 0.366025, 0.133975, 0.500000, 0.000000])
-        )
-        cls.G.h = dict(
-            zip(sorted(G), [0.366025, 0.000000, 0.211325, 0.000000, 0.211325, 0.211325])
-        )
-
-    def test_hits_numpy(self):
-        G = self.G
-        h, a = _hits_numpy(G)
-        for n in G:
-            assert h[n] == pytest.approx(G.h[n], abs=1e-4)
-        for n in G:
-            assert a[n] == pytest.approx(G.a[n], abs=1e-4)
-
-    @pytest.mark.parametrize("hits_alg", (nx.hits, _hits_python, _hits_scipy))
-    def test_hits(self, hits_alg):
-        G = self.G
-        h, a = hits_alg(G, tol=1.0e-08)
-        for n in G:
-            assert h[n] == pytest.approx(G.h[n], abs=1e-4)
-        for n in G:
-            assert a[n] == pytest.approx(G.a[n], abs=1e-4)
-        nstart = {i: 1.0 / 2 for i in G}
-        h, a = hits_alg(G, nstart=nstart)
-        for n in G:
-            assert h[n] == pytest.approx(G.h[n], abs=1e-4)
-        for n in G:
-            assert a[n] == pytest.approx(G.a[n], abs=1e-4)
-
-    def test_empty(self):
-        G = nx.Graph()
-        assert nx.hits(G) == ({}, {})
-        assert _hits_numpy(G) == ({}, {})
-        assert _hits_python(G) == ({}, {})
-        assert _hits_scipy(G) == ({}, {})
-
-    def test_hits_not_convergent(self):
-        G = nx.path_graph(50)
-        with pytest.raises(nx.PowerIterationFailedConvergence):
-            _hits_scipy(G, max_iter=1)
-        with pytest.raises(nx.PowerIterationFailedConvergence):
-            _hits_python(G, max_iter=1)
-        with pytest.raises(nx.PowerIterationFailedConvergence):
-            _hits_scipy(G, max_iter=0)
-        with pytest.raises(nx.PowerIterationFailedConvergence):
-            _hits_python(G, max_iter=0)
-        with pytest.raises(nx.PowerIterationFailedConvergence):
-            nx.hits(G, max_iter=0)
-        with pytest.raises(nx.PowerIterationFailedConvergence):
-            nx.hits(G, max_iter=1)

package/runtime/python/okstra_vendor/networkx/algorithms/link_analysis/tests/test_pagerank.py

@@ -1,213 +0,0 @@
-import random
-
-import pytest
-
-import networkx as nx
-from networkx.algorithms.link_analysis.pagerank_alg import (
-    _pagerank_numpy,
-    _pagerank_python,
-    _pagerank_scipy,
-)
-from networkx.classes.tests import dispatch_interface
-
-np = pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-# Example from
-# A. Langville and C. Meyer, "A survey of eigenvector methods of web
-# information retrieval."  http://citeseer.ist.psu.edu/713792.html
-
-
-class TestPageRank:
-    @classmethod
-    def setup_class(cls):
-        G = nx.DiGraph()
-        edges = [
-            (1, 2),
-            (1, 3),
-            # 2 is a dangling node
-            (3, 1),
-            (3, 2),
-            (3, 5),
-            (4, 5),
-            (4, 6),
-            (5, 4),
-            (5, 6),
-            (6, 4),
-        ]
-        G.add_edges_from(edges)
-        cls.G = G
-        cls.G.pagerank = dict(
-            zip(
-                sorted(G),
-                [
-                    0.03721197,
-                    0.05395735,
-                    0.04150565,
-                    0.37508082,
-                    0.20599833,
-                    0.28624589,
-                ],
-            )
-        )
-        cls.dangling_node_index = 1
-        cls.dangling_edges = {1: 2, 2: 3, 3: 0, 4: 0, 5: 0, 6: 0}
-        cls.G.dangling_pagerank = dict(
-            zip(
-                sorted(G),
-                [0.10844518, 0.18618601, 0.0710892, 0.2683668, 0.15919783, 0.20671497],
-            )
-        )
-
-    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
-    def test_pagerank(self, alg):
-        G = self.G
-        p = alg(G, alpha=0.9, tol=1.0e-08)
-        for n in G:
-            assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
-
-        nstart = {n: random.random() for n in G}
-        p = alg(G, alpha=0.9, tol=1.0e-08, nstart=nstart)
-        for n in G:
-            assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
-
-    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
-    def test_pagerank_max_iter(self, alg):
-        with pytest.raises(nx.PowerIterationFailedConvergence):
-            alg(self.G, max_iter=0)
-
-    def test_numpy_pagerank(self):
-        G = self.G
-        p = _pagerank_numpy(G, alpha=0.9)
-        for n in G:
-            assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
-
-    def test_google_matrix(self):
-        G = self.G
-        M = nx.google_matrix(G, alpha=0.9, nodelist=sorted(G))
-        _, ev = np.linalg.eig(M.T)
-        p = ev[:, 0] / ev[:, 0].sum()
-        for a, b in zip(p, self.G.pagerank.values()):
-            assert a == pytest.approx(b, abs=1e-7)
-
-    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python, _pagerank_numpy))
-    def test_personalization(self, alg):
-        G = nx.complete_graph(4)
-        personalize = {0: 1, 1: 1, 2: 4, 3: 4}
-        answer = {
-            0: 0.23246732615667579,
-            1: 0.23246732615667579,
-            2: 0.267532673843324,
-            3: 0.2675326738433241,
-        }
-        p = alg(G, alpha=0.85, personalization=personalize)
-        for n in G:
-            assert p[n] == pytest.approx(answer[n], abs=1e-4)
-
-    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python, nx.google_matrix))
-    def test_zero_personalization_vector(self, alg):
-        G = nx.complete_graph(4)
-        personalize = {0: 0, 1: 0, 2: 0, 3: 0}
-        pytest.raises(ZeroDivisionError, alg, G, personalization=personalize)
-
-    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
-    def test_one_nonzero_personalization_value(self, alg):
-        G = nx.complete_graph(4)
-        personalize = {0: 0, 1: 0, 2: 0, 3: 1}
-        answer = {
-            0: 0.22077931820379187,
-            1: 0.22077931820379187,
-            2: 0.22077931820379187,
-            3: 0.3376620453886241,
-        }
-        p = alg(G, alpha=0.85, personalization=personalize)
-        for n in G:
-            assert p[n] == pytest.approx(answer[n], abs=1e-4)
-
-    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
-    def test_incomplete_personalization(self, alg):
-        G = nx.complete_graph(4)
-        personalize = {3: 1}
-        answer = {
-            0: 0.22077931820379187,
-            1: 0.22077931820379187,
-            2: 0.22077931820379187,
-            3: 0.3376620453886241,
-        }
-        p = alg(G, alpha=0.85, personalization=personalize)
-        for n in G:
-            assert p[n] == pytest.approx(answer[n], abs=1e-4)
-
-    def test_dangling_matrix(self):
-        """
-        Tests that the google_matrix doesn't change except for the dangling
-        nodes.
-        """
-        G = self.G
-        dangling = self.dangling_edges
-        dangling_sum = sum(dangling.values())
-        M1 = nx.google_matrix(G, personalization=dangling)
-        M2 = nx.google_matrix(G, personalization=dangling, dangling=dangling)
-        for i in range(len(G)):
-            for j in range(len(G)):
-                if i == self.dangling_node_index and (j + 1) in dangling:
-                    assert M2[i, j] == pytest.approx(
-                        dangling[j + 1] / dangling_sum, abs=1e-4
-                    )
-                else:
-                    assert M2[i, j] == pytest.approx(M1[i, j], abs=1e-4)
-
-    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python, _pagerank_numpy))
-    def test_dangling_pagerank(self, alg):
-        pr = alg(self.G, dangling=self.dangling_edges)
-        for n in self.G:
-            assert pr[n] == pytest.approx(self.G.dangling_pagerank[n], abs=1e-4)
-
-    def test_empty(self):
-        G = nx.Graph()
-        assert nx.pagerank(G) == {}
-        assert _pagerank_python(G) == {}
-        assert _pagerank_numpy(G) == {}
-        assert nx.google_matrix(G).shape == (0, 0)
-
-    @pytest.mark.parametrize("alg", (nx.pagerank, _pagerank_python))
-    def test_multigraph(self, alg):
-        G = nx.MultiGraph()
-        G.add_edges_from([(1, 2), (1, 2), (1, 2), (2, 3), (2, 3), ("3", 3), ("3", 3)])
-        answer = {
-            1: 0.21066048614468322,
-            2: 0.3395308825985378,
-            3: 0.28933951385531687,
-            "3": 0.16046911740146227,
-        }
-        p = alg(G)
-        for n in G:
-            assert p[n] == pytest.approx(answer[n], abs=1e-4)
-
-
-class TestPageRankScipy(TestPageRank):
-    def test_scipy_pagerank(self):
-        G = self.G
-        p = _pagerank_scipy(G, alpha=0.9, tol=1.0e-08)
-        for n in G:
-            assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
-        personalize = {n: random.random() for n in G}
-        p = _pagerank_scipy(G, alpha=0.9, tol=1.0e-08, personalization=personalize)
-
-        nstart = {n: random.random() for n in G}
-        p = _pagerank_scipy(G, alpha=0.9, tol=1.0e-08, nstart=nstart)
-        for n in G:
-            assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
-
-    def test_scipy_pagerank_max_iter(self):
-        with pytest.raises(nx.PowerIterationFailedConvergence):
-            _pagerank_scipy(self.G, max_iter=0)
-
-    def test_dangling_scipy_pagerank(self):
-        pr = _pagerank_scipy(self.G, dangling=self.dangling_edges)
-        for n in self.G:
-            assert pr[n] == pytest.approx(self.G.dangling_pagerank[n], abs=1e-4)
-
-    def test_empty_scipy(self):
-        G = nx.Graph()
-        assert _pagerank_scipy(G) == {}