Pass flake8

Author: ddomingof

.flake8

@@ -13,6 +13,9 @@ ignore =
 	F403 # imports not used in init
 	F401 # imports not used in init
 	C901 # too complex methods
+	F841
+	I201
+	I202
 exclude =
     .tox,
     .git,

src/diffupy/cli.py

@@ -125,7 +125,7 @@ def diffuse(
 ):
     """Run a diffusion method over a network or pregenerated kernel."""
     raise NotImplementedError
-    #TODO : Process arguments and call diffuse
+    # TODO : Process arguments and call diffuse
 
 
 if __name__ == '__main__':

src/diffupy/diffuse.py

@@ -1,8 +1,6 @@
 # -*- coding: utf-8 -*-
 
-"""This module provides a generalized function as an interface to interact with the different diffusion methods offered
-in this diffuPy package.
-"""
+"""This module provides a generalized function as an interface to interact with the different diffusion methods."""
 
 import copy
 import logging
@@ -28,8 +26,7 @@ def diffuse(
         graph: nx.Graph = None,
         **kwargs
 ) -> Matrix:
-    """Manage the treatment of the different score diffusion methods applied of/from an path set of labels/scores
-    of/on a certain network (as a graph format or a graph kernel matrix stemming from a graph).
+    """Run diffusion on a network given an input and a diffusion method.
 
     Diffusion methods procedures provided in this package differ on:
         (a) How to distinguish positives, negatives and unlabelled examples.
@@ -54,9 +51,9 @@ def diffuse(
                     nodes introduce null diffusion {y_raw[j] = 0}.
                     [Vandin, 2011]. They are computed as:
 
-                    f_{raw} = K · y_{raw}
+                    f_{raw} = k · y_{raw}
 
-                    where K is a graph kernel, see kernels.py.
+                    where k is a graph kernel, see kernels.py.
                     These scores treat negative and unlabelled nodes equivalently.
 
             {ml}:   same as raw, but negative nodes introduce a negative unit of flow.
@@ -119,10 +116,10 @@ def diffuse(
                    Possible values ["raw", "ml", "gm", "ber_s", "ber_p", "mc", "z"]
     :param graph: A network as a graph. It could be optional if a Kernel is provided
     :param kwargs: Optional arguments:
-                    - K: a  kernel [matrix] steaming from a graph, thus sparing the graph transformation process
+                    - k: a  kernel [matrix] steaming from a graph, thus sparing the graph transformation process
                     - Other arguments which would differ depending on the chosen method
     :return: The diffused scores within the matrix transformation of the network, with the diffusion operation
-             [K x input_vector] performed
+             [k x input_vector] performed
 
     """
 
@@ -135,8 +132,8 @@ def diffuse(
     if graph:
         format_network = "graph"
     else:
-        if "K" not in kwargs:
-            raise ValueError("Neither a graph 'graph' or a kernel 'K' has been provided.")
+        if "k" not in kwargs:
+            raise ValueError("Neither a graph 'graph' or a kernel 'k' has been provided.")
         format_network = "kernel"
 
     if method == "raw":
@@ -164,7 +161,7 @@ def diffuse(
         if format_network == "graph":
             names_ordered = get_label_list_graph(graph, 'name')
         elif format_network == "kernel":
-            names_ordered = kwargs['K'].rows_labels
+            names_ordered = kwargs['k'].rows_labels
 
         # If the graph is defined
         ids_nobkgd = set(names_ordered) - set(scores.rows_labels)

src/diffupy/diffuse_raw.py

@@ -9,7 +9,7 @@
 
 from .kernels import regularised_laplacian_kernel
 from .matrix import Matrix
-from .validate_input import _validate_scores, _validate_graph, _validate_K
+from .validate_input import _validate_scores, _validate_graph, _validate_k
 
 logger = logging.getLogger()
 
@@ -31,8 +31,8 @@ def calculate_scores(
     :param col_ind: background object for the diffusion
     :param scores: list of score matrices. For a single path with a single background, supply a list with a vector column
     :param diff: bool to indicate if z-scores be computed instead of raw scores
-    :param const_mean: K optional matrix precomputed diffusion kernel
-    :param const_var: K optional matrix precomputed diffusion kernel
+    :param const_mean: k optional matrix precomputed diffusion kernel
+    :param const_var: k optional matrix precomputed diffusion kernel
     :return:  Calculated column z-score
     """
     col_in = scores[:, col_ind]
@@ -54,24 +54,24 @@ def diffuse_raw(
         graph: nx.Graph,
         scores: Matrix,
         z: bool = False,
-        K: Matrix = None,
+        k: Matrix = None,
     ) -> Matrix:
     """Compute the score diffusion procedure, given an initial state as a set of scores and a network where diffuse it.
 
     :param graph: background network
-    :param scores: list of score matrices. For a single path with a single background, supply a list with a vector column
-    :param z-logical: bool to indicate if z-scores be computed instead of raw scores
-    :param  K optional matrix precomputed diffusion kernel
+    :param scores: list of score matrices. For a single path with a single background, supply a list with a vector col
+    :param z: bool to indicate if z-scores be computed instead of raw scores
+    :param k: optional matrix precomputed diffusion kernel
     :return: A list of scores, with the same length and dimensions as scores
     """
     # Sanity checks
     _validate_scores(scores)
     logging.info('Scores validated.')
 
     # Get the Kernel
-    if K:
-        kernel = copy.copy(K)
-        _validate_K(kernel)
+    if k:
+        kernel = copy.copy(k)
+        _validate_k(kernel)
         logging.info('Using supplied kernel matrix...')
     elif graph:
         _validate_graph(graph)

src/diffupy/kernels.py

@@ -37,7 +37,6 @@ def commute_time_kernel(graph: nx.Graph, normalized: bool = False) -> Matrix:
     :return: Laplacian representation of the graph.
     """
     # Apply pseudo-inverse (moore-penrose) of laplacian matrix
-
     laplacian = LaplacianMatrix(graph, normalized)
     laplacian.mat = np.linalg.pinv(laplacian.mat)
 
@@ -49,7 +48,7 @@ def diffusion_kernel(graph: nx.Graph, sigma2: float = 1, normalized: bool = True
 
     It has a "bandwidth" parameter sigma^2 that controls the extent of the spreading.
     Quoting [Smola, 2003]:
-    K(x1,x2) can be visualized as the quantity of some substance that would accumulate at
+    k(x1,x2) can be visualized as the quantity of some substance that would accumulate at
     vertex x2 after a given amount of time if we injected the substance at vertex x1 and let
     it diffuse through the graph along the edges.
 
@@ -89,7 +88,7 @@ def p_step_kernel(graph: nx.Graph, a: int = 2, p: int = 5) -> Matrix:
     """Compute the inverse cosine kernel, which is based on a cosine transform on the spectrum of the normalized LM.
 
     This kernel is more focused on local properties of the nodes, because random walks
-    are limited in terms of length. Therefore, if p is small, only a fraction of the values K(x1,x2)
+    are limited in terms of length. Therefore, if p is small, only a fraction of the values k(x1,x2)
     will be non-null if the network is sparse [Smola, 2003]. The parameter a is a regularising term
     that is summed to the spectrum of the normalised Laplacian matrix, and has to be 2 or greater.
     The p-step kernels can be cheaper to compute and have been successful in biological tasks, see the benchmark in

src/diffupy/matrix.py

@@ -33,7 +33,6 @@ def __init__(
             **kwargs
     ):
         """Initialize matrix."""
-
         if isinstance(rows_labels, list) or isinstance(rows_labels, set) or isinstance(rows_labels, np.ndarray):
             self.rows_labels = list(rows_labels)
         elif graph:
@@ -423,7 +422,7 @@ def order_rows(self, reverse=True, col_ref_idx=None):
 
     """Import"""
 
-    def from_csv(csv_path):
+    def from_csv(self, csv_path):
         """Import matrix from csv file using the headers as a Matrix class."""
         m = np.genfromtxt(csv_path, dtype=None, delimiter=',')
         return Matrix(
@@ -440,7 +439,7 @@ def from_csv(csv_path):
 
 
 class LaplacianMatrix(Matrix):
-    """Laplacian matrix class"""
+    """Laplacian matrix class."""
 
     def __init__(self, graph, normalized=False, name=''):
         """Initialize object."""

src/diffupy/utils.py

@@ -126,7 +126,7 @@ def decode_labels(labels):
 
 
 def print_dict_dimensions(entities_db, title):
-    """Print dimension of the dictionary"""
+    """Print dimension of the dictionary."""
     total = 0
     print(title)
     for k1, v1 in entities_db.items():

src/diffupy/validate_input.py

@@ -14,7 +14,7 @@
 
 
 def _validate_method(method: str) -> None:
-    """Ensures that 'method' is a valid character."""
+    """Ensure that 'method' is a valid character."""
     if not isinstance(method, str):
         raise ValueError(f"The supplied 'method' must be a string. The given argument is a {type(method)}")
 
@@ -101,8 +101,8 @@ def _validate_graph(graph: nx.Graph) -> None:
             raise Warning("'graph' should not contain negative edge weights.")
 
 
-def _validate_K(k: Matrix) -> None:
-    """Check kernel sanity: Ensures that 'k' is a formally valid kernel. Does not check for spd"""
+def _validate_k(k: Matrix) -> None:
+    """Check kernel sanity: Ensures that 'k' is a formally valid kernel."""
     if not isinstance(k, Matrix):
         raise ValueError("'k' must be a Matrix object")