From 72bd705491a1f0b9190bf430880a56dff8d78259 Mon Sep 17 00:00:00 2001 From: Philippe Proulx Date: Wed, 13 Sep 2017 19:05:29 -0400 Subject: [PATCH] bt2: values: remove public `value` getter MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit The public `value` getter (e.g., `my_int_value.value`) is redundant here since the `bt2.values` object already act like their Python equivalent. If you need an `int` value out of a `bt2.IntegerValue` object, for example, you can just use `int(bt_value)` instead of `bt_value.value`. We keep the `value` setter because this is used to set the underlying raw value. Internally, we keep the private `_value` getter to access the object's raw value. In the tests, we copy the value to modify instead of using the `value` property with this pattern: orig_value = copy.copy(value) # modify value self.assertEqual(value, orig_value) Signed-off-by: Philippe Proulx Signed-off-by: Jérémie Galarneau --- bindings/python/bt2/bt2/values.py | 132 ++++++++++++----------- tests/bindings/python/bt2/test_values.py | 52 +++------ 2 files changed, 80 insertions(+), 104 deletions(-) diff --git a/bindings/python/bt2/bt2/values.py b/bindings/python/bt2/bt2/values.py index 26444e1a..735aeed9 100644 --- a/bindings/python/bt2/bt2/values.py +++ b/bindings/python/bt2/bt2/values.py @@ -131,7 +131,7 @@ class _Value(object._Object, object._Freezable, metaclass=abc.ABCMeta): class _BasicCopy: def __copy__(self): - return self.__class__(self.value) + return self.__class__(self._value) def __deepcopy__(self, memo): copy = self.__copy__() @@ -144,7 +144,7 @@ class _NumericValue(_Value, _BasicCopy): @staticmethod def _extract_value(other): if isinstance(other, _NumericValue): - return other.value + return other._value if other is True or other is False: return other @@ -161,27 +161,27 @@ class _NumericValue(_Value, _BasicCopy): raise TypeError("'{}' object is not a number object".format(other.__class__.__name__)) def __int__(self): - return int(self.value) + return int(self._value) def __float__(self): - return float(self.value) + return float(self._value) def __str__(self): - return str(self.value) + return str(self._value) def __lt__(self, other): if not isinstance(other, numbers.Number): raise TypeError('unorderable types: {}() < {}()'.format(self.__class__.__name__, other.__class__.__name__)) - return self.value < float(other) + return self._value < float(other) def __le__(self, other): if not isinstance(other, numbers.Number): raise TypeError('unorderable types: {}() <= {}()'.format(self.__class__.__name__, other.__class__.__name__)) - return self.value <= float(other) + return self._value <= float(other) def _spec_eq(self, other): pass @@ -190,67 +190,67 @@ class _NumericValue(_Value, _BasicCopy): if not isinstance(other, numbers.Number): return False - return self.value == complex(other) + return self._value == complex(other) def __rmod__(self, other): - return self._extract_value(other) % self.value + return self._extract_value(other) % self._value def __mod__(self, other): - return self.value % self._extract_value(other) + return self._value % self._extract_value(other) def __rfloordiv__(self, other): - return self._extract_value(other) // self.value + return self._extract_value(other) // self._value def __floordiv__(self, other): - return self.value // self._extract_value(other) + return self._value // self._extract_value(other) def __round__(self, ndigits=None): if ndigits is None: - return round(self.value) + return round(self._value) else: - return round(self.value, ndigits) + return round(self._value, ndigits) def __ceil__(self): - return math.ceil(self.value) + return math.ceil(self._value) def __floor__(self): - return math.floor(self.value) + return math.floor(self._value) def __trunc__(self): - return int(self.value) + return int(self._value) def __abs__(self): - return abs(self.value) + return abs(self._value) def __add__(self, other): - return self.value + self._extract_value(other) + return self._value + self._extract_value(other) def __radd__(self, other): return self.__add__(other) def __neg__(self): - return -self.value + return -self._value def __pos__(self): - return +self.value + return +self._value def __mul__(self, other): - return self.value * self._extract_value(other) + return self._value * self._extract_value(other) def __rmul__(self, other): return self.__mul__(other) def __truediv__(self, other): - return self.value / self._extract_value(other) + return self._value / self._extract_value(other) def __rtruediv__(self, other): - return self._extract_value(other) / self.value + return self._extract_value(other) / self._value def __pow__(self, exponent): - return self.value ** self._extract_value(exponent) + return self._value ** self._extract_value(exponent) def __rpow__(self, base): - return self._extract_value(base) ** self.value + return self._extract_value(base) ** self._value def __iadd__(self, other): self.value = self + other @@ -283,37 +283,37 @@ class _NumericValue(_Value, _BasicCopy): class _IntegralValue(_NumericValue, numbers.Integral): def __lshift__(self, other): - return self.value << self._extract_value(other) + return self._value << self._extract_value(other) def __rlshift__(self, other): - return self._extract_value(other) << self.value + return self._extract_value(other) << self._value def __rshift__(self, other): - return self.value >> self._extract_value(other) + return self._value >> self._extract_value(other) def __rrshift__(self, other): - return self._extract_value(other) >> self.value + return self._extract_value(other) >> self._value def __and__(self, other): - return self.value & self._extract_value(other) + return self._value & self._extract_value(other) def __rand__(self, other): - return self._extract_value(other) & self.value + return self._extract_value(other) & self._value def __xor__(self, other): - return self.value ^ self._extract_value(other) + return self._value ^ self._extract_value(other) def __rxor__(self, other): - return self._extract_value(other) ^ self.value + return self._extract_value(other) ^ self._value def __or__(self, other): - return self.value | self._extract_value(other) + return self._value | self._extract_value(other) def __ror__(self, other): - return self._extract_value(other) | self.value + return self._extract_value(other) | self._value def __invert__(self): - return ~self.value + return ~self._value def __ilshift__(self, other): self.value = self << other @@ -354,17 +354,17 @@ class BoolValue(_Value, _BasicCopy): def _spec_eq(self, other): if isinstance(other, numbers.Number): - return self.value == bool(other) + return self._value == bool(other) def __bool__(self): - return self.value + return self._value def __str__(self): - return str(self.value) + return str(self._value) def _value_to_bool(self, value): if isinstance(value, BoolValue): - value = value.value + value = value._value if not isinstance(value, bool): raise TypeError("'{}' object is not a 'bool' or 'BoolValue' object".format(value.__class__)) @@ -372,16 +372,17 @@ class BoolValue(_Value, _BasicCopy): return int(value) @property - def value(self): + def _value(self): status, value = native_bt.value_bool_get(self._ptr) assert(status == native_bt.VALUE_STATUS_OK) return value > 0 - @value.setter - def value(self, value): + def _set_value(self, value): status = native_bt.value_bool_set(self._ptr, self._value_to_bool(value)) self._handle_status(status) + value = property(fset=_set_value) + class IntegerValue(_IntegralValue): _NAME = 'Integer' @@ -404,16 +405,17 @@ class IntegerValue(_IntegralValue): return value @property - def value(self): + def _value(self): status, value = native_bt.value_integer_get(self._ptr) assert(status == native_bt.VALUE_STATUS_OK) return value - @value.setter - def value(self, value): + def _set_value(self, value): status = native_bt.value_integer_set(self._ptr, self._value_to_int(value)) self._handle_status(status) + value = property(fset=_set_value) + class FloatValue(_RealValue): _NAME = 'Floating point number' @@ -435,17 +437,18 @@ class FloatValue(_RealValue): return float(value) @property - def value(self): + def _value(self): status, value = native_bt.value_float_get(self._ptr) assert(status == native_bt.VALUE_STATUS_OK) return value - @value.setter - def value(self, value): + def _set_value(self, value): value = self._value_to_float(value) status = native_bt.value_float_set(self._ptr, value) self._handle_status(status) + value = property(fset=_set_value) + @functools.total_ordering class StringValue(_BasicCopy, collections.abc.Sequence, _Value): @@ -462,48 +465,49 @@ class StringValue(_BasicCopy, collections.abc.Sequence, _Value): def _value_to_str(self, value): if isinstance(value, self.__class__): - value = value.value + value = value._value utils._check_str(value) return value @property - def value(self): + def _value(self): status, value = native_bt.value_string_get(self._ptr) assert(status == native_bt.VALUE_STATUS_OK) return value - @value.setter - def value(self, value): + def _set_value(self, value): status = native_bt.value_string_set(self._ptr, self._value_to_str(value)) self._handle_status(status) + value = property(fset=_set_value) + def _spec_eq(self, other): try: - return self.value == self._value_to_str(other) + return self._value == self._value_to_str(other) except: return def __le__(self, other): - return self.value <= self._value_to_str(other) + return self._value <= self._value_to_str(other) def __lt__(self, other): - return self.value < self._value_to_str(other) + return self._value < self._value_to_str(other) def __bool__(self): - return bool(self.value) + return bool(self._value) def __str__(self): - return self.value + return self._value def __getitem__(self, index): - return self.value[index] + return self._value[index] def __len__(self): - return len(self.value) + return len(self._value) def __iadd__(self, value): - curvalue = self.value + curvalue = self._value curvalue += self._value_to_str(value) self.value = curvalue return self @@ -615,7 +619,7 @@ class ArrayValue(_Container, collections.abc.MutableSequence, _Value): for elem in self: if isinstance(elem, StringValue): - strings.append(repr(elem.value)) + strings.append(repr(elem._value)) else: strings.append(str(elem)) @@ -727,7 +731,7 @@ class MapValue(_Container, collections.abc.MutableMapping, _Value): for key, elem in self.items(): if isinstance(elem, StringValue): - value = repr(elem.value) + value = repr(elem._value) else: value = str(elem) diff --git a/tests/bindings/python/bt2/test_values.py b/tests/bindings/python/bt2/test_values.py index 57fd682b..55c3a42b 100644 --- a/tests/bindings/python/bt2/test_values.py +++ b/tests/bindings/python/bt2/test_values.py @@ -60,9 +60,6 @@ class _TestNumericValue(_TestFrozenSimple, _TestCopySimple): rvexc = None comp_value = rhs - if type(rhs) in (bt2.BoolValue, bt2.IntegerValue, bt2.FloatValue): - comp_value = rhs.value - try: r = op(self._def, rhs) except Exception as e: @@ -129,9 +126,9 @@ class _TestNumericValue(_TestFrozenSimple, _TestCopySimple): self.assertEqual(self._def.addr, addr_before) def _test_unaryop_value_same(self, op): - value_before = self._def.value + value_before = copy.copy(self._def) self._unaryop(op) - self.assertEqual(self._def.value, value_before) + self.assertEqual(self._def, value_before) def _test_binop_type(self, op, rhs): r, rv = self._binop(op, rhs) @@ -159,9 +156,9 @@ class _TestNumericValue(_TestFrozenSimple, _TestCopySimple): self.assertEqual(self._def.addr, addr_before) def _test_binop_lhs_value_same(self, op, rhs): - value_before = self._def.value + value_before = copy.copy(self._def) r, rv = self._binop(op, rhs) - self.assertEqual(self._def.value, value_before) + self.assertEqual(self._def, value_before) def _test_binop_invalid_unknown(self, op): if op in _COMP_BINOPS: @@ -846,21 +843,17 @@ class BoolValueTestCase(_TestFrozenSimple, _TestCopySimple, unittest.TestCase): self.assertFalse(b) def test_create_false(self): - self.assertFalse(self._f.value) self.assertFalse(self._f) def test_create_true(self): - self.assertTrue(self._t.value) self.assertTrue(self._t) def test_create_from_vfalse(self): b = bt2.BoolValue(self._f) - self.assertFalse(b.value) self.assertFalse(b) def test_create_from_vtrue(self): b = bt2.BoolValue(self._t) - self.assertTrue(b.value) self.assertTrue(b) def test_create_from_int_non_zero(self): @@ -948,14 +941,12 @@ class IntegerValueTestCase(_TestNumericValue, unittest.TestCase): def test_create_default(self): i = bt2.IntegerValue() - self.assertEqual(i.value, 0) + self.assertEqual(i, 0) def test_create_pos(self): - self.assertEqual(self._ip.value, self._pv) self.assertEqual(self._ip, self._pv) def test_create_neg(self): - self.assertEqual(self._in.value, self._nv) self.assertEqual(self._in, self._nv) def test_create_pos_too_big(self): @@ -972,12 +963,10 @@ class IntegerValueTestCase(_TestNumericValue, unittest.TestCase): def test_create_from_false(self): i = bt2.IntegerValue(False) - self.assertFalse(i.value) self.assertFalse(i) def test_create_from_true(self): i = bt2.IntegerValue(True) - self.assertTrue(i.value) self.assertTrue(i) def test_create_from_float(self): @@ -1004,37 +993,31 @@ class IntegerValueTestCase(_TestNumericValue, unittest.TestCase): raw = True self._def.value = raw self.assertEqual(self._def, raw) - self.assertEqual(self._def.value, raw) def test_assign_false(self): raw = False self._def.value = raw self.assertEqual(self._def, raw) - self.assertEqual(self._def.value, raw) def test_assign_pos_int(self): raw = 477 self._def.value = raw self.assertEqual(self._def, raw) - self.assertEqual(self._def.value, raw) def test_assign_neg_int(self): raw = -13 self._def.value = raw self.assertEqual(self._def, raw) - self.assertEqual(self._def.value, raw) def test_assign_vint(self): raw = 999 self._def.value = bt2.create_value(raw) self.assertEqual(self._def, raw) - self.assertEqual(self._def.value, raw) def test_assign_vfloat(self): raw = 123.456 self._def.value = bt2.create_value(raw) self.assertEqual(self._def, int(raw)) - self.assertEqual(self._def.value, int(raw)) _inject_numeric_testing_methods(IntegerValueTestCase) @@ -1065,14 +1048,12 @@ class FloatValueTestCase(_TestNumericValue, unittest.TestCase): def test_create_default(self): f = bt2.FloatValue() - self.assertEqual(f.value, 0.0) + self.assertEqual(f, 0.0) def test_create_pos(self): - self.assertEqual(self._fp.value, self._pv) self.assertEqual(self._fp, self._pv) def test_create_neg(self): - self.assertEqual(self._fn.value, self._nv) self.assertEqual(self._fn, self._nv) def test_create_from_vint(self): @@ -1081,28 +1062,26 @@ class FloatValueTestCase(_TestNumericValue, unittest.TestCase): def test_create_from_false(self): f = bt2.FloatValue(False) - self.assertFalse(f.value) self.assertFalse(f) def test_create_from_true(self): f = bt2.FloatValue(True) - self.assertTrue(f.value) self.assertTrue(f) def test_create_from_int(self): raw = 17 f = bt2.FloatValue(raw) - self.assertEqual(f.value, float(raw)) + self.assertEqual(f, float(raw)) def test_create_from_vint(self): raw = 17 f = bt2.FloatValue(bt2.create_value(raw)) - self.assertEqual(f.value, float(raw)) + self.assertEqual(f, float(raw)) def test_create_from_vfloat(self): raw = 17.17 f = bt2.FloatValue(bt2.create_value(raw)) - self.assertEqual(f.value, raw) + self.assertEqual(f, raw) def test_create_from_unknown(self): class A: @@ -1118,42 +1097,35 @@ class FloatValueTestCase(_TestNumericValue, unittest.TestCase): def test_assign_true(self): self._def.value = True self.assertTrue(self._def) - self.assertTrue(self._def.value) def test_assign_false(self): self._def.value = False self.assertFalse(self._def) - self.assertFalse(self._def.value) def test_assign_pos_int(self): raw = 477 self._def.value = raw self.assertEqual(self._def, float(raw)) - self.assertEqual(self._def.value, float(raw)) def test_assign_neg_int(self): raw = -13 self._def.value = raw self.assertEqual(self._def, float(raw)) - self.assertEqual(self._def.value, float(raw)) def test_assign_vint(self): raw = 999 self._def.value = bt2.create_value(raw) self.assertEqual(self._def, float(raw)) - self.assertEqual(self._def.value, float(raw)) def test_assign_float(self): raw = -19.23 self._def.value = raw self.assertEqual(self._def, raw) - self.assertEqual(self._def.value, raw) def test_assign_vfloat(self): raw = 101.32 self._def.value = bt2.create_value(raw) self.assertEqual(self._def, raw) - self.assertEqual(self._def.value, raw) def test_invalid_lshift(self): self._test_invalid_op(lambda: self._def << 23) @@ -1191,17 +1163,17 @@ class StringValueTestCase(_TestCopySimple, _TestFrozenSimple, unittest.TestCase) def test_create_default(self): s = bt2.StringValue() - self.assertEqual(s.value, '') + self.assertEqual(s, '') def test_create_from_str(self): raw = 'liberté' s = bt2.StringValue(raw) - self.assertEqual(s.value, raw) + self.assertEqual(s, raw) def test_create_from_vstr(self): raw = 'liberté' s = bt2.StringValue(bt2.create_value(raw)) - self.assertEqual(s.value, raw) + self.assertEqual(s, raw) def test_create_from_unknown(self): class A: -- 2.34.1