skchem.core.Mol

Complexity

Total Complexity

32

Size/Duplication

Total Lines	158
Duplicated Lines	0 %

13 Methods

Rating	Name	Duplication	Size	Complexity
A	Mol.conformers()	0	7	1
A	Mol.to_dict()	0	14	2
B	Mol._to_dict_chemdoodle()	0	13	5
B	Mol.atom_props()	0	12	5
A	Mol.bonds()	0	6	1
A	Mol.__init__()	0	3	1
A	Mol._two_d()	0	7	2
A	Mol.atoms()	0	6	1
A	Mol.props()	0	6	1
A	Mol.name()	0	9	2
A	Mol.to_json()	0	5	1
A	Mol.to_inchi_key()	0	5	1
A	Mol.to_formula()	0	5	1

#! /usr/bin/env python
#
# Copyright (C) 2007-2009 Rich Lewis <rl403@cam.ac.uk>
# License: 3-clause BSD

"""
skchem.core.mol

Defining molecules in scikit-chem.
"""

import rdkit.Chem

The import rdkit.Chem could not be resolved.

from rdkit.Chem.rdDepictor import Compute2DCoords

The import rdkit.Chem.rdDepictor could not be resolved.

from rdkit.Chem.rdMolDescriptors import CalcMolFormula

The import rdkit.Chem.rdMolDescriptors could not be resolved.

import json

from skchem.core import ChemicalObject, Atom, Bond, Conformer

class Mol(rdkit.Chem.rdchem.Mol, ChemicalObject):

    """
    Class representing a Molecule in scikit-chem.
    """

    def __init__(self, *args, **kwargs):
        super(Mol, self).__init__(*args, **kwargs)
        self.__two_d = None #set in constructor

    @property
    def name(self):

        """ Return the name of the molecule. """

        try:
            return self.GetProp('_Name')

The Instance of Mol does not seem to have a member named GetProp.

        except KeyError:
            return None

    @name.setter
    def name(self, value):

        """ Set the name of the molecule. """

        if value is None:
            self.ClearProp('_Name')

The Instance of Mol does not seem to have a member named ClearProp.

        else:
            self.SetProp('_Name', value)

The Instance of Mol does not seem to have a member named SetProp.

    @property
    def atoms(self):

        """ return an iterable over the atoms of the molecule. """

        return [Atom.from_super(self.GetAtomWithIdx(i)) for i in range(self.GetNumAtoms())]

The Instance of Mol does not seem to have a member named GetAtomWithIdx.

The Instance of Mol does not seem to have a member named GetNumAtoms.

    @atoms.setter
    def atoms(self, value):

        """ Set the atoms of a molecule.  Not implemented. """

        raise NotImplementedError

    @property
    def bonds(self):

        """ Return an iterable over the bonds of the molecule. """

        return [Bond.from_super(self.GetBondWithIdx(i)) for i in range(self.GetNumBonds())]

The Instance of Mol does not seem to have a member named GetBondWithIdx.

The Instance of Mol does not seem to have a member named GetNumBonds.

    @bonds.setter
    def bonds(self, value):

        """ Set the bonds of the molecule. Not implemented. """

        raise NotImplementedError

    # use a view to easily set properties?
    @property
    def props(self):

        """ Return a dictionary of the properties of the molecule. """

        return {i: self.GetProp(i) for i in self.GetPropNames()}

The Instance of Mol does not seem to have a member named GetProp.

The Instance of Mol does not seem to have a member named GetPropNames.

    @props.setter
    def props(self, value):

        """ Set the properties of the molecule. Not implemented. """

        raise NotImplementedError

    @property
    def atom_props(self):

        """ Return a dict of lists of properties on atoms of the molecule. """

        if not hasattr(self, '_atom_prop_names'):
            res = set()
            for atom in self.atoms:
                res = res.union(set(atom.props.keys()))
            self._atom_prop_names = list(res)

The attribute _atom_prop_names was defined outside __init__.

        return {prop: [atom.props.get(prop, None) for atom in self.atoms]
                                        for prop in self._atom_prop_names}

Wrong continued indentation.
for prop in self._atom_prop_names}
| ^

    @property
    def conformers(self):

        """ Return a list of conformers of the molecule. """

        return [Conformer.from_super(self.GetConformer(i)) \

The Instance of Mol does not seem to have a member named GetConformer.

            for i in range(len(self.GetConformers()))]

The Instance of Mol does not seem to have a member named GetConformers.

    @conformers.setter
    def conformers(self, value):

        """ Set the conformers of the molecule.  Not implemented. """

        raise NotImplementedError

    def to_formula(self):

        """ Return the chemical formula of the molecule. """

        return CalcMolFormula(self)

    def _two_d(self):

        """ Return a conformer with coordinates in two dimension. """

        if not hasattr(self, '__two_d'):
            self.__two_d = Compute2DCoords(self)
        return self.conformers[self.__two_d]

    def to_dict(self, kind="chemdoodle"):

        """
        Return a dictionary representation of the molecule.

        TODO

        """

        if kind == "chemdoodle":
            return self._to_dict_chemdoodle()

        else:
            raise NotImplementedError

    def _to_dict_chemdoodle(self):

        """ Return a chemdoodle dict representation of the molecule. """

        atom_positions = [p.to_dict() for p in self._two_d().atom_positions]
        atom_elements = [a.element for a in self.atoms]

        for i, atom_position in enumerate(atom_positions):
            atom_position['l'] = atom_elements[i]

        bonds = [b.to_dict() for b in self.bonds]

        return {"m": [{"a": atom_positions, "b": bonds}]}

    def to_json(self, kind='chemdoodle'):

        """ Return a JSON representation of the molecule. """

        return json.dumps(self.to_dict(kind=kind))

    def to_inchi_key(self, *args, **kwargs):

        """ Return the INCHI key of the molecule. """

        return rdkit.Chem.InchiToInchiKey(self.to_inchi(), *args, **kwargs)

The Instance of Mol does not seem to have a member named to_inchi.

    def __repr__(self):
        return '<{klass} name="{name}" formula="{formula}" at {address}>'.format(
            klass=self.__class__.__name__,
            name=self.name,
            formula=self.to_formula(),
            address=hex(id(self)))

    def _repr_javascript(self):

        """ Rich printing in javascript. """

        return self.to_json()

    def __str__(self):
        return '<Mol: {}>'.format(self.to_smiles())

The Instance of Mol does not seem to have a member named to_smiles.

def bind_constructor(constructor_name, name_to_bind=None):

    """ Bind an (rdkit) constructor to the class """

    @classmethod
    def constructor(_, in_arg, name=None, *args, **kwargs):

        """ The constructor to be bound. """

        m = getattr(rdkit.Chem, 'MolFrom' + constructor_name)(in_arg, *args, **kwargs)

The name m does not conform to the variable naming conventions ([a-z_][a-z0-9_]{2,30}$).

        if m is None:
            raise ValueError('Failed to parse molecule, {}'.format(in_arg))
        m = Mol.from_super(m)

The name m does not conform to the variable naming conventions ([a-z_][a-z0-9_]{2,30}$).

        m.name = name
        return m

    setattr(Mol, 'from_{}'.format(constructor_name).lower() \
        if name_to_bind is None else name_to_bind, constructor)

def bind_serializer(serializer_name, name_to_bind=None):

    """ Bind an (rdkit) serializer to the class """

    def serializer(self, *args, **kwargs):

        """ The serializer to be bound. """
        return getattr(rdkit.Chem, 'MolTo' + serializer_name)(self, *args, **kwargs)

    setattr(Mol, 'to_{}'.format(serializer_name).lower() \
        if name_to_bind is None else name_to_bind, serializer)

CONSTRUCTORS = ['Inchi', 'Smiles', 'Mol2Block', 'Mol2File', 'MolBlock', \
                    'MolFile', 'PDBBlock', 'PDBFile', 'Smarts', 'TPLBlock', 'TPLFile']
SERIALIZERS = ['Inchi', 'Smiles', 'MolBlock', 'PDBBlock', 'Smarts', 'TPLBlock', 'TPLFile']

list(map(bind_constructor, CONSTRUCTORS))

Used builtin function 'map'

list(map(bind_serializer, SERIALIZERS))

Used builtin function 'map'