Orange.data.Instance.__init__() - Code Metrics - hugobuddel/orange3 - Measure and Improve Code Quality continuously with Scrutinizer

Orange.data.Instance.init() D
last analyzed 2015-12-08 12:38 UTC

↳ Parent: Orange.data.Instance

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	8
dl	0
loc	36
rs	4

from itertools import chain
from numbers import Real, Integral
from ..data.value import Value, Unknown
from math import isnan
import numpy as np
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3


class Instance:
    def __init__(self, domain, data=None, id=None):

        """
        Construct a new data instance.

        :param domain: domain that describes the instance's variables
        :type domain: Orange.data.Domain
        :param data: instance's values
        :type data: Orange.data.Instance or a sequence of values
        :param id: instance id
        :type id: hashable value
        """
        if data is None and isinstance(domain, Instance):
            data = domain
            domain = data.domain

        self._domain = domain
        if data is None:
            self._x = np.repeat(Unknown, len(domain.attributes))
            self._y = np.repeat(Unknown, len(domain.class_vars))
            self._metas = np.array([var.Unknown for var in domain.metas],
                                   dtype=object)
            self._weight = 1
        elif isinstance(data, Instance) and data.domain == domain:
            self._x = np.array(data._x)
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent
            self._y = np.array(data._y)
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent
            self._metas = np.array(data._metas)
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent
            self._weight = data._weight
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent
        else:
            self._x, self._y, self._metas = domain.convert(data)
            self._weight = 1

        if id is not None:
            self.id = id
        else:
            from Orange.data import Table
            self.id = Table.new_id()

    @property
    def domain(self):
        """The domain describing the instance's values."""
        return self._domain

    @property
    def x(self):
        """
        Instance's attributes as a 1-dimensional numpy array whose length
        equals `len(self.domain.attributes)`.
        """
        return self._x

    @property
    def y(self):
        """
        Instance's classes as a 1-dimensional numpy array whose length
        equals `len(self.domain.attributes)`.
        """
        return self._y

    @property
    def metas(self):
        """
        Instance's meta attributes as a 1-dimensional numpy array whose length
        equals `len(self.domain.attributes)`.
        """
        return self._metas

    @property
    def list(self):
        """
        All instance's values, including attributes, classes and meta
        attributes, as a list whose length equals `len(self.domain.attributes)
        + len(self.domain.class_vars) + len(self.domain.metas)`.
        """
        n_self, n_metas = len(self), len(self._metas)
        return [self[i].value if i < n_self else self[n_self - i - 1].value
                for i in range(n_self + n_metas)]

    @property
    def weight(self):
        """The weight of the data instance. Default is 1."""
        return self._weight

    @weight.setter
    def weight(self, weight):
        self._weight = weight

    def __setitem__(self, key, value):
        if not isinstance(key, Integral):
            key = self._domain.index(key)
        value = self._domain[key].to_val(value)
        if key >= 0 and not isinstance(value, (int, float)):
            raise TypeError("Expected primitive value, got '%s'" %
                            type(value).__name__)

        if 0 <= key < len(self._domain.attributes):
            self._x[key] = value
        elif len(self._domain.attributes) <= key:
            self._y[key - len(self.domain.attributes)] = value
        else:
            self._metas[-1 - key] = value

    def __getitem__(self, key, key_id=None, key_var=None):
        # key_id can explicitly be given to prevent the extra dictionary
        # lookup. The derived LazyRowInstance passes the parameter, because
        # the key_id is already looked up there. key_var is included for
        # compatibility.
        if key_id is None:
            if not isinstance(key, Integral):
                key = self._domain.index(key)
        else:
            key = key_id

        if 0 <= key < len(self._domain.attributes):
            value = self._x[key]
        elif key >= len(self._domain.attributes):
            value = self._y[key - len(self.domain.attributes)]
        else:
            value = self._metas[-1 - key]
        return Value(self._domain[key], value)

    #TODO Should we return an instance of `object` if we have a meta attribute

    #     that is not Discrete or Continuous? E.g. when we have strings, we'd
    #     like to be able to use startswith, lower etc...
    #     Or should we even return Continuous as floats and use Value only
    #     for discrete attributes?!
    #     Same in Table.__getitem__

    @staticmethod
    def str_values(data, variables, limit=True):
        if limit:
            s = ", ".join(var.str_val(val)
                          for var, val in zip(variables, data[:5]))
            if len(data) > 5:
                s += ", ..."
            return s
        else:
            return ", ".join(var.str_val(val)
                             for var, val in zip(variables, data))

    def _str(self, limit):
        s = "[" + self.str_values(self._x, self._domain.attributes, limit)
        if self._domain.class_vars:
            s += " | " + \
                 self.str_values(self._y, self._domain.class_vars, limit)
        s += "]"
        if self._domain.metas:
            s += " {" + \
                 self.str_values(self._metas, self._domain.metas, limit) + \
                 "}"
        return s

    def __str__(self):
        return self._str(False)

    def __repr__(self):
        return self._str(True)

    def __eq__(self, other):
        if not isinstance(other, Instance):
            other = Instance(self._domain, other)

        def same(x1, x2):
            nan1 = np.isnan(x1)
            nan2 = np.isnan(x2)
            return np.array_equal(nan1, nan2) and \
                   np.array_equal(x1[~nan1], x2[~nan2])

        return same(self._x, other._x) and same(self._y, other._y) \
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent
               and all(m1 == m2 or
                       type(m1) == type(m2) == float and isnan(m1) and isnan(m2)
                       for m1, m2 in zip(self._metas, other._metas))
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent

    def __iter__(self):
        return chain(iter(self._x), iter(self._y))

    def values(self):
        return (Value(var, val)
                for var, val in zip(self.domain.variables, self))

    def __len__(self):
        return len(self._x) + len(self._y)

    def attributes(self):
        """Return iterator over the instance's attributes"""
        return iter(self._x)

    def classes(self):
        """Return iterator over the instance's class attributes"""
        return iter(self._y)

    # A helper function for get_class and set_class
    def _check_single_class(self):
        if not self._domain.class_vars:
            raise TypeError("Domain has no class variable")
        elif len(self._domain.class_vars) > 1:
            raise TypeError("Domain has multiple class variables")

    def get_class(self):
        """
        Return the class value as an instance of :obj:`Orange.data.Value`.
        Throws an exception if there are multiple classes.
        """
        self._check_single_class()
        return Value(self._domain.class_var, self._y[0])

    def get_classes(self):
        """
        Return the class value as a list of instances of
        :obj:`Orange.data.Value`.
        """
        return (Value(var, value)
                for var, value in zip(self._domain.class_vars, self._y))

    def set_class(self, value):
        """
        Set the instance's class. Throws an exception if there are multiple
        classes.
        """
        self._check_single_class()
        if not isinstance(value, Real):
            self._y[0] = self._domain.class_var.to_val(value)
        else:
            self._y[0] = value


GitHub Access Token became invalid

Orange.data.Instance.init() D
last analyzed 2015-12-08 12:38 UTC

Complexity

Size

Duplication

1. Missing Dependencies

2. Missing init.py files

1			from itertools import chain
2			from numbers import Real, Integral
3			from ..data.value import Value, Unknown
4			from math import isnan
5			import numpy as np
			0 ignored issues – show Configuration introduced 2015-12-02 09:15 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...
6
7
8			class Instance:
9			def __init__(self, domain, data=None, id=None):
			0 ignored issues – show Bug Best Practice introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report This seems to re-define the built-in `id`. It is generally discouraged to redefine built-ins as this makes code very hard to read. Loading history...
10			"""
11			Construct a new data instance.
12
13			:param domain: domain that describes the instance's variables
14			:type domain: Orange.data.Domain
15			:param data: instance's values
16			:type data: Orange.data.Instance or a sequence of values
17			:param id: instance id
18			:type id: hashable value
19			"""
20			if data is None and isinstance(domain, Instance):
21			data = domain
22			domain = data.domain
23
24			self._domain = domain
25			if data is None:
26			self._x = np.repeat(Unknown, len(domain.attributes))
27			self._y = np.repeat(Unknown, len(domain.class_vars))
28			self._metas = np.array([var.Unknown for var in domain.metas],
29			dtype=object)
30			self._weight = 1
31			elif isinstance(data, Instance) and data.domain == domain:
32			self._x = np.array(data._x)
			0 ignored issues – show Coding Style Best Practice introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report It seems like `_x` was declared protected and should not be accessed from this context. Prefixing a member variable `_` is usually regarded as the equivalent of declaring it with protected visibility that exists in other languages. Consequentially, such a member should only be accessed from the same class or a child class: class MyParent: def __init__(self): self._x = 1; self.y = 2; class MyChild(MyParent): def some_method(self): return self._x # Ok, since accessed from a child class class AnotherClass: def some_method(self, instance_of_my_child): return instance_of_my_child._x # Would be flagged as AnotherClass is not # a child class of MyParent Loading history...
33			self._y = np.array(data._y)
			0 ignored issues – show Coding Style Best Practice introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report It seems like `_y` was declared protected and should not be accessed from this context. Prefixing a member variable `_` is usually regarded as the equivalent of declaring it with protected visibility that exists in other languages. Consequentially, such a member should only be accessed from the same class or a child class: class MyParent: def __init__(self): self._x = 1; self.y = 2; class MyChild(MyParent): def some_method(self): return self._x # Ok, since accessed from a child class class AnotherClass: def some_method(self, instance_of_my_child): return instance_of_my_child._x # Would be flagged as AnotherClass is not # a child class of MyParent Loading history...
34			self._metas = np.array(data._metas)
			0 ignored issues – show Coding Style Best Practice introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report It seems like `_metas` was declared protected and should not be accessed from this context. Prefixing a member variable `_` is usually regarded as the equivalent of declaring it with protected visibility that exists in other languages. Consequentially, such a member should only be accessed from the same class or a child class: class MyParent: def __init__(self): self._x = 1; self.y = 2; class MyChild(MyParent): def some_method(self): return self._x # Ok, since accessed from a child class class AnotherClass: def some_method(self, instance_of_my_child): return instance_of_my_child._x # Would be flagged as AnotherClass is not # a child class of MyParent Loading history...
35			self._weight = data._weight
			0 ignored issues – show Coding Style Best Practice introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report It seems like `_weight` was declared protected and should not be accessed from this context. Prefixing a member variable `_` is usually regarded as the equivalent of declaring it with protected visibility that exists in other languages. Consequentially, such a member should only be accessed from the same class or a child class: class MyParent: def __init__(self): self._x = 1; self.y = 2; class MyChild(MyParent): def some_method(self): return self._x # Ok, since accessed from a child class class AnotherClass: def some_method(self, instance_of_my_child): return instance_of_my_child._x # Would be flagged as AnotherClass is not # a child class of MyParent Loading history...
36			else:
37			self._x, self._y, self._metas = domain.convert(data)
38			self._weight = 1
39
40			if id is not None:
41			self.id = id
42			else:
43			from Orange.data import Table
44			self.id = Table.new_id()
45
46			@property
47			def domain(self):
48			"""The domain describing the instance's values."""
49			return self._domain
50
51			@property
52			def x(self):
53			"""
54			Instance's attributes as a 1-dimensional numpy array whose length
55			equals `len(self.domain.attributes)`.
56			"""
57			return self._x
58
59			@property
60			def y(self):
61			"""
62			Instance's classes as a 1-dimensional numpy array whose length
63			equals `len(self.domain.attributes)`.
64			"""
65			return self._y
66
67			@property
68			def metas(self):
69			"""
70			Instance's meta attributes as a 1-dimensional numpy array whose length
71			equals `len(self.domain.attributes)`.
72			"""
73			return self._metas
74
75			@property
76			def list(self):
77			"""
78			All instance's values, including attributes, classes and meta
79			attributes, as a list whose length equals `len(self.domain.attributes)
80			+ len(self.domain.class_vars) + len(self.domain.metas)`.
81			"""
82			n_self, n_metas = len(self), len(self._metas)
83			return [self[i].value if i < n_self else self[n_self - i - 1].value
84			for i in range(n_self + n_metas)]
85
86			@property
87			def weight(self):
88			"""The weight of the data instance. Default is 1."""
89			return self._weight
90
91			@weight.setter
92			def weight(self, weight):
93			self._weight = weight
94
95			def __setitem__(self, key, value):
96			if not isinstance(key, Integral):
97			key = self._domain.index(key)
98			value = self._domain[key].to_val(value)
99			if key >= 0 and not isinstance(value, (int, float)):
100			raise TypeError("Expected primitive value, got '%s'" %
101			type(value).__name__)
102
103			if 0 <= key < len(self._domain.attributes):
104			self._x[key] = value
105			elif len(self._domain.attributes) <= key:
106			self._y[key - len(self.domain.attributes)] = value
107			else:
108			self._metas[-1 - key] = value
109
110			def __getitem__(self, key, key_id=None, key_var=None):
111			# key_id can explicitly be given to prevent the extra dictionary
112			# lookup. The derived LazyRowInstance passes the parameter, because
113			# the key_id is already looked up there. key_var is included for
114			# compatibility.
115			if key_id is None:
116			if not isinstance(key, Integral):
117			key = self._domain.index(key)
118			else:
119			key = key_id
120
121			if 0 <= key < len(self._domain.attributes):
122			value = self._x[key]
123			elif key >= len(self._domain.attributes):
124			value = self._y[key - len(self.domain.attributes)]
125			else:
126			value = self._metas[-1 - key]
127			return Value(self._domain[key], value)
128
129			#TODO Should we return an instance of `object` if we have a meta attribute
			0 ignored issues – show Coding Style introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report `TODO` and `FIXME` comments should generally be avoided. Loading history...
130			# that is not Discrete or Continuous? E.g. when we have strings, we'd
131			# like to be able to use startswith, lower etc...
132			# Or should we even return Continuous as floats and use Value only
133			# for discrete attributes?!
134			# Same in Table.__getitem__
135
136			@staticmethod
137			def str_values(data, variables, limit=True):
138			if limit:
139			s = ", ".join(var.str_val(val)
140			for var, val in zip(variables, data[:5]))
141			if len(data) > 5:
142			s += ", ..."
143			return s
144			else:
145			return ", ".join(var.str_val(val)
146			for var, val in zip(variables, data))
147
148			def _str(self, limit):
149			s = "[" + self.str_values(self._x, self._domain.attributes, limit)
150			if self._domain.class_vars:
151			s += " \| " + \
152			self.str_values(self._y, self._domain.class_vars, limit)
153			s += "]"
154			if self._domain.metas:
155			s += " {" + \
156			self.str_values(self._metas, self._domain.metas, limit) + \
157			"}"
158			return s
159
160			def __str__(self):
161			return self._str(False)
162
163			def __repr__(self):
164			return self._str(True)
165
166			def __eq__(self, other):
167			if not isinstance(other, Instance):
168			other = Instance(self._domain, other)
169
170			def same(x1, x2):
171			nan1 = np.isnan(x1)
172			nan2 = np.isnan(x2)
173			return np.array_equal(nan1, nan2) and \
174			np.array_equal(x1[~nan1], x2[~nan2])
175
176			return same(self._x, other._x) and same(self._y, other._y) \
			0 ignored issues – show Coding Style Best Practice introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report It seems like `_x` was declared protected and should not be accessed from this context. Prefixing a member variable `_` is usually regarded as the equivalent of declaring it with protected visibility that exists in other languages. Consequentially, such a member should only be accessed from the same class or a child class: class MyParent: def __init__(self): self._x = 1; self.y = 2; class MyChild(MyParent): def some_method(self): return self._x # Ok, since accessed from a child class class AnotherClass: def some_method(self, instance_of_my_child): return instance_of_my_child._x # Would be flagged as AnotherClass is not # a child class of MyParent Loading history... Coding Style Best Practice introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report It seems like `_y` was declared protected and should not be accessed from this context. Prefixing a member variable `_` is usually regarded as the equivalent of declaring it with protected visibility that exists in other languages. Consequentially, such a member should only be accessed from the same class or a child class: class MyParent: def __init__(self): self._x = 1; self.y = 2; class MyChild(MyParent): def some_method(self): return self._x # Ok, since accessed from a child class class AnotherClass: def some_method(self, instance_of_my_child): return instance_of_my_child._x # Would be flagged as AnotherClass is not # a child class of MyParent Loading history...
177			and all(m1 == m2 or
178			type(m1) == type(m2) == float and isnan(m1) and isnan(m2)
179			for m1, m2 in zip(self._metas, other._metas))
			0 ignored issues – show Coding Style Best Practice introduced 2015-12-02 09:15 UTC by Report Bug Copy Issue Report It seems like `_metas` was declared protected and should not be accessed from this context. Prefixing a member variable `_` is usually regarded as the equivalent of declaring it with protected visibility that exists in other languages. Consequentially, such a member should only be accessed from the same class or a child class: class MyParent: def __init__(self): self._x = 1; self.y = 2; class MyChild(MyParent): def some_method(self): return self._x # Ok, since accessed from a child class class AnotherClass: def some_method(self, instance_of_my_child): return instance_of_my_child._x # Would be flagged as AnotherClass is not # a child class of MyParent Loading history...
180
181			def __iter__(self):
182			return chain(iter(self._x), iter(self._y))
183
184			def values(self):
185			return (Value(var, val)
186			for var, val in zip(self.domain.variables, self))
187
188			def __len__(self):
189			return len(self._x) + len(self._y)
190
191			def attributes(self):
192			"""Return iterator over the instance's attributes"""
193			return iter(self._x)
194
195			def classes(self):
196			"""Return iterator over the instance's class attributes"""
197			return iter(self._y)
198
199			# A helper function for get_class and set_class
200			def _check_single_class(self):
201			if not self._domain.class_vars:
202			raise TypeError("Domain has no class variable")
203			elif len(self._domain.class_vars) > 1:
204			raise TypeError("Domain has multiple class variables")
205
206			def get_class(self):
207			"""
208			Return the class value as an instance of :obj:`Orange.data.Value`.
209			Throws an exception if there are multiple classes.
210			"""
211			self._check_single_class()
212			return Value(self._domain.class_var, self._y[0])
213
214			def get_classes(self):
215			"""
216			Return the class value as a list of instances of
217			:obj:`Orange.data.Value`.
218			"""
219			return (Value(var, value)
220			for var, value in zip(self._domain.class_vars, self._y))
221
222			def set_class(self, value):
223			"""
224			Set the instance's class. Throws an exception if there are multiple
225			classes.
226			"""
227			self._check_single_class()
228			if not isinstance(value, Real):
229			self._y[0] = self._domain.class_var.to_val(value)
230			else:
231			self._y[0] = value
232

hugobuddel / orange3

GitHub Access Token became invalid

Orange.data.Instance.__init__() D last analyzed 2015-12-08 12:38 UTC

Complexity

Size

Duplication

1. Missing Dependencies

2. Missing __init__.py files

Duplication Side-by-Side

Filter issues like

Orange.data.Instance.init() D
last analyzed 2015-12-08 12:38 UTC

2. Missing init.py files