ChemObjectIterator

Complexity

Total Complexity

3

Size/Duplication

Total Lines	18
Duplicated Lines	0 %

Test Coverage

Coverage

50%

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__init__()	0	4	1
A	__next__()	0	6	2

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

"""
## skchem.core.base

Define base classes for scikit chem objects
"""

from abc import ABCMeta, abstractmethod
import warnings
import numpy as np

The import numpy could not be resolved.

import pandas as pd

The import pandas could not be resolved.

class ChemicalObject(object):

    """ A mixin for each chemical object in scikit-chem """

    @classmethod
    def from_super(cls, obj):

        """A method that converts the class of an object of parent class to that of the child. """

        obj.__class__ = cls
        return obj


class ChemicalObjectView(object):

    """ Atom interface wrapper """

    def __init__(self, owner):
        self.owner = owner

    def __iter__(self):
        return ChemObjectIterator(self)

    def __str__(self):
        return str(list(str(obj) for obj in self))

    @property
    def props(self):

This method should have a docstring.

        return MolPropertyView(self)

    def __repr__(self):
        return '<{class_} values="{values}" at {address}>'.format(
            class_=self.__class__.__name__,
            values=str(self),
            address=hex(id(self)))


class ChemObjectIterator(object):

    """ Atom iterator """

    def __init__(self, view):
        self.view = view
        self._current = 0
        self._high = len(self.view)

    def __next__(self):
        if self._current >= self._high:
            raise StopIteration
        else:
            self._current += 1
            return self.view[self._current - 1]

    # py2 compat
    next = __next__


class View(object):

    """ View wrapper interface """
    __metaclass__ = ABCMeta

    @abstractmethod
    def keys(self):

This method should have a docstring.

        return []

    def get(self, index, default=None):

This method should have a docstring.

        if index in self.keys():
            return self[index]
        else:
            return default

    def pop(self, index, default=None):

This method should have a docstring.

        if default:
            val = self.get(index, default)
        else:
            val = self[index]
        self.remove(index)
        return val

    def clear(self):

This method should have a docstring.

        for idx in self.keys():
            self.remove(idx)

    def items(self):

This method should have a docstring.

        return list((k, self[k]) for k in self.keys())

    def remove(self, key):

This method should have a docstring.

        self.__delitem__(key)

    def __getitem__(self, key):
        raise NotImplemented

NotImplemented raised - should raise NotImplementedError

    def __setitem__(self, key, value):
        raise NotImplemented

NotImplemented raised - should raise NotImplementedError

    def __delitem__(self, key):
        raise NotImplemented

NotImplemented raised - should raise NotImplementedError

    def __iter__(self):
        return iter(self.keys())

    def __str__(self):
        return str(self.to_dict())

    def __len__(self):
        return len(self.keys())

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

    def to_dict(self):

This method should have a docstring.

        return dict(self)

    def to_series(self):

This method should have a docstring.

        return pd.Series(self.to_dict())


class PropertyView(View):

    """ Property object wrapper """

    def __init__(self, owner):
        self._owner = owner

    def keys(self):
        return list(k for k in self._owner.GetPropNames() if k[:1] != '_')

    def __getitem__(self, key):

        # we manually work out if it was a float that was stored, as GetProp
        # returns floats and ints set by SetDoubleProp and SetIntProp as strings
        value = self._owner.GetProp(str(key))
        try:
            return int(value)
        except ValueError:
            try:
                return float(value)
            except ValueError:
                return value

    def __setitem__(self, key, value):

        if not isinstance(key, str):
            warnings.warn("RDKit property keys can only be of type `str`.  Using `{key}` as a `str`.".format(key=key))

This line is too long as per the coding-style (118/100).

            key = str(key)

        if key[0] == '_':
            warnings.warn("`{value}` is a private RDKit property key. "
                          "Using this may have unintended consequences.".format(value=value))

        if isinstance(value, str):
            self._owner.SetProp(key, value)
        elif isinstance(value, (int, np.int64, np.int32)):
            self._owner.SetIntProp(key, value)
        elif isinstance(value, (float, np.float64, np.float32)):
            self._owner.SetDoubleProp(key, value)
        else:
            warnings.warn("RDKit property keys can only be `str`, `int` or `float`."
                          "Using `{value}` as a `str`.".format(value=value))
            self._owner.SetProp(key, str(value))

    def __delitem__(self, index):
        self._owner.ClearProp(index)



class MolPropertyView(View):

    """ Mol property wrapper """

    def __init__(self, obj_view):
        self._obj_view = obj_view

    def keys(self):
        res = set()
        for atom in self._obj_view:
            res = res.union(set(atom.props.keys()))
        return list(res)

    def get(self, key, default=None):
        return pd.Series((a.props.get(key, default) for a in self._obj_view), index=self._obj_view.index)

This line is too long as per the coding-style (105/100).

    def __getitem__(self, key):
        if key not in self.keys():
            raise KeyError('No atoms have the property set.')
        return self.get(key, None)

    def __setitem__(self, key, value):
        if isinstance(value, (pd.Series, dict)):
            for idx, val in pd.compat.iteritems(value):
                self._obj_view[int(idx)].props[key] = val
        else:
            assert len(self._obj_view) == len(value), "Must pass same number of values as atoms."
            for atom, val in zip(self._obj_view, value):
                atom.props[key] = val

    def __delitem__(self, key):
        for atom in self._obj_view:
            atom.props.remove(key)

    def to_frame(self):

This method should have a docstring.

        return pd.DataFrame(dict(self), index=self._obj_view.index)

    def to_dict(self):
        return {k: v.tolist() for k, v in pd.compat.iteritems(self)}

    def __str__(self):
        return str(self.to_dict())