Formatting feedback from flake

Author: charnley

src/qmllib/kernels/__init__.py

@@ -1,3 +1,3 @@
-from .distance import *
-from .gradient_kernels import *
-from .kernels import *
+from qmllib.kernels.distance import *  # noqa:F403
+from qmllib.kernels.gradient_kernels import *  # noqa:F403
+from qmllib.kernels.kernels import *  # noqa:F403

src/qmllib/kernels/distance.py

@@ -77,7 +77,7 @@ def p_distance(A, B, p=2):
     The value of the keyword argument ``p =`` sets the norm order.
     E.g. ``p = 1.0`` and ``p = 2.0`` with yield the Manhattan and L2 distances, respectively.
 
-        .. math:: D_{ij} = \|A_i - B_j\|_p
+        .. math:: D_{ij} = \\|A_i - B_j\\|_p
 
     Where :math:`A_{i}` and :math:`B_{j}` are representation vectors.
     D is calculated using an OpenMP parallel Fortran routine.
@@ -104,13 +104,13 @@ def p_distance(A, B, p=2):
 
     D = np.empty((na, nb), order="F")
 
-    if type(p) == type(1):
+    if isinstance(p, int):
         if p == 2:
             fl2_distance(A, B, D)
         else:
             fp_distance_integer(A.T, B.T, D, p)
 
-    elif type(p) == type(1.0):
+    elif isinstance(p, float):
         if p.is_integer():
             p = int(p)
             if p == 2:

src/qmllib/kernels/gradient_kernels.py

@@ -1,5 +1,3 @@
-import ctypes
-
 import numpy as np
 
 from .fgradient_kernels import (
@@ -20,29 +18,31 @@
 
 def mkl_set_num_threads(cores):
 
-    if cores is None:
-        return
+    raise NotImplementedError("Should not be here")
+    # if cores is None:
+    #     return
 
-    try:
-        mkl_rt = ctypes.CDLL("libmkl_rt.so")
-        mkl_rt.mkl_set_num_threads(ctypes.byref(ctypes.c_int(cores)))
+    # try:
+    #     mkl_rt = ctypes.CDLL("libmkl_rt.so")
+    #     mkl_rt.mkl_set_num_threads(ctypes.byref(ctypes.c_int(cores)))
 
-    except:
+    # except:
 
-        pass
+    #     pass
 
 
 def mkl_get_num_threads():
 
-    try:
-        mkl_rt = ctypes.CDLL("libmkl_rt.so")
-        mkl_num_threads = mkl_rt.mkl_get_max_threads()
+    raise NotImplementedError("Should not be here")
+    # try:
+    #     mkl_rt = ctypes.CDLL("libmkl_rt.so")
+    #     mkl_num_threads = mkl_rt.mkl_get_max_threads()
 
-        return mkl_num_threads
+    #     return mkl_num_threads
 
-    except:
+    # except:
 
-        return None
+    #     return None
 
 
 def get_global_kernel(X1, X2, Q1, Q2, SIGMA):

src/qmllib/kernels/wrappers.py

@@ -1,67 +1,65 @@
 import numpy as np
 
 from ..arad import get_local_kernels_arad, get_local_symmetric_kernels_arad
-from .fkernels import (
-    fget_vector_kernels_gaussian,
-    fget_vector_kernels_gaussian_symmetric,
-    fget_vector_kernels_laplacian,
-)
+from .fkernels import fget_vector_kernels_gaussian, fget_vector_kernels_laplacian
 
+# TODO Duplicate function definition
+# def get_atomic_kernels_laplacian(mols1, mols2, sigmas):
 
-def get_atomic_kernels_laplacian(mols1, mols2, sigmas):
+#     n1 = np.array([mol.natoms for mol in mols1], dtype=np.int32)
+#     n2 = np.array([mol.natoms for mol in mols2], dtype=np.int32)
 
-    n1 = np.array([mol.natoms for mol in mols1], dtype=np.int32)
-    n2 = np.array([mol.natoms for mol in mols2], dtype=np.int32)
+#     max1 = np.max(n1)
+#     max2 = np.max(n2)
 
-    max1 = np.max(n1)
-    max2 = np.max(n2)
+#     nm1 = n1.size
+#     nm2 = n2.size
 
-    nm1 = n1.size
-    nm2 = n2.size
+#     cmat_size = mols1[0].representation.shape[1]
 
-    cmat_size = mols1[0].representation.shape[1]
+#     x1 = np.zeros((nm1, max1, cmat_size), dtype=np.float64, order="F")
+#     x2 = np.zeros((nm2, max2, cmat_size), dtype=np.float64, order="F")
 
-    x1 = np.zeros((nm1, max1, cmat_size), dtype=np.float64, order="F")
-    x2 = np.zeros((nm2, max2, cmat_size), dtype=np.float64, order="F")
+#     for imol in range(nm1):
+#         x1[imol, : n1[imol], :cmat_size] = mols1[imol].representation
 
-    for imol in range(nm1):
-        x1[imol, : n1[imol], :cmat_size] = mols1[imol].representation
+#     for imol in range(nm2):
+#         x2[imol, : n2[imol], :cmat_size] = mols2[imol].representation
 
-    for imol in range(nm2):
-        x2[imol, : n2[imol], :cmat_size] = mols2[imol].representation
+#     # Reorder for Fortran speed
+#     x1 = np.swapaxes(x1, 0, 2)
+#     x2 = np.swapaxes(x2, 0, 2)
 
-    # Reorder for Fortran speed
-    x1 = np.swapaxes(x1, 0, 2)
-    x2 = np.swapaxes(x2, 0, 2)
+#     sigmas = np.asarray(sigmas, dtype=np.float64)
+#     nsigmas = sigmas.size
 
-    sigmas = np.asarray(sigmas, dtype=np.float64)
-    nsigmas = sigmas.size
-
-    return fget_vector_kernels_laplacian(x1, x2, n1, n2, sigmas, nm1, nm2, nsigmas)
+#     return fget_vector_kernels_laplacian(x1, x2, n1, n2, sigmas, nm1, nm2, nsigmas)
 
 
 def get_atomic_kernels_laplacian_symmetric(mols, sigmas):
 
-    n = np.array([mol.natoms for mol in mols], dtype=np.int32)
+    raise NotImplementedError("x1 is missing definition")
 
-    max_atoms = np.max(n)
+    # n = np.array([mol.natoms for mol in mols], dtype=np.int32)
 
-    nm = n.size
+    # max_atoms = np.max(n)
 
-    cmat_size = mols[0].representation.shape[1]
+    # nm = n.size
 
-    x = np.zeros((nm, max_atoms, cmat_size), dtype=np.float64, order="F")
+    # cmat_size = mols[0].representation.shape[1]
 
-    for imol in range(nm):
-        x[imol, : n[imol], :cmat_size] = mols[imol].representation
+    # x = np.zeros((nm, max_atoms, cmat_size), dtype=np.float64, order="F")
 
-    # Reorder for Fortran speed
-    x = np.swapaxes(x, 0, 2)
+    # for imol in range(nm):
+    #     x[imol, : n[imol], :cmat_size] = mols[imol].representation
 
-    sigmas = np.asarray(sigmas, dtype=np.float64)
-    nsigmas = sigmas.size
+    # # Reorder for Fortran speed
+    # x = np.swapaxes(x, 0, 2)
 
-    return fget_vector_kernels_laplacian(x1, n, sigmas, nm, nsigmas)
+    # sigmas = np.asarray(sigmas, dtype=np.float64)
+    # nsigmas = sigmas.size
+
+    # return fget_vector_kernels_laplacian(x1, n, sigmas, nm, nsigmas)
 
 
 def arad_local_kernels(
@@ -165,23 +163,24 @@ def get_atomic_kernels_gaussian(mols1, mols2, sigmas):
 
 def get_atomic_kernels_gaussian_symmetric(mols, sigmas):
 
-    n = np.array([mol.natoms for mol in mols], dtype=np.int32)
+    raise NotImplementedError("nm1 not defined and x1 not used")
+    # n = np.array([mol.natoms for mol in mols], dtype=np.int32)
 
-    max_atoms = np.max(n)
+    # max_atoms = np.max(n)
 
-    nm = n.size
+    # nm = n.size
 
-    cmat_size = mols[0].representation.shape[1]
+    # cmat_size = mols[0].representation.shape[1]
 
-    x1 = np.zeros((nm, max_atoms, cmat_size), dtype=np.float64, order="F")
+    # x1 = np.zeros((nm, max_atoms, cmat_size), dtype=np.float64, order="F")
 
-    for imol in range(nm1):
-        x[imol, : n[imol], :cmat_size] = mols[imol].representation
+    # for imol in range(nm1):
+    #     x[imol, : n[imol], :cmat_size] = mols[imol].representation
 
-    # Reorder for Fortran speed
-    x = np.swapaxes(x, 0, 2)
+    # # Reorder for Fortran speed
+    # x = np.swapaxes(x, 0, 2)
 
-    sigmas = np.array(sigmas, dtype=np.float64)
-    nsigmas = sigmas.size
+    # sigmas = np.array(sigmas, dtype=np.float64)
+    # nsigmas = sigmas.size
 
-    return fget_vector_kernels_gaussian_symmetric(x, n, sigmas, nm, nsigmas)
+    # return fget_vector_kernels_gaussian_symmetric(x, n, sigmas, nm, nsigmas)

src/qmllib/representations/__init__.py

@@ -1 +1 @@
-from .representations import *
+from .representations import *  # noqa:F403

src/qmllib/representations/fchl/__init__.py

@@ -1,4 +1,4 @@
-from .fchl_electric_field_kernels import *
-from .fchl_force_kernels import *
-from .fchl_representations import *
-from .fchl_scalar_kernels import *
+from .fchl_electric_field_kernels import *  # noqa:F403
+from .fchl_force_kernels import *  # noqa:F403
+from .fchl_representations import *  # noqa:F403
+from .fchl_scalar_kernels import *  # noqa:F403