Fingerprinter.__init__() - Code Metrics - Inspection of "updated descriptors for efficiency and to work wit..." - richlewis42/scikit-chem - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c7f259...9726b9 )

by Rich

created 2016-06-02 13:35 UTC

Fingerprinter.init() A

↳ Parent: Fingerprinter

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	2

Metric	Value
cc	1
c	2
b	0
f	2
dl	0
loc	14
rs	9.4285

#! /usr/bin/env python
#
# Copyright (C) 2007-2009 Rich Lewis <[email protected]>
# License: 3-clause BSD

"""
## skchem.descriptors.fingerprints

Fingerprinting classes and associated functions are defined.
"""

from functools import wraps
from collections import Iterable

import pandas as pd
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3
from rdkit.Chem import DataStructs, GetDistanceMatrix
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3
from rdkit.DataStructs import ConvertToNumpyArray
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3
from rdkit.Chem.rdMolDescriptors import (GetMorganFingerprint,
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3
                                         GetHashedMorganFingerprint,
                                         GetMorganFingerprintAsBitVect,
                                         GetAtomPairFingerprint,
                                         GetHashedAtomPairFingerprint,
                                         GetHashedAtomPairFingerprintAsBitVect,
                                         GetTopologicalTorsionFingerprint,
                                         GetHashedTopologicalTorsionFingerprint,
                                         GetHashedTopologicalTorsionFingerprintAsBitVect,
                                         GetMACCSKeysFingerprint,
                                         GetFeatureInvariants,
                                         GetConnectivityInvariants)
from rdkit.Chem.rdReducedGraphs import GetErGFingerprint
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3
from rdkit.Chem.rdmolops import RDKFingerprint
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3

import numpy as np
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3
import skchem

def skchemize(func, columns=None, *args, **kwargs):
    """

    transform an RDKit fingerprinting function to work well with pandas

    >>> from rdkit import Chem
    >>> import skchem
    >>> from skchem.descriptors import skchemize
    >>> from skchem.core import Mol
    >>> f = skchemize(Chem.RDKFingerprint)
    >>> m = Mol.from_smiles('c1ccccc1')
    >>> f(m)
    0       0
    1       0
    2       0
    3       0
    4       0
    5       0
    6       0
    7       0
    8       0
    9       0
    10      0
    11      0
    12      0
    13      0
    14      0
    15      0
    16      0
    17      0
    18      0
    19      0
    20      0
    21      0
    22      0
    23      0
    24      0
    25      0
    26      0
    27      0
    28      0
    29      0
           ..
    2018    0
    2019    0
    2020    0
    2021    0
    2022    0
    2023    0
    2024    0
    2025    0
    2026    0
    2027    0
    2028    0
    2029    0
    2030    0
    2031    0
    2032    0
    2033    0
    2034    0
    2035    0
    2036    0
    2037    0
    2038    0
    2039    0
    2040    0
    2041    0
    2042    0
    2043    0
    2044    0
    2045    0
    2046    0
    2047    0
    dtype: int64
    >>> from skchem.data import resource
    >>> df = skchem.read_sdf(resource('test_sdf', 'multi_molecule-simple.sdf'))
    >>> df.structure.apply(f) # doctest: +NORMALIZE_WHITESPACE
          0     1     2     3     4     5     6     7     8     9     ...   2038
    name                                                              ...
    297      0     0     0     0     0     0     0     0     0     0  ...      0
    6324     0     0     0     0     0     0     0     0     0     0  ...      0
    6334     0     0     0     0     0     0     0     0     0     0  ...      0
    <BLANKLINE>
          2039  2040  2041  2042  2043  2044  2045  2046  2047
    name
    297      0     0     0     0     0     0     0     0     0
    6324     0     0     0     0     0     0     0     0     0
    6334     0     0     0     0     0     0     0     0     0
    <BLANKLINE>
    [3 rows x 2048 columns]

    """
    @wraps(func)
    def func_wrapper(m):


        """ Function that wraps an rdkit function allowing it to produce dataframes. """

        arr = np.array(0)
        DataStructs.ConvertToNumpyArray(func(m, *args, **kwargs), arr)


        return pd.Series(arr, index=columns)

    return func_wrapper


class Fingerprinter(object):

    """ Fingerprinter Base class. """

    def __init__(self, func, sparse=False, name=None):

        """ A generic fingerprinter.  Create with a function.

        Args:
            func (callable):
                A fingerprinting function that takes an skchem.Mol argument, and
                returns an iterable of values.
            name (str):
                The name of the fingerprints that are being calculated"""

        self.NAME = name

        self.func = func
        self.sparse = sparse

    def __call__(self, obj):

        """ Call the fingerprinter directly.

        This is a shorthand for transform. """

        return self.transform(obj)

    def __add__(self, other):

        """ Add fingerprinters together to create a fusion fingerprinter.

        Fusion featurizers will transform molecules to series with all
        features from all component featurizers.
        """

        fpers = []
        for fper in (self, other):
            if isinstance(fper, FusionFingerprinter):
                fpers += fper.fingerprinters

            else:
                fpers.append(fper)

        return FusionFingerprinter(fpers)

    def fit(self, X, y):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self

    def transform(self, obj):

        """ Calculate a fingerprint for the given object.

        Args:
            obj (skchem.Mol or pd.Series or pd.DataFrame or iterable):
                The object to be transformed.

        Returns:
            pd.DataFrame:
                The produced features.
        """

        if self.sparse:
            return self._transform_sparse(obj)
        else:
            return self._transform_dense(obj)

    def _transform_dense(self, obj):

        """ calculate a dense fingerprint for the given object. """

        if isinstance(obj, skchem.Mol):
            return pd.Series(self._transform(obj), index=self.index)

        elif isinstance(obj, pd.DataFrame):
            return self.transform(obj.structure)

        elif isinstance(obj, pd.Series):
            res_0 = self._transform(obj.ix[0])
            res = np.zeros((len(obj), len(res_0)))
            for i, mol in enumerate(obj):
                res[i] = self._transform(mol)
            return pd.DataFrame(res, index=obj.index, columns=self.index)

        elif isinstance(obj, (tuple, list)):
            res_0 = self._transform(obj[0])
            res = np.zeros((len(obj), len(res_0)))
            for i, mol in enumerate(obj):
                res[i] = self._transform(mol)

            idx = pd.Index([mol.name for mol in obj], name='name')
            return pd.DataFrame(res, index=idx, columns=self.index)

        else:
            raise NotImplementedError

    def _transform_sparse(self, obj):

        """ Calculate a sparse fingerprint for the given object. """

        if isinstance(obj, skchem.Mol):
            return pd.Series(self._transform(obj), index=self.index)

        elif isinstance(obj, pd.DataFrame):
            return self.transform(obj.structure)

        elif isinstance(obj, pd.Series):
            return pd.DataFrame([self.transform(m) for m in obj],
                                index=obj.idx,
                                columns=self.index).fillna(0)

        elif isinstance(obj, (tuple, list)):
            idx = pd.Index([mol.name for mol in obj], name='name')
            return pd.DataFrame([self.transform(m) for m in obj],
                                index=idx,
                                columns=self.index)

        else:
            raise NotImplementedError

    def _transform(self, mol):

        """ Calculate the fingerprint on a molecule. """

        return pd.Series(list(self.func(mol)), name=mol.name)

    @property
    def index(self):
class Foo:
    def some_method(self, x, y):
        return x + y;

        """ The index to use. """

        return None

class FusionFingerprinter(Fingerprinter):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

    def __init__(self, fingerprinters):
class SomeParent:
    def __init__(self):
        self.x = 1

class SomeChild(SomeParent):
    def __init__(self):
        # Initialize the super class
        SomeParent.__init__(self)

        self.fingerprinters = fingerprinters

    def transform(self, obj):

        if isinstance(obj, skchem.Mol):
            return pd.concat([fp.transform(obj) for fp in self.fingerprinters],
                             keys=[fp.NAME for fp in self.fingerprinters])

        elif isinstance(obj, pd.DataFrame):
            return pd.concat([fp.transform(obj) for fp in self.fingerprinters],
                             keys=[fp.NAME for fp in self.fingerprinters],
                             axis=1)

        elif isinstance(obj, pd.Series):
            return pd.concat([fp.transform(obj.structure) \
                                for fp in self.fingerprinters],
                             keys=[fp.NAME for fp in self.fingerprinters],
                             axis=1)

        else:
            raise NotImplementedError

    def _transform(self, mol):

        return pd.concat([fp.transform(mol) for fp in self.fingerprinters])

class MorganFingerprinter(Fingerprinter):

    """ Morgan Fingerprint Transformer. """

    NAME = 'morgan'

    def __init__(self, radius=2, n_feats=2048, as_bits=True,
class SomeParent:
    def __init__(self):
        self.x = 1

class SomeChild(SomeParent):
    def __init__(self):
        # Initialize the super class
        SomeParent.__init__(self)
                 use_features=False, use_bond_types=True, use_chirality=False):

        """
        Args:
            radius (int):
                The maximum radius for atom environments.
                Default is `2`.
            n_feats (int):
                The number of features to which to fold the fingerprint down.
                For unfolded, use `-1`.
                Default is `2048`.
            as_bits (bool):
                Whether to return bits (`True`) or counts (`False`).
                Default is `True`.
            use_features (bool):
                Whether to use map atom types to generic features (FCFP analog).
                Default is `False`.
            use_bond_types (bool):
                Whether to use bond types to differentiate environments.
                Default is `False`.
            use_chirality (bool):
                Whether to use chirality to differentiate environments.
                Default is `False`.

        Notes:
            Currently, folded bits are by far the fastest implementation.
        """

        self.radius = radius
        self.n_feats = n_feats
        self.sparse = self.n_feats < 0
        self.as_bits = as_bits
        self.use_features = use_features
        self.use_bond_types = use_bond_types
        self.use_chirality = use_chirality

    def _transform(self, mol):


        """Private method to transform a skchem molecule.

        Use `transform` for the public method, which genericizes the argument to
        iterables of mols.

        Args:
            mol (skchem.Mol): Molecule to calculate fingerprint for.

        Returns:
            np.array or dict:
                Fingerprint as an array (or a dict if sparse).
        """

        if self.as_bits and self.n_feats > 0:

            fp = GetMorganFingerprintAsBitVect(mol, self.radius,

                                           useFeatures=self.use_features,

                                           useBondTypes=self.use_bond_types,

                                           useChirality=self.use_chirality)

            res = np.array(0)
            ConvertToNumpyArray(fp, res).astype(np.uint8)

        else:

            if self.n_feats <= 0:

                res = GetMorganFingerprint(mol, self.radius,
                                           useFeatures=self.use_features,
                                           useBondTypes=self.use_bond_types,
                                           useChirality=self.use_chirality)
                res = res.GetNonzeroElements()
                if self.as_bits:
                    res = {k: int(v > 0) for k, v in res.items()}

            else:
                res = GetHashedMorganFingerprint(mol, self.radius,
                                                 nBits=self.n_feats,
                                                 useFeatures=self.use_features,
                                                 useBondTypes=self.use_bond_types,
                                                 useChirality=self.use_chirality)
                res = np.array(list(res))



        return res

    def grad(self, mol):

        """ Calculate the pseudo gradient with resepect to the atoms.

        The pseudo gradient is the number of times the atom set that particular
        bit.

        Args:
            mol (skchem.Mol):
                The molecule for which to calculate the pseudo gradient.

        Returns:
            pandas.DataFrame:
                Dataframe of pseudogradients, with columns corresponding to
                atoms, and rows corresponding to features of the fingerprint.
        """

        cols = pd.Index(list(range(len(mol.atoms))), name='atoms')
        dist = GetDistanceMatrix(mol)

        info = {}

        if self.n_feats < 0:

            res = GetMorganFingerprint(mol, self.radius,
                                       useFeatures=self.use_features,
                                       useBondTypes=self.use_bond_types,
                                       useChirality=self.use_chirality,
                                       bitInfo=info).GetNonzeroElements()
            idx_list = list(res.keys())
            idx = pd.Index(idx_list, name='features')
            grad = np.zeros((len(idx), len(cols)))
            for bit in info:
                for atom_idx, radius in info[bit]:
                    grad[idx_list.index(bit)] += (dist <= radius)[atom_idx]

        else:

            res = list(GetHashedMorganFingerprint(mol, self.radius,
                                        nBits=self.n_feats,

                                        useFeatures=self.use_features,

                                        useBondTypes=self.use_bond_types,

                                        useChirality=self.use_chirality,

                                        bitInfo=info))

            idx = pd.Index(range(self.n_feats), name='features')
            grad = np.zeros((len(idx), len(cols)))

            for bit in info:
                for atom_idx, radius in info[bit]:
                    grad[bit] += (dist <= radius)[atom_idx]

        grad = pd.DataFrame(grad, index=idx, columns=cols)

        if self.as_bits:
            grad = (grad > 0)

        return grad.astype(int)

class AtomPairFingerprinter(Fingerprinter):

    """ Atom Pair Tranformer. """

    NAME = 'atom_pair'

    def __init__(self, min_length=1, max_length=30, n_feats=2048, as_bits=False,
class SomeParent:
    def __init__(self):
        self.x = 1

class SomeChild(SomeParent):
    def __init__(self):
        # Initialize the super class
        SomeParent.__init__(self)
                 use_chirality=False):

        """ Instantiate an atom pair fingerprinter.

        Args:
            min_length (int):
                The minimum length of paths between pairs.
                Default is `1`, i.e. pairs can be bonded together.
            max_length (int):
                The maximum length of paths between pairs.
                Default is `30`.
            n_feats (int):
                The number of features to which to fold the fingerprint down.
                For unfolded, use `-1`.
                Default is `2048`.
            as_bits (bool):
                Whether to return bits (`True`) or counts (`False`).
                Default is `False`.
            use_chirality (bool):
                Whether to use chirality to differentiate environments.
                Default is `False`.
        """

        self.min_length = min_length
        self.max_length = max_length
        self.n_feats = n_feats
        self.sparse = self.n_feats < 0
        self.as_bits = as_bits
        self.use_chirality = use_chirality

    def _transform(self, mol):


        """Private method to transform a skchem molecule.

        Use transform` for the public method, which genericizes the argument to
        iterables of mols.

        Args:
            mol (skchem.Mol): Molecule to calculate fingerprint for.

        Returns:
            np.array or dict:
                Fingerprint as an array (or a dict if sparse).
        """


        if self.as_bits and self.n_feats > 0:

            fp = GetHashedAtomPairFingerprintAsBitVect(mol, nBits=self.n_feats,

                                           minLength=self.min_length,

                                           maxLength=self.max_length,

                                           includeChirality=self.use_chirality)

            res = np.array(0)
            ConvertToNumpyArray(fp, res).astype(np.uint8)

        else:

            if self.n_feats <= 0:

                res = GetAtomPairFingerprint(mol, nBits=self.n_feats,
                                               minLength=self.min_length,

                                               maxLength=self.max_length,

                                               includeChirality=self.use_chirality)

                res = res.GetNonzeroElements()
                if self.as_bits:
                    res = {k: int(v > 0) for k, v in res.items()}

            else:
                res = GetHashedAtomPairFingerprint(mol, nBits=self.n_feats,
                                               minLength=self.min_length,

                                               maxLength=self.max_length,

                                               includeChirality=self.use_chirality)

                res = np.array(list(res))

        return res

class TopologicalTorsionFingerprinter(Fingerprinter):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

    NAME = 'topological_torsion'

    def __init__(self, target_size=4, n_feats=2048, as_bits=False,
class SomeParent:
    def __init__(self):
        self.x = 1

class SomeChild(SomeParent):
    def __init__(self):
        # Initialize the super class
        SomeParent.__init__(self)
                 use_chirality=False):

        """
        Args:
            target_size (int):
                # TODO
            n_feats (int):
                The number of features to which to fold the fingerprint down.
                For unfolded, use `-1`.
                Default is `2048`.
            as_bits (bool):
                Whether to return bits (`True`) or counts (`False`).
                Default is `False`.
            use_chirality (bool):
                Whether to use chirality to differentiate environments.
                Default is `False`.
        """

        self.target_size = target_size
        self.n_feats = n_feats
        self.sparse = self.n_feats < 0
        self.as_bits = as_bits
        self.use_chirality = use_chirality

    def _transform(self, mol):
        """ Private method to transform a skchem molecule.
        Args:
            mol (skchem.Mol): Molecule to calculate fingerprint for.

        Returns:
            np.array or dict:
                Fingerprint as an array (or a dict if sparse).
        """

        if self.as_bits and self.n_feats > 0:

            fp = GetHashedTopologicalTorsionFingerprintAsBitVect(mol, nBits=self.n_feats,

                                           targetSize=self.target_size,

                                           includeChirality=self.use_chirality)

            res = np.array(0)
            ConvertToNumpyArray(fp, res).astype(np.uint8)

        else:

            if self.n_feats <= 0:

                res = GetTopologicalTorsionFingerprint(mol, nBits=self.n_feats,
                                               targetSize=self.target_size,

                                               includeChirality=self.use_chirality)

                res = res.GetNonzeroElements()
                if self.as_bits:
                    res = {k: int(v > 0) for k, v in res.items()}

            else:
                res = GetHashedTopologicalTorsionFingerprint(mol, nBits=self.n_feats,
                                               targetSize=self.target_size,

                                               includeChirality=self.use_chirality)

                res = np.array(list(res))

        return res


class MACCSKeysFingerprinter(Fingerprinter):

    """ MACCS Keys Fingerprints """

    NAME = 'maccs'

    def __init__(self):
class SomeParent:
    def __init__(self):
        self.x = 1

class SomeChild(SomeParent):
    def __init__(self):
        # Initialize the super class
        SomeParent.__init__(self)
        self.sparse = False

    def _transform(self, mol):

        return np.array(list(GetMACCSKeysFingerprint(mol)))

class ErGFingerprinter(Fingerprinter):

    """ ErG Fingerprints """

    NAME = 'erg'

    def __init__(self):
class SomeParent:
    def __init__(self):
        self.x = 1

class SomeChild(SomeParent):
    def __init__(self):
        # Initialize the super class
        SomeParent.__init__(self)
        self.sparse = False

    def _transform(self, mol):

        return np.array(GetErGFingerprint(mol))

class FeatureInvariantsFingerprinter(Fingerprinter):

    """ Feature invariants fingerprints. """

    NAME = 'feat_inv'

    def __init__(self):
class SomeParent:
    def __init__(self):
        self.x = 1

class SomeChild(SomeParent):
    def __init__(self):
        # Initialize the super class
        SomeParent.__init__(self)
        self.sparse = False

    def _transform(self, mol):

        return np.array(GetFeatureInvariants(mol))

class ConnectivityInvariantsFingerprinter(Fingerprinter):

    """ Connectivity invariants fingerprints """

    NAME = 'conn_inv'

    def __init__(self):
class SomeParent:
    def __init__(self):
        self.x = 1

class SomeChild(SomeParent):
    def __init__(self):
        # Initialize the super class
        SomeParent.__init__(self)
        self.sparse = False

    def _transform(self, mol):

        return np.array(GetConnectivityInvariants(mol))

class RDKFingerprinter(Fingerprinter):


    """ RDKit fingerprint """

    NAME = 'rdk'

    def __init__(self, min_path=1, max_path=7, n_feats=2048, n_bits_per_hash=2,
class SomeParent:
    def __init__(self):
        self.x = 1

class SomeChild(SomeParent):
    def __init__(self):
        # Initialize the super class
        SomeParent.__init__(self)
                 use_hs=True, target_density=0.0, min_size=128,

                 branched_paths=True, use_bond_types=True):


        """ RDK fingerprints

        Args:
            min_path (int):

            max_path (int):

            n_feats (int):
                The number of features to which to fold the fingerprint down.
                For unfolded, use `-1`.
                Default is `2048`.

            n_bits_per_hash (int)

            use_hs (bool):

            target_density (float):

            min_size (int):

            branched_paths (bool):

            use_bond_types (bool):
        """

        self.min_path = 1
        self.max_path = 7
        self.n_feats = 2048
        self.sparse = False
        self.n_bits_per_hash = 2
        self.use_hs = True
        self.target_density = 0.0
        self.min_size = 128
        self.branched_paths = True
        self.use_bond_types = True

    def _transform(self, mol):

        return np.array(list(RDKFingerprint(mol, minPath=self.min_path,
                                             maxPath=self.max_path,

                                             fpSize=self.n_feats,

                                             nBitsPerHash=self.n_bits_per_hash,

                                             useHs=self.use_hs,

                                             tgtDensity=self.target_density,

                                             minSize=self.min_size,

                                             branchedPaths=self.branched_paths,

                                             useBondOrder=self.use_bond_types)),

                        name=mol.name)


Push — master ( c7f259...9726b9 )

Fingerprinter.init() A

Complexity

Size

Duplication

Importance

1. Missing Dependencies

2. Missing init.py files

1. Missing Dependencies

2. Missing init.py files

1. Missing Dependencies

2. Missing init.py files

1. Missing Dependencies

2. Missing init.py files

1. Missing Dependencies

2. Missing init.py files

1. Missing Dependencies

2. Missing init.py files

1. Missing Dependencies

2. Missing init.py files

1			#! /usr/bin/env python
2			#
3			# Copyright (C) 2007-2009 Rich Lewis <[email protected]>
4			# License: 3-clause BSD
5
6			"""
7			## skchem.descriptors.fingerprints
8
9			Fingerprinting classes and associated functions are defined.
10			"""
11
12			from functools import wraps
13			from collections import Iterable
			0 ignored issues – show Unused Code introduced 2016-06-02 13:37 UTC by Report Bug Copy Issue Report Unused Iterable imported from collections Loading history...
14			import pandas as pd
			0 ignored issues – show Configuration introduced 2016-01-19 16:21 UTC by Report Bug Copy Issue Report The import `pandas` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
15			from rdkit.Chem import DataStructs, GetDistanceMatrix
			0 ignored issues – show Configuration introduced 2016-05-15 17:12 UTC by Report Bug Copy Issue Report The import `rdkit.Chem` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
16			from rdkit.DataStructs import ConvertToNumpyArray
			0 ignored issues – show Configuration introduced 2016-06-02 13:37 UTC by Report Bug Copy Issue Report The import `rdkit.DataStructs` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
17			from rdkit.Chem.rdMolDescriptors import (GetMorganFingerprint,
			0 ignored issues – show Configuration introduced 2016-04-14 16:48 UTC by Report Bug Copy Issue Report The import `rdkit.Chem.rdMolDescriptors` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
18			GetHashedMorganFingerprint,
19			GetMorganFingerprintAsBitVect,
20			GetAtomPairFingerprint,
21			GetHashedAtomPairFingerprint,
22			GetHashedAtomPairFingerprintAsBitVect,
23			GetTopologicalTorsionFingerprint,
24			GetHashedTopologicalTorsionFingerprint,
25			GetHashedTopologicalTorsionFingerprintAsBitVect,
26			GetMACCSKeysFingerprint,
27			GetFeatureInvariants,
28			GetConnectivityInvariants)
29			from rdkit.Chem.rdReducedGraphs import GetErGFingerprint
			0 ignored issues – show Configuration introduced 2016-04-14 16:48 UTC by Report Bug Copy Issue Report The import `rdkit.Chem.rdReducedGraphs` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
30			from rdkit.Chem.rdmolops import RDKFingerprint
			0 ignored issues – show Configuration introduced 2016-04-14 16:48 UTC by Report Bug Copy Issue Report The import `rdkit.Chem.rdmolops` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
31
32			import numpy as np
			0 ignored issues – show Configuration introduced 2016-01-19 16:21 UTC by Report Bug Copy Issue Report The import `numpy` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...

richlewis42 / scikit-chem

Push — master ( c7f259...9726b9 )

Fingerprinter.__init__() A

Complexity

Size

Duplication

Importance

1. Missing Dependencies

2. Missing __init__.py files

1. Missing Dependencies

2. Missing __init__.py files

1. Missing Dependencies

2. Missing __init__.py files

1. Missing Dependencies

2. Missing __init__.py files

1. Missing Dependencies

2. Missing __init__.py files

1. Missing Dependencies

2. Missing __init__.py files

1. Missing Dependencies

2. Missing __init__.py files

Duplication Side-by-Side

Filter issues like

Fingerprinter.init() A

2. Missing init.py files

2. Missing init.py files

2. Missing init.py files

2. Missing init.py files

2. Missing init.py files

2. Missing init.py files

2. Missing init.py files