scikit-network 0.30.0__cp39-cp39-win_amd64.whl → 0.32.1__cp39-cp39-win_amd64.whl

sknetwork/linalg/push.pyx

@@ -1,7 +1,5 @@
 # distutils: language = c++
 # cython: language_level=3
-# cython: linetrace=True
-# distutils: define_macros=CYTHON_TRACE_NOGIL=1
 """
 Created on Mars 2021
 @author: Wenzhuo Zhao <wenzhuo.zhao@etu.sorbonne-universite.fr>

sknetwork/linalg/svd_solver.py

@@ -13,7 +13,7 @@ import numpy as np
 from scipy import sparse
 from scipy.sparse.linalg import svds
 
-from sknetwork.utils.base import Algorithm
+from sknetwork.base import Algorithm
 
 
 class SVDSolver(Algorithm, ABC):

sknetwork/linalg/tests/test_normalization.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on April 2020
+Created in April 2020
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 """
 
@@ -10,7 +10,7 @@ import unittest
 import numpy as np
 from scipy import sparse
 
-from sknetwork.linalg import normalize, CoNeighbor
+from sknetwork.linalg import normalize
 
 
 class TestNormalization(unittest.TestCase):
@@ -19,12 +19,10 @@ class TestNormalization(unittest.TestCase):
         n = 5
         mat1 = normalize(np.eye(n))
         mat2 = normalize(sparse.eye(n))
-        mat3 = normalize(CoNeighbor(mat2))
 
         x = np.random.randn(n)
         self.assertAlmostEqual(np.linalg.norm(mat1.dot(x) - x), 0)
         self.assertAlmostEqual(np.linalg.norm(mat2.dot(x) - x), 0)
-        self.assertAlmostEqual(np.linalg.norm(mat3.dot(x) - x), 0)
 
         mat1 = np.random.rand(n**2).reshape((n, n))
         mat2 = sparse.csr_matrix(mat1)
@@ -32,7 +30,5 @@ class TestNormalization(unittest.TestCase):
         mat2 = normalize(mat2, p=2)
         self.assertAlmostEqual(np.linalg.norm(mat1.dot(x) - mat2.dot(x)), 0)
 
-        with self.assertRaises(NotImplementedError):
-            normalize(mat3, p=2)
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(ValueError):
             normalize(mat1, p=3)

sknetwork/linalg/tests/test_operators.py

@@ -1,21 +1,21 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on Apr 2020
+Created in April 2020
 @author: Thomas Bonald <bonald@enst.fr>
 @author: Nathan de Lara <nathan.delara@polytechnique.org>
 """
 import unittest
 
 from sknetwork.data.test_graphs import *
-from sknetwork.linalg import Laplacian, Normalizer, CoNeighbor, normalize
+from sknetwork.linalg import Laplacian, Normalizer, CoNeighbor
 from sknetwork.linalg.basics import safe_sparse_dot
 
 
 class TestOperators(unittest.TestCase):
 
     def test_laplacian(self):
-        for adjacency in [test_graph(), test_graph_disconnect()]:
+        for adjacency in [test_graph(), test_disconnected_graph()]:
             n = adjacency.shape[1]
             # regular Laplacian
             laplacian = Laplacian(adjacency)
@@ -35,7 +35,7 @@ class TestOperators(unittest.TestCase):
             self.assertEqual(safe_sparse_dot(laplacian, np.ones(shape)).shape, shape)
 
     def test_normalizer(self):
-        for adjacency in [test_graph(), test_graph_disconnect()]:
+        for adjacency in [test_graph(), test_disconnected_graph()]:
             n_row, n_col = adjacency.shape
             # square matrix
             normalizer = Normalizer(adjacency)
@@ -53,10 +53,6 @@ class TestOperators(unittest.TestCase):
     def test_coneighbors(self):
         biadjacency = test_bigraph()
         operator = CoNeighbor(biadjacency)
-        transition = normalize(operator)
-        x = transition.dot(np.ones(transition.shape[1]))
-
-        self.assertAlmostEqual(np.linalg.norm(x - np.ones(operator.shape[0])), 0)
         operator.astype('float')
         operator.right_sparse_dot(sparse.eye(operator.shape[1], format='csr'))
 

sknetwork/linalg/tests/test_ppr.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""Tests for Louvain"""
+"""Tests for d-iteration"""
 import unittest
 
 import numpy as np

sknetwork/linkpred/base.py

@@ -7,8 +7,9 @@ Created in March 2022
 from abc import ABC
 
 import numpy as np
+from scipy import sparse
 
-from sknetwork.utils.base import Algorithm
+from sknetwork.base import Algorithm
 
 
 class BaseLinker(Algorithm, ABC):
@@ -23,7 +24,17 @@ class BaseLinker(Algorithm, ABC):
     def __init__(self):
         self.links_ = None
 
-    def fit_predict(self, *args, **kwargs) -> np.ndarray:
+    def predict(self) -> sparse.csr_matrix:
+        """Return the predicted links.
+
+        Returns
+        -------
+        links_ : sparse.csr_matrix
+            Link matrix.
+        """
+        return self.links_
+
+    def fit_predict(self, *args, **kwargs) -> sparse.csr_matrix:
         """Fit algorithm to data and return the links. Same parameters as the ``fit`` method.
 
         Returns

sknetwork/linkpred/nn.py

@@ -11,7 +11,7 @@ from scipy import sparse
 
 from sknetwork.linkpred.base import BaseLinker
 from sknetwork.embedding.base import BaseEmbedding
-from sknetwork.linalg.normalization import normalize
+from sknetwork.linalg.normalizer import normalize
 from sknetwork.utils.check import check_n_neighbors
 from sknetwork.utils.format import get_adjacency
 
@@ -23,11 +23,11 @@ class NNLinker(BaseLinker):
 
     Parameters
     ----------
-    n_neighbors :
+    n_neighbors : int
         Number of nearest neighbors. If ``None``, all nodes are considered.
-    threshold :
+    threshold : float
         Threshold on cosine similarity. Only links above this threshold are kept.
-    embedding_method :
+    embedding_method : :class:`BaseEmbedding`
         Embedding method used to represent nodes in vector space.
         If ``None`` (default), use identity.
 
@@ -95,9 +95,9 @@ class NNLinker(BaseLinker):
 
         Parameters
         ----------
-        input_matrix :
+        input_matrix : sparse.csr_matrix, np.ndarray
             Adjacency matrix or biadjacency matrix of the graph.
-        index :
+        index : np.ndarray
             Index of source nodes to consider. If ``None``, the links are predicted for all nodes.
 
         Returns

sknetwork/log.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in December 2019
+@author: Quentin Lutz <qlutz@enst.fr>
+"""
+
+
+class Log:
+    """Log class for verbosity features"""
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.log = ''
+
+    def print_log(self, *args):
+        """Fill log with text."""
+        if self.verbose:
+            print(*args)
+        self.log += ' '.join(map(str, args)) + '\n'

sknetwork/path/__init__.py

@@ -1,4 +1,5 @@
 """Path module"""
-from sknetwork.path.metrics import get_diameter, get_eccentricity, get_radius
-from sknetwork.path.search import breadth_first_search, depth_first_search
-from sknetwork.path.shortest_path import get_distances, get_shortest_path
+from sknetwork.path.dag import get_dag
+from sknetwork.path.distances import get_distances
+from sknetwork.path.search import breadth_first_search
+from sknetwork.path.shortest_path import get_shortest_path

sknetwork/path/dag.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in May 2023
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Iterable, Optional, Union
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.path.distances import get_distances
+from sknetwork.utils.check import check_format, check_square
+
+
+def get_dag(adjacency: sparse.csr_matrix, source: Optional[Union[int, Iterable]] = None,
+            order: Optional[np.ndarray] = None) -> sparse.csr_matrix:
+    """Get a Directed Acyclic Graph (DAG) from a graph.
+    If the order is specified, keep only edges i -> j such that 0 <= order[i] < order[j].
+    If the source is specified, use the distances from this source node (or set of source nodes) as order.
+    If neither the order nor the source is specified, use the node indices as order.
+
+    Parameters
+    ----------
+    adjacency :
+        Adjacency matrix of the graph.
+    source :
+        Source node (or set of source nodes).
+    order :
+        Order of nodes. Negative values ignored.
+
+    Returns
+    -------
+    dag :
+        Adjacency matrix of the directed acyclic graph.
+    """
+    adjacency = check_format(adjacency, allow_empty=True)
+    check_square(adjacency)
+
+    if order is None:
+        if source is None:
+            order = np.arange(adjacency.shape[0])
+        else:
+            order = get_distances(adjacency, source)
+
+    dag = adjacency.astype(bool).tocoo()
+    for value in np.unique(order):
+        if value < 0:
+            dag.data[order[dag.row] == value] = 0
+        else:
+            dag.data[(order[dag.row] == value) & (order[dag.col] <= value)] = 0
+    dag.eliminate_zeros()
+
+    return dag.tocsr()

sknetwork/path/distances.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in May 2023
+@author: Thomas Bonald <bonald@enst.fr>
+"""
+from typing import Iterable, Optional, Union, Tuple
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.format import get_adjacency
+
+
+def get_distances(input_matrix: sparse.csr_matrix, source: Optional[Union[int, Iterable]] = None,
+                  source_row: Optional[Union[int, Iterable]] = None,
+                  source_col: Optional[Union[int, Iterable]] = None, transpose: bool = False,
+                  force_bipartite: bool = False) \
+        -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]]:
+    """Get the distances from a source (or a set of sources) in number of hops.
+
+    Parameters
+    ----------
+    input_matrix :
+        Adjacency matrix or biadjacency matrix of the graph.
+    source :
+        If an integer, index of the source node.
+        If a list or array, indices of source nodes (the shortest distances to one of these nodes is returned).
+    source_row, source_col :
+        For bipartite graphs, index of source nodes on rows and columns.
+        The parameter source_row is an alias for source (at least one of them must be ``None``).
+    transpose :
+        If ``True``, transpose the input matrix.
+    force_bipartite :
+        If ``True``, consider the input matrix as the biadjacency matrix of a bipartite graph.
+        Set to ``True`` is the parameters source_row or source_col re specified.
+
+    Returns
+    -------
+    distances : np.ndarray of shape (n_nodes,)
+        Vector of distances from source (distance = -1 if no path exists from the source).
+        For a bipartite graph, two vectors are returned, one for the rows and one for the columns.
+
+    Examples
+    --------
+    >>> from sknetwork.data import cyclic_digraph
+    >>> adjacency = cyclic_digraph(3)
+    >>> get_distances(adjacency, source=0)
+    array([0, 1, 2])
+    >>> get_distances(adjacency, source=[0, 2])
+    array([0, 1, 0])
+    """
+    if transpose:
+        matrix = sparse.csr_matrix(input_matrix.T)
+    else:
+        matrix = input_matrix
+    if source_row is not None or source_col is not None:
+        force_bipartite = True
+    adjacency, bipartite = get_adjacency(matrix, force_bipartite=force_bipartite, allow_empty=True)
+    adjacency_transpose = adjacency.astype(bool).T.tocsr()
+    n_row, n_col = matrix.shape
+    n_nodes = adjacency.shape[0]
+
+    mask = np.zeros(n_nodes, dtype=bool)
+    if bipartite:
+        if source is not None:
+            if source_row is not None:
+                raise ValueError('Only one of the parameters source and source_row can be specified.')
+            source_row = source
+        if source_row is None and source_col is None:
+            raise ValueError('At least one of the parameters source_row or source_col must be specified.')
+        if source_row is not None:
+            mask[source_row] = 1
+        if source_col is not None:
+            mask[n_row + np.array(source_col)] = 1
+    else:
+        if source is None:
+            raise ValueError('The parameter source must be specified.')
+        mask[source] = 1
+
+    distances = -np.ones(n_nodes, dtype=int)
+    distances[mask] = 0
+
+    distance = 0
+    reach = mask
+
+    while 1:
+        distance += 1
+        mask = adjacency_transpose.dot(reach).astype(bool) & ~reach
+        if np.sum(mask) == 0:
+            break
+        distances[mask] = distance
+        reach |= mask
+
+    if bipartite:
+        return distances[:n_row], distances[n_row:]
+    else:
+        return distances

sknetwork/path/search.py

@@ -1,65 +1,31 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on Jul 24, 2019
+Created in May 2023
 """
 import numpy as np
 from scipy import sparse
 
-from sknetwork.utils.check import is_symmetric
+from sknetwork.path.distances import get_distances
 
 
-def breadth_first_search(adjacency: sparse.csr_matrix, source: int, return_predecessors: bool = True):
-    """Breadth-first ordering starting with specified node.
-
-    Based on SciPy (scipy.sparse.csgraph.breadth_first_order)
+def breadth_first_search(adjacency: sparse.csr_matrix, source: int):
+    """Breadth-first ordering starting from some node.
 
     Parameters
     ----------
     adjacency :
-        The adjacency matrix of the graph
+        Adjacency matrix of the graph.
     source : int
-        The node from which to start the ordering
-    return_predecessors : bool
-        If ``True``, the size predecessor matrix is returned
-
-    Returns
-    -------
-    node_array : np.ndarray
-        The breadth-first list of nodes, starting with specified node. The length of node_array is the number of nodes
-        reachable from the specified node.
-    predecessors : np.ndarray
-        Returned only if ``return_predecessors == True``. The list of predecessors of each node in a breadth-first tree.
-        If node ``i`` is in the tree, then its parent is given by ``predecessors[i]``. If node ``i`` is not in the tree
-        (and for the parent node) then ``predecessors[i] = -9999``.
-    """
-    directed = not is_symmetric(adjacency)
-    return sparse.csgraph.breadth_first_order(adjacency, source, directed, return_predecessors)
-
-
-def depth_first_search(adjacency: sparse.csr_matrix, source: int, return_predecessors: bool = True):
-    """Depth-first ordering starting with specified node.
-
-    Based on SciPy (scipy.sparse.csgraph.depth_first_order)
-
-    Parameters
-    ----------
-    adjacency :
-        The adjacency matrix of the graph
-    source :
-        The node from which to start the ordering
-    return_predecessors:
-        If ``True``, the size predecessor matrix is returned
+        Source node.
 
     Returns
     -------
-    node_array : np.ndarray
-        The depth-first list of nodes, starting with specified node. The length of node_array is the number of nodes
-        reachable from the specified node.
-    predecessors : np.ndarray
-        Returned only if ``return_predecessors == True``. The list of predecessors of each node in a depth-first tree.
-        If node ``i`` is in the tree, then its parent is given by ``predecessors[i]``. If node ``i`` is not in the tree
-        (and for the parent node) then ``predecessors[i] = -9999``.
+    index : np.ndarray
+        Node index corresponding to the breadth-first-search from the source.
+        The length of the vector is the number of nodes reachable from the source.
     """
-    directed = not is_symmetric(adjacency)
-    return sparse.csgraph.depth_first_order(adjacency, source, directed, return_predecessors)
+    distances = get_distances(adjacency, source)
+    indices = np.argsort(distances)
+    n = np.sum(distances < 0)
+    return indices[n:]

sknetwork/path/shortest_path.py

@@ -1,186 +1,61 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Created on November 12, 2019
-@author: Quentin Lutz <qlutz@enst.fr>
+Created in May 2023
+@author: Thomas Bonald <bonald@enst.fr>
 """
-from functools import partial
-from multiprocessing import Pool
-from typing import Optional, Union, Iterable
+from typing import Iterable, Optional, Union, Tuple
 
 import numpy as np
 from scipy import sparse
 
-from sknetwork.utils.check import check_n_jobs, is_symmetric
+from sknetwork.path.dag import get_dag
+from sknetwork.utils.format import bipartite2undirected
+from sknetwork.path.distances import get_distances
 
 
-def get_distances(adjacency: sparse.csr_matrix, sources: Optional[Union[int, Iterable]] = None, method: str = 'D',
-                  return_predecessors: bool = False, unweighted: bool = False, n_jobs: Optional[int] = None):
-    """Compute distances between nodes.
-
-    * Graphs
-    * Digraphs
-
-
-    Based on SciPy (scipy.sparse.csgraph.shortest_path)
+def get_shortest_path(input_matrix: sparse.csr_matrix, source: Optional[Union[int, Iterable]] = None,
+                      source_row: Optional[Union[int, Iterable]] = None,
+                      source_col: Optional[Union[int, Iterable]] = None, force_bipartite: bool = False) \
+        -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]]:
+    """Get the shortest paths from a source (or a set of sources) in number of hops.
 
     Parameters
     ----------
-    adjacency :
-        The adjacency matrix of the graph
-    sources :
-        If specified, only compute the paths for the points at the given indices. Will not work with ``method =='FW'``.
-    method :
-        The method to be used.
-
-        * ``'D'`` (Dijkstra),
-        * ``'BF'`` (Bellman-Ford),
-        * ``'J'`` (Johnson).
-    return_predecessors :
-        If ``True``, the size predecessor matrix is returned
-    unweighted :
-        If ``True``, the weights of the edges are ignored
-    n_jobs :
-        If an integer value is given, denotes the number of workers to use (-1 means the maximum number will be used).
-        If ``None``, no parallel computations are made.
+    input_matrix :
+        Adjacency matrix or biadjacency matrix of the graph.
+    source :
+        If an integer, index of the source node.
+        If a list, indices of source nodes (the shortest distances to one of these nodes in returned).
+    source_row, source_col :
+        For bipartite graphs, index of source nodes on rows and columns.
+        The parameter source_row is an alias for source (at least one of them must be ``None``).
+    force_bipartite :
+        If ``True``, consider the input matrix as the biadjacency matrix of a bipartite graph.
+        Set to ``True`` is the parameters source_row or source_col are specified.
 
     Returns
     -------
-    dist_matrix : np.ndarray
-        Matrix of distances between nodes. ``dist_matrix[i,j]`` gives the shortest
-        distance from the ``i``-th source to node ``j`` in the graph (infinite if no path exists
-        from the ``i``-th source to node ``j``).
-    predecessors : np.ndarray, optional
-        Returned only if ``return_predecessors == True``. The matrix of predecessors, which can be used to reconstruct
-        the shortest paths. Row ``i`` of the predecessor matrix contains information on the shortest paths from the
-        ``i``-th source: each entry ``predecessors[i, j]`` gives the index of the previous node in the path from
-        the ``i``-th source to node ``j`` (-1 if no path exists from the ``i``-th source to node ``j``).
+    path : sparse.csr_matrix
+        Adjacency matrix of the graph of the shortest paths from the source node (or the set of source nodes).
+        If the input graph is a bipartite graph, the shape of the matrix is (n_row + n_col, n_row + n_col) with the new
+        index corresponding to the rows then the columns of the original graph.
 
     Examples
     --------
     >>> from sknetwork.data import cyclic_digraph
     >>> adjacency = cyclic_digraph(3)
-    >>> get_distances(adjacency, sources=0)
-    array([0., 1., 2.])
-    >>> get_distances(adjacency, sources=0, return_predecessors=True)
-    (array([0., 1., 2.]), array([-1,  0,  1]))
-
+    >>> path = get_shortest_path(adjacency, source=0)
+    >>> path.toarray().astype(int)
+    array([[0, 1, 0],
+           [0, 0, 1],
+           [0, 0, 0]])
     """
-    n_jobs = check_n_jobs(n_jobs)
-    if method == 'FW' and n_jobs != 1:
-        raise ValueError('The Floyd-Warshall algorithm cannot be used with parallel computations.')
-    if sources is None:
-        sources = np.arange(adjacency.shape[0])
-    elif np.issubdtype(type(sources), np.integer):
-        sources = np.array([sources])
-    n = len(sources)
-    directed = not is_symmetric(adjacency)
-    local_function = partial(sparse.csgraph.shortest_path,
-                             adjacency, method, directed, return_predecessors, unweighted, False)
-    if n_jobs == 1 or n == 1:
-        try:
-            res = sparse.csgraph.shortest_path(adjacency, method, directed, return_predecessors,
-                                               unweighted, False, sources)
-        except sparse.csgraph.NegativeCycleError:
-            raise ValueError("The shortest path computation could not be completed because a negative cycle is present.")
-    else:
-        try:
-            with Pool(n_jobs) as pool:
-                res = np.array(pool.map(local_function, sources))
-        except sparse.csgraph.NegativeCycleError:
-            pool.terminate()
-            raise ValueError("The shortest path computation could not be completed because a negative cycle is present.")
-    if return_predecessors:
-        res[1][res[1] < 0] = -1
-        if n == 1:
-            return res[0].ravel(), res[1].astype(int).ravel()
-        else:
-            return res[0], res[1].astype(int)
-    else:
-        if n == 1:
-            return res.ravel()
-        else:
-            return res
-
-
-def get_shortest_path(adjacency: sparse.csr_matrix, sources: Union[int, Iterable], targets: Union[int, Iterable],
-                      method: str = 'D', unweighted: bool = False, n_jobs: Optional[int] = None):
-    """Compute the shortest paths in the graph.
-
-    Parameters
-    ----------
-    adjacency :
-        The adjacency matrix of the graph
-    sources : int or iterable
-        Sources nodes.
-    targets : int or iterable
-        Target nodes.
-    method :
-        The method to be used.
-
-        * ``'D'`` (Dijkstra),
-        * ``'BF'`` (Bellman-Ford),
-        * ``'J'`` (Johnson).
-    unweighted :
-        If ``True``, the weights of the edges are ignored
-    n_jobs :
-        If an integer value is given, denotes the number of workers to use (-1 means the maximum number will be used).
-        If ``None``, no parallel computations are made.
-
-    Returns
-    -------
-    paths : list
-        If single source and single target, return a list containing the nodes on the path from source to target.
-        If multiple sources or multiple targets, return a list of paths as lists.
-        An empty list means that the path does not exist.
-
-    Examples
-    --------
-    >>> from sknetwork.data import linear_digraph
-    >>> adjacency = linear_digraph(3)
-    >>> get_shortest_path(adjacency, 0, 2)
-    [0, 1, 2]
-    >>> get_shortest_path(adjacency, 2, 0)
-    []
-    >>> get_shortest_path(adjacency, 0, [1, 2])
-    [[0, 1], [0, 1, 2]]
-    >>> get_shortest_path(adjacency, [0, 1], 2)
-    [[0, 1, 2], [1, 2]]
-    """
-    if np.issubdtype(type(sources), np.integer):
-        sources = [sources]
-    if np.issubdtype(type(targets), np.integer):
-        targets = [targets]
-
-    if len(sources) == 1:
-        source2target = True
-        source = sources[0]
-    elif len(targets) == 1:
-        source2target = False
-        source = targets[0]
-        targets = sources
-    else:
-        raise ValueError(
-            'This request is ambiguous. Either use one source and multiple targets or multiple sources and one target.')
-
-    if source2target:
-        dists, preds = get_distances(adjacency, source, method, True, unweighted, n_jobs)
+    distances = get_distances(input_matrix, source, source_row, source_col, force_bipartite)
+    if type(distances) == tuple:
+        adjacency = bipartite2undirected(input_matrix)
+        distances = np.hstack(distances)
     else:
-        dists, preds = get_distances(adjacency.T, source, method, True, unweighted, n_jobs)
+        adjacency = input_matrix
+    return get_dag(adjacency, order=distances)
 
-    paths = []
-    for target in targets:
-        if dists[target] == np.inf:
-            path = []
-        else:
-            path = [target]
-            node = target
-            while node != source:
-                node = preds[node]
-                path.append(node)
-        if source2target:
-            path.reverse()
-        paths.append(path)
-    if len(paths) == 1:
-        paths = paths[0]
-    return paths