bt2: values: remove public `value` getter

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 <eeppeliteloop@gmail.com>
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>

diff --git a/bindings/python/bt2/bt2/values.py b/bindings/python/bt2/bt2/values.py
index 26444e1aad025cbe3da3fb38614f7b35a1739c69..735aeed9e00b6d2c82d58802440b9fb91711e0cd 100644 (file)
--- 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 57fd682b077220aca7836c3b97fc628c606ee64e..55c3a42be3ae79e0001f907b84c2836d8173e582 100644 (file)
--- 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: