Pass flake8

Author: ddomingof

src/diffupy/diffuse.py

@@ -1,7 +1,8 @@
 # -*- 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 offered
+in this diffuPy package.
+"""
 
 import copy
 import logging
@@ -27,7 +28,7 @@ def diffuse(
         graph: nx.Graph = None,
         **kwargs
 ) -> Matrix:
-    """Manages the treatment of the different score diffusion methods applied of/from an path set of labels/scores
+    """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).
 
     Diffusion methods procedures provided in this package differ on:

src/diffupy/diffuse_raw.py

@@ -26,7 +26,7 @@ def calculate_scores(
         const_mean: np.array,
         const_var: np.array
 ) -> float:
-    """Helper function for diffuse_raw, which operate the z-scores calculation given a whole column of the score matrix.
+    """Help function for diffuse_raw, which operate the z-scores calculation given a whole column of the score matrix.
 
     :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
@@ -55,8 +55,8 @@ def diffuse_raw(
         scores: Matrix,
         z: bool = False,
         K: Matrix = None,
-        **karg) -> Matrix:
-    """ Computes the score diffusion procedure, given an initial state as a set of scores and a network where diffuse it.
+    ) -> 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

src/diffupy/kernels.py

@@ -66,8 +66,7 @@ def diffusion_kernel(graph: nx.Graph, sigma2: float = 1, normalized: bool = True
 
 
 def inverse_cosine_kernel(graph: nx.Graph) -> Matrix:
-    """Compute the inverse cosine kernel, which is based on a cosine transform
-    on the spectrum of the normalized Laplacian matrix.
+    """Compute the inverse cosine kernel, which is based on a cosine transform  on the spectrum of the normalized LM.
 
     Quoting [Smola, 2003]: the inverse cosine kernel treats lower complexity
     functions almost equally, with a significant reduction in the upper end of the spectrum.
@@ -80,15 +79,14 @@ def inverse_cosine_kernel(graph: nx.Graph) -> Matrix:
     # Decompose matrix (Singular Value Decomposition)
     laplacian = LaplacianMatrix(graph, normalized=True)
     # Decompose matrix (Singular Value Decomposition)
-    U, S, _ = np.linalg.svd(laplacian.mat * (pi / 4))
-    laplacian.mat = np.matmul(np.matmul(U, np.diag(np.cos(S))), np.transpose(U))
+    u, s, _ = np.linalg.svd(laplacian.mat * (pi / 4))
+    laplacian.mat = np.matmul(np.matmul(u, np.diag(np.cos(s))), np.transpose(u))
 
     return laplacian
 
 
 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
-    Laplacian 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)

src/diffupy/process_input.py

@@ -5,8 +5,14 @@
 from .matrix import Matrix
 
 
-def generate_categoric_input_vector_from_labels(rows_labeled, col_label, background_mat, missing_value=-1,
-                                                rows_unlabeled=None):
+def generate_categoric_input_vector_from_labels(
+        rows_labeled,
+        col_label,
+        background_mat,
+        missing_value=-1,
+        rows_unlabeled=None,
+):
+    """Generate input vector from labels."""
     if isinstance(col_label, str):
         col_label = [col_label]
 
@@ -22,30 +28,39 @@ def generate_categoric_input_vector_from_labels(rows_labeled, col_label, backgro
     return input_mat.match_missing_rows(background_mat.rows_labels, missing_value).match_rows(background_mat)
 
 
-def generate_categoric_input_from_labels(rows_labels, cols_labels, background_mat, missing_value=-1,
-                                         rows_unlabeled=None, ):
+def generate_categoric_input_from_labels(
+        rows_labels,
+        cols_labels,
+        background_mat,
+        missing_value=-1,
+        rows_unlabeled=None,
+):
+    """Generate input vector from labels."""
     if isinstance(cols_labels, list) and len(cols_labels) > 1:
-        input_mat = generate_categoric_input_vector_from_labels(rows_labels[0],
-                                                                cols_labels[0],
-                                                                background_mat,
-                                                                missing_value,
-                                                                rows_unlabeled[0]
-                                                                )
+        input_mat = generate_categoric_input_vector_from_labels(
+            rows_labels[0],
+            cols_labels[0],
+            background_mat,
+            missing_value,
+            rows_unlabeled[0]
+        )
 
         for idx, row_label in enumerate(rows_labels[1:]):
-            input_vector = generate_categoric_input_vector_from_labels(row_label,
-                                                                       cols_labels[idx + 1],
-                                                                       background_mat,
-                                                                       missing_value,
-                                                                       rows_unlabeled[idx + 1],
-                                                                       )
+            input_vector = generate_categoric_input_vector_from_labels(
+                row_label,
+                cols_labels[idx + 1],
+                background_mat,
+                missing_value,
+                rows_unlabeled[idx + 1],
+            )
             input_mat.col_bind(matrix=input_vector)
 
         return input_mat
     else:
-        return generate_categoric_input_vector_from_labels(rows_labels,
-                                                           cols_labels,
-                                                           background_mat,
-                                                           missing_value,
-                                                           rows_unlabeled
-                                                           )
+        return generate_categoric_input_vector_from_labels(
+            rows_labels,
+            cols_labels,
+            background_mat,
+            missing_value,
+            rows_unlabeled
+        )