PropertyView.__delitem__() - Code Metrics - Inspection of "Added a lot of functionality and tests to core." - richlewis42/scikit-chem - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 87dea9...e88bec )

by Rich

created 2016-08-25 13:45 UTC

PropertyView.delitem() A

↳ Parent: PropertyView

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Importance

Changes	2
Bugs	0	Features	2

Metric	Value
c	2
b	0
f	2
dl	0
loc	2
ccs	1
cts	1
cp	1
rs	10
cc	1
crap	1

#! /usr/bin/env python
#
# Copyright (C) 2015-2016 Rich Lewis <[email protected]>
# 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
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3
import pandas as pd
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3


class ChemicalObject(object):

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

    @classmethod
    def from_super(cls, obj):

        """ Converts the class of an object to this class. """

        obj.__class__ = cls
        return obj


class ChemicalObjectView(object):

    """ Abstract iterable view of chemical objects.

    Concrete classes inheriting from it should implement `__getitem__`
    and `__len__`.
    """

    __metaclass__ = ABCMeta

    def __init__(self, owner):
        """ Return a view """
        self.owner = owner

    @abstractmethod
    def __getitem__(self, index):
        # subclass call this, then implement the actual get if None
        if isinstance(index, slice):
            return self.to_list()[index]
        if isinstance(index, (list, tuple)) \
                and all(isinstance(i, bool) for i in index) \
                and len(index) == len(self):
            return [self[i] for i, ix in enumerate(index) if ix]
        elif isinstance(index, (list, tuple)):
            return [self[ix] for ix in index]
        else:
            return None

    @abstractmethod
    def __len__(self):  # pragma: no cover
        pass

    def __iter__(self):
        return ChemicalObjectIterator(self)

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

    @property
    def props(self):
        """ Return a property view of the objects in the view. """

        return MolPropertyView(self)

    def to_list(self):
        """ Return a list of objects in the view. """

        return list(self)

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


class ChemicalObjectIterator(object):

    """  Iterator for chemical object views.  """

    def __init__(self, view):
        """ Create an iterator from a chemical object 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.  Conforms to the dictionary interface.

    Objects inheriting from this should implement the `keys`, `getitem`,
    `setitem` and `delitem` methods."""

    __metaclass__ = ABCMeta

    @abstractmethod
    def keys(self):  # pragma: no cover
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return []

    def get(self, index, default=None):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        if index in self.keys():
            return self[index]
        else:
            return default

    def pop(self, index, default=None):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        if default:
            val = self.get(index, default)
        else:
            val = self[index]
        self.remove(index)
        return val

    def clear(self):
        """ Remove all properties from the object. """
        for idx in self.keys():
            self.remove(idx)

    def items(self):
        """ Return an iterable of key, value pairs. """

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

    def remove(self, key):
        """ Remove a property from the object. """
        self.__delitem__(key)

    @abstractmethod
    def __getitem__(self, key):  # pragma: no cover
        pass

    @abstractmethod
    def __setitem__(self, key, value):  # pragma: no cover
        pass

    @abstractmethod
    def __delitem__(self, key):  # pragma: no cover
        pass

    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):
        """ Return a dict of the properties on the object. """
        return dict(self)

    def to_series(self):
        """ Return a pd.Series of the properties on the object. """
        return pd.Series(self.to_dict())


class PropertyView(View):
    """ Property object wrapper.

     This provides properties for rdkit objects. """

    _reserved = ('origNoImplicit', 'isImplicit')

    def __init__(self, owner):
        """ Initialize a PropertyView.

        Args:
            owner(skchem.ChemicalObject):
                A chemical object with properties, such as `skchem.Atom`."""

        self._owner = owner

    def keys(self):
        """ The available property keys on the object. """

        # pretend not to know about 'reserved' props
        return list(k for k in self._owner.GetPropNames()
                    if (k[:1] != '_' and k not in self._reserved))


    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 strs
        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):
            msg = 'RDKit property keys can only be of type `str`.' \
                  '  Using `{key}` as a `str`.'.format(key=key)
            warnings.warn(msg)
            key = str(key)

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

        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:
            msg = 'RDKit property keys can only be `str`, `int` or `float`. '
            'Using `{value}` as a `str`.'.format(value=value)

            warnings.warn(msg)
            self._owner.SetProp(key, str(value))

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


class MolPropertyView(View):

    """ Mol property wrapper.

    This provides properties for the atom and bond views. """

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

    def keys(self):
        """ The available property keys on the object. """

        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)

    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)):
            print('got dict or series')

            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):

        """ Return a DataFrame of the properties of the view's objects. """

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

    def to_dict(self):

        """ Return a dict of the properties of the view's objects. """

        return {k: v.tolist() for k, v in self.items()}

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


Push — master ( 87dea9...e88bec )

PropertyView.delitem() A

Complexity

Size

Duplication

Code Coverage

Importance

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) 2015-2016 Rich Lewis <[email protected]>
4		# License: 3-clause BSD
5
6	1	"""
7		## skchem.core.base
8
9		Define base classes for scikit chem objects
10		"""
11
12	1	from abc import ABCMeta, abstractmethod
13	1	import warnings
14	1	import numpy as np
		0 ignored issues – show Configuration introduced 2016-05-24 17:01 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...
15	1	import pandas as pd
		0 ignored issues – show Configuration introduced 2016-07-18 17:48 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...
16
17
18	1	class ChemicalObject(object):
19
20		""" A mixin for each chemical object in scikit-chem. """
21
22	1	@classmethod
23		def from_super(cls, obj):
24
25		""" Converts the class of an object to this class. """
26
27	1	obj.__class__ = cls
28	1	return obj
29
30
31	1	class ChemicalObjectView(object):
32
33		""" Abstract iterable view of chemical objects.
34
35		Concrete classes inheriting from it should implement `__getitem__`
36		and `__len__`.
37		"""
38
39	1	__metaclass__ = ABCMeta
40
41	1	def __init__(self, owner):
42		""" Return a view """
43	1	self.owner = owner
44
45	1	@abstractmethod
46		def __getitem__(self, index):
47		# subclass call this, then implement the actual get if None
48	1	if isinstance(index, slice):
49		return self.to_list()[index]
50	1	if isinstance(index, (list, tuple)) \
51		and all(isinstance(i, bool) for i in index) \
52		and len(index) == len(self):
53		return [self[i] for i, ix in enumerate(index) if ix]
54	1	elif isinstance(index, (list, tuple)):
55		return [self[ix] for ix in index]
56		else:
57	1	return None
58
59	1	@abstractmethod
60		def __len__(self): # pragma: no cover
61		pass
62
63	1	def __iter__(self):
64	1	return ChemicalObjectIterator(self)
65
66	1	def __str__(self):
67	1	return str(list(str(obj) for obj in self))
68
69	1	@property
70		def props(self):
71		""" Return a property view of the objects in the view. """
72
73	1	return MolPropertyView(self)
74
75	1	def to_list(self):
76		""" Return a list of objects in the view. """
77
78		return list(self)
79
80	1	def __repr__(self):
81	1	return '<{class_} values="{values}" at {address}>'.format(
82		class_=self.__class__.__name__,
83		values=str(self),
84		address=hex(id(self)))
85
86
87	1	class ChemicalObjectIterator(object):
88
89		""" Iterator for chemical object views. """
90
91	1	def __init__(self, view):
92		""" Create an iterator from a chemical object view. """
93	1	self.view = view
94	1	self._current = 0
95	1	self._high = len(self.view)
96
97	1	def __next__(self):
98	1	if self._current >= self._high:
99	1	raise StopIteration
100		else:
101	1	self._current += 1
102	1	return self.view[self._current - 1]
103
104		# py2 compat
105	1	next = __next__
106
107
108	1	class View(object):
109
110		""" View wrapper interface. Conforms to the dictionary interface.
111
112		Objects inheriting from this should implement the `keys`, `getitem`,
113		`setitem` and `delitem` methods."""
114
115	1	__metaclass__ = ABCMeta
116
117	1	@abstractmethod
118		def keys(self): # pragma: no cover
		0 ignored issues – show Coding Style introduced 2016-08-25 14:00 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
119		return []
120
121	1	def get(self, index, default=None):
		0 ignored issues – show Coding Style introduced 2016-05-15 15:29 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
122	1	if index in self.keys():
123	1	return self[index]
124		else:
125	1	return default
126
127	1	def pop(self, index, default=None):
		0 ignored issues – show Coding Style introduced 2016-05-15 15:29 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
128	1	if default:
129		val = self.get(index, default)
130		else:
131	1	val = self[index]
132	1	self.remove(index)
133	1	return val
134
135	1	def clear(self):
136		""" Remove all properties from the object. """
137	1	for idx in self.keys():
138	1	self.remove(idx)
139
140	1	def items(self):
141		""" Return an iterable of key, value pairs. """
142
143	1	return list((k, self[k]) for k in self.keys())
144
145	1	def remove(self, key):
146		""" Remove a property from the object. """
147	1	self.__delitem__(key)
148
149	1	@abstractmethod
150		def __getitem__(self, key): # pragma: no cover
151		pass
152
153	1	@abstractmethod
154		def __setitem__(self, key, value): # pragma: no cover
155		pass
156
157	1	@abstractmethod
158		def __delitem__(self, key): # pragma: no cover
159		pass
160
161	1	def __iter__(self):
162		return iter(self.keys())
163
164	1	def __str__(self):
165		return str(self.to_dict())
166
167	1	def __len__(self):
168	1	return len(self.keys())
169
170	1	def __repr__(self):
171	1	return '<{klass} values="{values}" at {address}>'.format(
172		klass=self.__class__.__name__,
173		values=str(self),
174		address=hex(id(self)))
175
176	1	def to_dict(self):
177		""" Return a dict of the properties on the object. """
178	1	return dict(self)
179
180	1	def to_series(self):
181		""" Return a pd.Series of the properties on the object. """
182	1	return pd.Series(self.to_dict())
183
184
185	1	class PropertyView(View):
186		""" Property object wrapper.
187
188		This provides properties for rdkit objects. """
189
190	1	_reserved = ('origNoImplicit', 'isImplicit')
191
192		def __init__(self, owner):
193		""" Initialize a PropertyView.
194
195		Args:
196		owner(skchem.ChemicalObject):
197	1	A chemical object with properties, such as `skchem.Atom`."""
198
199	1	self._owner = owner
200
201		def keys(self):
202	1	""" The available property keys on the object. """
203
204	1	# pretend not to know about 'reserved' props
205		return list(k for k in self._owner.GetPropNames()
206		if (k[:1] != '_' and k not in self._reserved))
		0 ignored issues – show Unused Code Coding Style introduced 2016-08-25 14:00 UTC by Report Bug Copy Issue Report There is an unnecessary parenthesis after `if`. Loading history...
207
208	1	def __getitem__(self, key):
209	1
210	1	# we manually work out if it was a float that was stored, as GetProp
211	1	# returns floats and ints set by SetDoubleProp and SetIntProp as strs
212	1	value = self._owner.GetProp(str(key))
213	1	try:
214	1	return int(value)
215	1	except ValueError:
216		try:
217	1	return float(value)
218		except ValueError:
219	1	return value
220	1
221		def __setitem__(self, key, value):
222	1
223	1	if not isinstance(key, str):
224		msg = 'RDKit property keys can only be of type `str`.' \
225	1	' Using `{key}` as a `str`.'.format(key=key)
226		warnings.warn(msg)
227		key = str(key)
228
229		if key[0] == '_' or key in self._reserved:
230	1	msg = '`{value}` is a private RDKit property key. '
231	1	'Using this may have unintended consequences.'.format(value=value)
232	1	warnings.warn(msg)
233	1
234	1	if isinstance(value, str):
235	1	self._owner.SetProp(key, value)
236		elif isinstance(value, (int, np.int64, np.int32)):
237		self._owner.SetIntProp(key, value)
238		elif isinstance(value, (float, np.float64, np.float32)):
239		self._owner.SetDoubleProp(key, value)
240		else:
241		msg = 'RDKit property keys can only be `str`, `int` or `float`. '
242		'Using `{value}` as a `str`.'.format(value=value)
243	1
244	1	warnings.warn(msg)
245		self._owner.SetProp(key, str(value))
246
247	1	def __delitem__(self, index):
248		self._owner.ClearProp(index)
249
250
251		class MolPropertyView(View):
252
253	1	""" Mol property wrapper.
254	1
255		This provides properties for the atom and bond views. """
256	1
257		def __init__(self, obj_view):
258		self._obj_view = obj_view
259	1
260	1	def keys(self):
261	1	""" The available property keys on the object. """
262	1
263		res = set()
264	1	for atom in self._obj_view:
265	1	res = res.union(set(atom.props.keys()))
266		return list(res)
267
268	1	def get(self, key, default=None):
269	1	return pd.Series((a.props.get(key, default) for a in self._obj_view),
270	1	index=self._obj_view.index)
271	1
272		def __getitem__(self, key):
273	1	if key not in self.keys():
274	1	raise KeyError('No atoms have the property set.')
275		return self.get(key, None)
276
277		def __setitem__(self, key, value):
278	1	if isinstance(value, (pd.Series, dict)):
279		print('got dict or series')
		0 ignored issues – show Unused Code Coding Style introduced 2016-08-25 14:00 UTC by Report Bug Copy Issue Report There is an unnecessary parenthesis after `print`. Loading history...
280	1	for idx, val in pd.compat.iteritems(value):
281	1	self._obj_view[int(idx)].props[key] = val
282		else:
283	1	assert len(self._obj_view) == len(value), \
284	1	"Must pass same number of values as atoms."
285	1	for atom, val in zip(self._obj_view, value):
286		atom.props[key] = val
287	1
288		def __delitem__(self, key):
289		for atom in self._obj_view:
290		atom.props.remove(key)
291	1
292		def to_frame(self):
293	1
294		""" Return a DataFrame of the properties of the view's objects. """
295
296		return pd.DataFrame(dict(self), index=self._obj_view.index)
297	1
298		def to_dict(self):
299	1
300	1	""" Return a dict of the properties of the view's objects. """
301
302		return {k: v.tolist() for k, v in self.items()}
303
304		def __str__(self):
305		return str(self.to_dict())
306

richlewis42 / scikit-chem

Push — master ( 87dea9...e88bec )

PropertyView.__delitem__() A

Complexity

Size

Duplication

Code Coverage

Importance

1. Missing Dependencies

2. Missing __init__.py files

1. Missing Dependencies

2. Missing __init__.py files

Duplication Side-by-Side

Filter issues like

PropertyView.delitem() A

2. Missing init.py files

2. Missing init.py files