scikit-network 0.33.3__cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

sknetwork/data/test_graphs.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Nov 29, 2018
+@author: Quentin Lutz <qlutz@enst.fr>
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <tbonald@enst.fr>
+"""
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils import directed2undirected
+
+
+def test_digraph():
+    """Simple directed graph, used for testing.
+    10 nodes, 12 edges
+    """
+    row = np.array([0, 1, 1, 3, 4, 6, 6, 6, 6, 7, 8, 8, 9])
+    col = np.array([1, 4, 3, 2, 5, 4, 5, 7, 1, 9, 9, 2, 9])
+    data = np.array([1, 1, 2.5, 1, 2, 2, 1, 2, 2, 1.5, 2, 1, 2])
+    return sparse.csr_matrix((data, (row, col)), shape=(10, 10))
+
+
+def test_graph():
+    """Simple undirected graph, used for testing.
+    10 nodes, 12 edges.
+    """
+    return directed2undirected(test_digraph(), weighted=True)
+
+
+def test_bigraph():
+    """Simple bipartite graph, used for testing.
+    6 + 8 nodes, 9 edges.
+    """
+    row = np.array([0, 1, 1, 2, 2, 3, 4, 5, 5])
+    col = np.array([1, 2, 3, 1, 0, 4, 7, 5, 6])
+    data = np.array([1, 2.5, 1, 2, 2, 1.5, 1, 2, 3])
+    return sparse.csr_matrix((data, (row, col)), shape=(6, 8))
+
+
+def test_disconnected_graph():
+    """Simple disconnected undirected graph, used for testing.
+    10 nodes, 10 edges.
+    """
+    row = np.array([1, 2, 3, 4, 6, 6, 6, 7, 8, 9])
+    col = np.array([1, 3, 2, 5, 4, 5, 7, 9, 9, 9])
+    data = np.array([1, 2.5, 1, 2, 2, 1, 2, 2, 1.5, 2])
+    adjacency = sparse.csr_matrix((data, (row, col)), shape=(10, 10))
+    return directed2undirected(adjacency)
+
+
+def test_bigraph_disconnect():
+    """Simple disconnected bipartite graph, used for testing.
+    6 + 8 nodes, 9 edges.
+    """
+    row = np.array([1, 1, 1, 2, 2, 3, 5, 4, 5])
+    col = np.array([1, 2, 3, 1, 3, 4, 7, 7, 6])
+    data = np.array([1, 2.5, 1, 2, 2, 1.5, 3, 0, 1])
+    return sparse.csr_matrix((data, (row, col)), shape=(6, 8))
+
+
+def test_graph_bool():
+    """Simple undirected graph with boolean entries, used for testing (10 nodes, 10 edges)."""
+    adjacency = test_graph()
+    adjacency.data = adjacency.data.astype(bool)
+    return adjacency
+
+
+def test_clique():
+    """Clique graph, used for testing (10 nodes, 45 edges).
+    """
+    n = 10
+    adjacency = sparse.csr_matrix(np.ones((n, n), dtype=bool))
+    adjacency.setdiag(0)
+    adjacency.eliminate_zeros()
+    return adjacency
+
+
+def test_graph_empty():
+    """Empty graph, used for testing (10 nodes, 0 edges).
+    """
+    return sparse.csr_matrix((10, 10), dtype=bool)

sknetwork/data/tests/__init__.py

@@ -0,0 +1 @@
+"""tests module"""

sknetwork/data/tests/test_API.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for data API"""
+
+import tempfile
+import unittest
+import warnings
+
+from sknetwork.data.load import *
+from sknetwork.data.toy_graphs import *
+from sknetwork.data import Dataset
+
+
+class TestDataAPI(unittest.TestCase):
+
+    def test_toy_graphs(self):
+        toy_graphs = [karate_club, painters, bow_tie, house, miserables]
+        for toy_graph in toy_graphs:
+            self.assertEqual(type(toy_graph()), sparse.csr_matrix)
+            self.assertEqual(type(toy_graph(metadata=True)), Dataset)
+
+    def test_load(self):
+        tmp_data_dir = tempfile.gettempdir() + '/stub'
+        clear_data_home(tmp_data_dir)
+        try:
+            graph = load_netset('stub', tmp_data_dir)
+            self.assertEqual(type(graph), Dataset)
+        except URLError:  # pragma: no cover
+            warnings.warn('Could not reach NetSet. Corresponding test has not been performed.', RuntimeWarning)
+            return

sknetwork/data/tests/test_base.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+"""tests for dataset"""
+
+import unittest
+
+from sknetwork.data.base import Dataset
+
+
+class TestDataset(unittest.TestCase):
+
+    def test(self):
+        dataset = Dataset(name='dataset')
+        self.assertEqual(dataset.name, 'dataset')
+        self.assertEqual(dataset['name'], 'dataset')

sknetwork/data/tests/test_load.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for load.py"""
+
+import tempfile
+import unittest
+import warnings
+
+import numpy as np
+
+from sknetwork.data.load import load_netset, load_konect, clear_data_home, save, load
+from sknetwork.data.toy_graphs import house, star_wars
+from sknetwork.data.timeout import TimeOut
+
+
+class TestLoader(unittest.TestCase):
+
+    def setUp(self):
+        self.data_home = tempfile.gettempdir() + '/data'
+
+    def test_netset(self):
+        clear_data_home(self.data_home)
+        try:
+            graph = load_netset('stub', self.data_home)
+        except:  # pragma: no cover
+            warnings.warn('Could not reach the NetSet collection. Corresponding test has not been performed.',
+                          RuntimeWarning)
+            return
+        n = 2
+        self.assertEqual(graph.adjacency.shape, (n, n))
+        self.assertEqual(len(graph.names), n)
+        clear_data_home(self.data_home)
+
+    def test_invalid_netset(self):
+        try:
+            with self.assertRaises(ValueError):
+                load_netset('junk', self.data_home)
+        except:  # pragma: no cover
+            warnings.warn('Could not reach the NetSet collection. Corresponding test has not been performed.',
+                          RuntimeWarning)
+            return
+        load_netset()
+
+    def test_konect(self):
+        try:
+            with TimeOut(2):
+                data = load_konect('moreno_crime', self.data_home)
+        except (TimeoutError, RuntimeError):  # pragma: no cover
+            warnings.warn('Could not reach Konect. Corresponding test has not been performed.', RuntimeWarning)
+            return
+        self.assertEqual(data.biadjacency.shape[0], 829)
+        self.assertEqual(data.name.shape[0], 829)
+
+        # load from bundle
+        data = load_konect('moreno_crime', self.data_home)
+        self.assertEqual(data.biadjacency.shape[0], 829)
+
+        try:
+            with TimeOut(2):
+                data = load_konect('ego-facebook', self.data_home)
+        except (TimeoutError, RuntimeError):  # pragma: no cover
+            warnings.warn('Could not reach Konect. Corresponding test has not been performed.', RuntimeWarning)
+            return
+        self.assertEqual(data.adjacency.shape[0], 2888)
+        clear_data_home(self.data_home)
+
+    def test_invalid_konect(self):
+        try:
+            with TimeOut(4):
+                with self.assertRaises(ValueError):
+                    load_konect('junk', self.data_home)
+                with self.assertRaises(ValueError):
+                    load_konect('', self.data_home)
+        except (TimeoutError, RuntimeError):  # pragma: no cover
+            warnings.warn('Could not reach Konect. Corresponding test has not been performed.', RuntimeWarning)
+            return
+
+    def test_save_load(self):
+        data = house()
+        save(self.data_home + '/house', data)
+        loaded_data = load(self.data_home + '/house')
+        self.assertTrue(np.allclose(data.data, loaded_data.adjacency.data))
+
+        data = star_wars()
+        save(self.data_home + '/star_wars', data)
+        loaded_data = load(self.data_home + '/star_wars')
+        self.assertTrue(np.allclose(data.data, loaded_data.biadjacency.data))
+
+        data = star_wars(metadata=True)
+        save(self.data_home + '/star_wars', data)
+        loaded_data = load(self.data_home + '/star_wars')
+        self.assertTrue(np.allclose(data.biadjacency.data, loaded_data.biadjacency.data))
+        self.assertEqual(data.names_col[0], loaded_data.names_col[0])
+
+

sknetwork/data/tests/test_models.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+# tests for toy_graphs.py
+"""authors:
+Thomas Bonald <bonald@enst.fr>
+Quentin Lutz <qlutz@enst.fr>"""
+import unittest
+
+from sknetwork.data.models import *
+
+
+class TestModels(unittest.TestCase):
+
+    def test_shape(self):
+        n = 10
+        for model in [linear_graph, linear_digraph, cyclic_graph, cyclic_digraph, watts_strogatz]:
+            adjacency = model(n)
+            graph = model(n, metadata=True)
+            self.assertEqual(adjacency.shape, (n, n))
+            self.assertEqual(graph.adjacency.shape, (n, n))
+            if hasattr(graph, 'position'):
+                self.assertEqual(graph.position.shape, (n, 2))
+
+        adjacency = star(n)
+        self.assertEqual(adjacency.shape, (n+1, n+1))
+        graph = star(n, metadata=True)
+        self.assertTrue(hasattr(graph, 'position'))
+
+        adjacency = erdos_renyi(n)
+        self.assertEqual(adjacency.shape, (n, n))
+        adjacency = erdos_renyi(n, directed=True, self_loops=True, seed=4)
+        self.assertEqual(adjacency.shape, (n, n))
+
+        adjacency = albert_barabasi(n, 2)
+        self.assertEqual(adjacency.shape, (n, n))
+
+        n1, n2 = 4, 6
+        n = n1 * n2
+        adjacency = grid(n1, n2)
+        self.assertEqual(adjacency.shape, (n, n))
+        graph = grid(n1, n2, metadata=True)
+        self.assertEqual(graph.adjacency.shape, (n, n))
+        if hasattr(graph, 'position'):
+            self.assertEqual(graph.position.shape, (n, 2))
+
+    def test_block_model(self):
+        graph = block_model(np.array([4, 5, 6]), np.array([0.5, 0.3, 0.2]), 0.1, metadata=True)
+        adjacency = graph.adjacency
+        labels = graph.labels
+        self.assertEqual(adjacency.shape, (15, 15))
+        self.assertEqual(len(labels), 15)
+        adjacency = block_model(np.array([4, 5, 6]), np.array([0.5, 0.3, 0.2]), 0.1, directed=True, self_loops=True)
+        self.assertEqual(adjacency.shape, (15, 15))

sknetwork/data/tests/test_parse.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""tests for parse.py"""
+
+import unittest
+from os import remove
+
+import numpy as np
+
+from sknetwork.data import parse
+
+
+class TestParser(unittest.TestCase):
+
+    def test_unlabeled_unweighted(self):
+        self.stub_data_1 = 'stub_1.txt'
+        with open(self.stub_data_1, "w") as text_file:
+            text_file.write('%stub\n1 3\n4 5\n0 2')
+        adjacency = parse.from_csv(self.stub_data_1)
+        self.assertTrue((adjacency.indices == [2, 3, 0, 1, 5, 4]).all())
+        self.assertTrue((adjacency.indptr == [0, 1, 2, 3, 4, 5, 6]).all())
+        self.assertTrue((adjacency.data == [1, 1, 1, 1, 1, 1]).all())
+        adjacency = parse.from_csv(self.stub_data_1, shape=(7, 7))
+        self.assertTrue((adjacency.shape == (7, 7)))
+        biadjacency = parse.from_csv(self.stub_data_1, bipartite=True, shape=(7, 9))
+        self.assertTrue((biadjacency.shape == (7, 9)))
+        remove(self.stub_data_1)
+
+    def test_labeled_weighted(self):
+        self.stub_data_2 = 'stub_2.txt'
+        with open(self.stub_data_2, "w") as text_file:
+            text_file.write('%stub\nf, e, 5\na, d, 6\nc, b, 1')
+        graph = parse.from_csv(self.stub_data_2)
+        adjacency = graph.adjacency
+        names = graph.names
+        self.assertTrue((adjacency.indices == [4, 3, 5, 1, 0, 2]).all())
+        self.assertTrue((adjacency.indptr == [0, 1, 2, 3, 4, 5, 6]).all())
+        self.assertTrue((adjacency.data == [1, 6, 5, 6, 1, 5]).all())
+        self.assertTrue((names == [' b', ' d', ' e', 'a', 'c', 'f']).all())
+
+        remove(self.stub_data_2)
+
+    def test_auto_reindex(self):
+        self.stub_data_4 = 'stub_4.txt'
+        with open(self.stub_data_4, "w") as text_file:
+            text_file.write('%stub\n14 31\n42 50\n0 12')
+        graph = parse.from_csv(self.stub_data_4, reindex=True)
+        adjacency = graph.adjacency
+        names = graph.names
+        self.assertTrue((adjacency.data == [1, 1, 1, 1, 1, 1]).all())
+        self.assertTrue((names == [0, 12, 14, 31, 42, 50]).all())
+        remove(self.stub_data_4)
+
+    def test_wrong_format(self):
+        self.stub_data_3 = 'stub_3.txt'
+        with open(self.stub_data_3, "w") as text_file:
+            text_file.write('%stub\n1 3 a\n4 5 b\n0 2 e')
+        self.assertRaises(ValueError, parse.from_csv, self.stub_data_3)
+        remove(self.stub_data_3)
+
+    def test_graphml_basic(self):
+        self.stub_data_5 = 'stub_5.graphml'
+        with open(self.stub_data_5, "w") as graphml_file:
+            graphml_file.write("""<?xml version='1.0' encoding='utf-8'?>
+                                    <graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+                                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                                    xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+                                    http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+                                    <key id="d0" for="edge" attr.name="weight" attr.type="int"/>
+                                    <graph edgedefault="directed">
+                                    <node id="node1"/>
+                                    <node id="node2"/>
+                                    <edge source="node1" target="node2">
+                                      <data key="d0">1</data>
+                                    </edge></graph></graphml>""")
+        graph = parse.from_graphml(self.stub_data_5)
+        adjacency = graph.adjacency
+        names = graph.names
+        self.assertTrue((adjacency.indices == [1]).all())
+        self.assertTrue((adjacency.indptr == [0, 1, 1]).all())
+        self.assertTrue((adjacency.data == [1]).all())
+        self.assertTrue((names == ['node1', 'node2']).all())
+        remove(self.stub_data_5)
+
+    def test_graphml_refined(self):
+        self.stub_data_6 = 'stub_6.graphml'
+        with open(self.stub_data_6, "w") as graphml_file:
+            graphml_file.write("""<?xml version='1.0' encoding='utf-8'?>
+                                    <graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+                                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                                    xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+                                    http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+                                      <desc>Some file</desc>
+                                    <key id="d0" for="edge" attr.name="weight" attr.type="int"/>
+                                    <key id="d1" for="node" attr.name="color" attr.type="string">
+                                      <desc>Color</desc>
+                                      <default>blue</default>
+                                    </key>
+                                    <key id="d2" for="edge" attr.name="distance" attr.type="double">
+                                      <desc>Distance</desc>
+                                      <default>1.5</default>
+                                    </key>
+                                    <graph edgedefault="undirected" parse.nodeids="canonical"
+                                    parse.nodes="3" parse.edges="4">
+                                    <node id="n0">
+                                      <data key="d1">green</data>
+                                    </node>
+                                    <node id="n1"/>
+                                    <node id="n2"/>
+                                    <edge source="n0" target="n1">
+                                      <data key="d0">1</data>
+                                      <data key="d2">7.2</data>
+                                    </edge>
+                                    <edge source="n1" target="n2" directed='true'>
+                                      <data key="d0">1</data>
+                                    </edge>
+                                    <edge source="n0" target="n2" directed='false'>
+                                      <data key="d0">1</data>
+                                    </edge></graph></graphml>""")
+        graph = parse.from_graphml(self.stub_data_6)
+        adjacency = graph.adjacency
+        colors = graph.node_attribute.color
+        distances = graph.edge_attribute.distance
+        self.assertTrue((adjacency.indices == [1, 2, 0, 2, 0]).all())
+        self.assertTrue((adjacency.indptr == [0, 2, 4, 5]).all())
+        self.assertTrue((adjacency.data == [1, 1, 1, 1, 1]).all())
+        self.assertTrue((colors == ['green', 'blue', 'blue']).all())
+        self.assertTrue((distances == [7.2, 7.2, 1.5, 1.5, 1.5]).all())
+        self.assertEqual(graph.meta.description, 'Some file')
+        self.assertEqual(graph.meta.attributes.node.color, 'Color')
+        self.assertEqual(graph.meta.attributes.edge.distance, 'Distance')
+        remove(self.stub_data_6)
+
+    def test_no_graphml(self):
+        self.stub_data_7 = 'stub_7.graphml'
+        with open(self.stub_data_7, "w") as graphml_file:
+            graphml_file.write("""<?xml version='1.0' encoding='utf-8'?>
+                                    <graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+                                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                                    xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+                                    http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+                                    <key id="d0" for="edge" attr.name="weight" attr.type="int"/>
+                                    </graphml>""")
+        self.assertRaises(ValueError, parse.from_graphml, self.stub_data_7)
+        remove(self.stub_data_7)
+
+    def test_csv_adjacency(self):
+        self.stub_data_8 = 'stub_8.txt'
+        with open(self.stub_data_8, "w") as text_file:
+            text_file.write('%stub\n2\n3\n0\n1\n5\n4')
+        adjacency = parse.from_csv(self.stub_data_8)
+        self.assertTupleEqual(adjacency.shape, (6, 6))
+        self.assertTrue((adjacency.indices == [2, 3, 0, 1, 5, 4]).all())
+        self.assertTrue((adjacency.indptr == [0, 1, 2, 3, 4, 5, 6]).all())
+        self.assertTrue((adjacency.data == [2, 2, 2, 2, 2, 2]).all())
+        graph = parse.from_csv(self.stub_data_8, matrix_only=False)
+        adjacency = graph.adjacency
+        self.assertTupleEqual(adjacency.shape, (6, 6))
+        remove(self.stub_data_8)
+        # without comment line
+        self.stub_data_8 = 'stub_8.txt'
+        with open(self.stub_data_8, "w") as text_file:
+            text_file.write('2\n3\n0\n1\n5\n4')
+        adjacency = parse.from_csv(self.stub_data_8)
+        self.assertTupleEqual(adjacency.shape, (6, 6))
+        remove(self.stub_data_8)
+
+    def test_csv_bipartite(self):
+        self.stub_data_9 = 'stub_9.txt'
+        with open(self.stub_data_9, "w") as text_file:
+            text_file.write('#stub\n1 3\n4 5\n0 3')
+        graph = parse.from_csv(self.stub_data_9, bipartite=True, reindex=True)
+        biadjacency = graph.biadjacency
+        self.assertTrue((biadjacency.indices == [0, 0, 1]).all())
+        self.assertTrue((biadjacency.indptr == [0, 1, 2, 3]).all())
+        self.assertTrue((biadjacency.data == [1, 1, 1]).all())
+        biadjacency = parse.from_csv(self.stub_data_9, bipartite=True)
+        self.assertTrue(biadjacency.shape == (5, 6))
+        remove(self.stub_data_9)
+
+    def test_edge_list(self):
+        edge_list_1 = [('Alice', 'Bob'), ('Carol', 'Alice')]
+        graph = parse.from_edge_list(edge_list_1)
+        adjacency = graph.adjacency
+        names = graph.names
+        self.assertTrue((names == ['Alice', 'Bob', 'Carol']).all())
+        self.assertTupleEqual(adjacency.shape, (3, 3))
+        self.assertTrue((adjacency.indptr == [0, 2, 3, 4]).all())
+        self.assertTrue((adjacency.indices == [1, 2, 0, 0]).all())
+        self.assertTrue((adjacency.data == [1, 1, 1, 1]).all())
+
+        edge_list_2 = [('Alice', 'Bob', 4), ('Carol', 'Alice', 6)]
+        graph = parse.from_edge_list(edge_list_2)
+        adjacency = graph.adjacency
+        names = graph.names
+        self.assertTrue((names == ['Alice', 'Bob', 'Carol']).all())
+        self.assertTupleEqual(adjacency.shape, (3, 3))
+        self.assertTrue((adjacency.indptr == [0, 2, 3, 4]).all())
+        self.assertTrue((adjacency.indices == [1, 2, 0, 0]).all())
+        self.assertTrue((adjacency.data == [4, 6, 4, 6]).all())
+
+        edge_list_3 = [('Alice', 'Bob'), ('Carol', 'Alice'), ('Alice', 'Bob')]
+        graph = parse.from_edge_list(edge_list_3, directed=True)
+        adjacency = graph.adjacency
+        names = graph.names
+        self.assertTrue((names == ['Alice', 'Bob', 'Carol']).all())
+        self.assertTupleEqual(adjacency.shape, (3, 3))
+        self.assertTrue((adjacency.data == [2, 1]).all())
+
+        adjacency = parse.from_edge_list(edge_list_3, directed=True, matrix_only=True)
+        self.assertTupleEqual(adjacency.shape, (3, 3))
+
+        graph = parse.from_edge_list(edge_list_3, directed=True, weighted=False)
+        adjacency = graph.adjacency
+        self.assertTrue((adjacency.data == [1, 1]).all())
+
+        edge_list = np.array([[0, 1, 1], [1, 2, 2]])
+        adjacency = parse.from_edge_list(edge_list, weighted=True, matrix_only=True)
+        self.assertTrue((adjacency.data == np.array([1, 1, 2, 2])).all())
+
+        edge_list = np.array([[0, 1, 2], [0, 1, 1], [1, 2, 1]])
+        adjacency = parse.from_edge_list(edge_list, weighted=True, matrix_only=True, sum_duplicates=False)
+        self.assertTrue(adjacency.data[0] == 2)
+
+    def test_adjacency_list(self):
+        edge_list_4 = {'Alice': ['Bob', 'Carol'], 'Bob': ['Carol']}
+        graph = parse.from_adjacency_list(edge_list_4, directed=True)
+        adjacency = graph.adjacency
+        names = graph.names
+        self.assertTrue((names == ['Alice', 'Bob', 'Carol']).all())
+        self.assertTupleEqual(adjacency.shape, (3, 3))
+        self.assertTrue((adjacency.data == [1, 1, 1]).all())
+
+        edge_list_5 = [[0, 1, 2], [2, 3]]
+        adjacency = parse.from_adjacency_list(edge_list_5, directed=True)
+        self.assertTupleEqual(adjacency.shape, (4, 4))
+        self.assertTrue((adjacency.data == [1, 1, 1, 1, 1]).all())
+
+        self.assertRaises(TypeError, parse.from_adjacency_list, {2, 3})
+
+    def test_bad_format_edge_list(self):
+        edge_list_2 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
+        self.assertRaises(ValueError, parse.from_edge_list, edge_list_2)
+        edge_list_3 = 'ab cd'
+        self.assertRaises(TypeError, parse.from_edge_list, edge_list_3)
+
+    def test_is_number(self):
+        self.assertTrue(parse.is_number(3))
+        self.assertFalse(parse.is_number('a'))
+

sknetwork/data/tests/test_test_graphs.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+# tests for test_graphs.py
+"""
+@author: Quentin Lutz <qlutz@enst.fr>
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <tbonald@enst.fr>
+"""
+import unittest
+
+from sknetwork.data.test_graphs import *
+
+
+class TestTestGraphs(unittest.TestCase):
+
+    def test_undirected(self):
+        adjacency = test_graph()
+        self.assertEqual(adjacency.shape, (10, 10))
+        adjacency = test_disconnected_graph()
+        self.assertEqual(adjacency.shape, (10, 10))
+
+    def test_directed(self):
+        adjacency = test_digraph()
+        self.assertEqual(adjacency.shape, (10, 10))
+
+    def test_bipartite(self):
+        biadjacency = test_bigraph()
+        self.assertEqual(biadjacency.shape, (6, 8))
+        biadjacency = test_bigraph_disconnect()
+        self.assertEqual(biadjacency.shape, (6, 8))

sknetwork/data/tests/test_toy_graphs.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+# tests for toy_graphs.py
+"""
+@author: Quentin Lutz <qlutz@enst.fr>
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Thomas Bonald <tbonald@enst.fr>
+"""
+import unittest
+
+from sknetwork.data.toy_graphs import *
+
+
+class TestToys(unittest.TestCase):
+
+    def test_undirected(self):
+        adjacency = house()
+        self.assertEqual(adjacency.shape, (5, 5))
+
+        dataset = house(metadata=True)
+        self.assertEqual(dataset.position.shape, (5, 2))
+
+        adjacency = bow_tie()
+        self.assertEqual(adjacency.shape, (5, 5))
+
+        dataset = bow_tie(metadata=True)
+        self.assertEqual(dataset.position.shape, (5, 2))
+
+        dataset = karate_club(True)
+        self.assertEqual(dataset.adjacency.shape, (34, 34))
+        self.assertEqual(len(dataset.labels), 34)
+
+        dataset = miserables(True)
+        self.assertEqual(dataset.adjacency.shape, (77, 77))
+        self.assertEqual(len(dataset.names), 77)
+
+    def test_directed(self):
+        adjacency = painters()
+        self.assertEqual(adjacency.shape, (14, 14))
+
+        adjacency = art_philo_science()
+        self.assertEqual(adjacency.shape, (30, 30))
+
+        dataset = painters(True)
+        self.assertEqual(dataset.adjacency.shape, (14, 14))
+        self.assertEqual(len(dataset.names), 14)
+
+        dataset = art_philo_science(True)
+        self.assertEqual(dataset.adjacency.shape, (30, 30))
+        self.assertEqual(len(dataset.names), 30)
+
+    def test_bipartite(self):
+        dataset = star_wars(True)
+        self.assertEqual(dataset.biadjacency.shape, (4, 3))
+        self.assertEqual(len(dataset.names), 4)
+        self.assertEqual(len(dataset.names_col), 3)
+
+        dataset = movie_actor(True)
+        self.assertEqual(dataset.biadjacency.shape, (15, 17))
+        self.assertEqual(len(dataset.names), 15)
+        self.assertEqual(len(dataset.names_col), 17)
+
+        dataset = hourglass(True)
+        self.assertEqual(dataset.biadjacency.shape, (2, 2))
+
+        dataset = art_philo_science(True)
+        self.assertEqual(dataset.biadjacency.shape, (30, 11))
+        self.assertEqual(len(dataset.names), 30)
+        self.assertEqual(len(dataset.names_col), 11)

sknetwork/data/timeout.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+import contextlib
+import signal
+import warnings
+
+
+class TimeOut(contextlib.ContextDecorator):
+    """
+    Timeout context manager/decorator.
+
+    Adapted from https://gist.github.com/TySkby/143190ad1b88c6115597c45f996b030c on 12/10/2020.
+
+    Examples
+    --------
+    >>> from time import sleep
+    >>> try:
+    ...     with TimeOut(1):
+    ...         sleep(10)
+    ... except TimeoutError:
+    ...     print("Function timed out")
+    Function timed out
+    """
+    def __init__(self, seconds: float):
+        self.seconds = seconds
+
+    def _timeout_handler(self, signum, frame):
+        raise TimeoutError("Code timed out.")
+
+    def __enter__(self):
+        if hasattr(signal, "SIGALRM"):
+            signal.signal(signal.SIGALRM, self._timeout_handler)
+            signal.alarm(self.seconds)
+        else:
+            warnings.warn("SIGALRM is unavailable on Windows. Timeouts are not functional.")
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if hasattr(signal, "SIGALRM"):
+            signal.alarm(0)