#498: Relax numeric conversion to float when reading JSON (#500)

* #498: loosen type requirements in lbsObject

* #498: allow ints for rank size

* #498: add missing import

* #498: handle bool case

* #498: add unit test for rank size

Author: cwschilly

src/lbaf/Model/lbsObject.py

@@ -24,16 +24,16 @@ def __init__(
         self.__index = i
 
         # Nonnegative load required to perform the work of this object
-        if not isinstance(load, float) or load < 0.0:
+        if not isinstance(load, (int, float)) or isinstance(load, bool) or load < 0.0:
             raise TypeError(
                 f"load: incorrect type {type(load)} or value: {load}")
-        self.__load = load
+        self.__load = float(load)
 
         # Nonnegative size required to for memory footprint of this object
-        if not isinstance(size, float) or size < 0.0:
+        if not isinstance(size, (int, float)) or isinstance(size, bool) or size < 0.0:
             raise TypeError(
                 f"size: incorrect type {type(size)} or value: {size}")
-        self.__size = size
+        self.__size = float(size)
 
         # Rank to which object is currently assigned if defined
         if not(r_id is None or isinstance(r_id, int)) or isinstance(r_id, bool):
@@ -62,19 +62,19 @@ def __init__(
         if user_defined:
             # Object size is by definition its memory footprint
             if not isinstance((
-                size := user_defined.get("task_footprint_bytes")), float) or size < 0.0:
+                size := user_defined.get("task_footprint_bytes")), (int, float)) or isinstance(size, bool) or size < 0.0:
                 raise TypeError(
                     f"size: incorrect type {type(size)} or value: {size}")
             else:
-                self.__size = size
+                self.__size = float(size)
 
             # Object overhead is by definition its additional working memory
             if not isinstance((
-                overhead := user_defined.get("task_working_bytes")), float) or overhead < 0.0:
+                overhead := user_defined.get("task_working_bytes")), (int, float)) or isinstance(overhead, bool) or overhead < 0.0:
                 raise TypeError(
                     f"overhead: incorrect type {type(overhead)} or value: {overhead}")
             else:
-                self.__overhead = overhead
+                self.__overhead = float(overhead)
 
         # Sub-phases
         if isinstance(subphases, list) or subphases is None:

src/lbaf/Model/lbsRank.py

@@ -64,13 +64,13 @@ def get_size(self) -> float:
         """Return object size."""
         return self.__size
 
-    def set_size(self, size: float):
+    def set_size(self, size):
         """Set rank working memory, called size."""
         # Nonnegative size required for memory footprint of this rank
-        if not isinstance(size, float) or size < 0.0:
+        if not isinstance(size, (int, float)) or isinstance(size, bool) or size < 0.0:
             raise TypeError(
                 f"size: incorrect type {type(size)} or value: {size}")
-        self.__size = size
+        self.__size = float(size)
 
     def get_metadata(self) -> dict:
         """Return original metadata."""

tests/unit/Model/test_lbs_object.py

@@ -19,7 +19,7 @@ def setUp(self):
         self.simple_obj_001 = Object(i=1, load=2.5, subphases=self.subphases)
         self.simple_obj_002 = Object(i=2, load=4.5, r_id=0)
         self.oc = ObjectCommunicator(i=3, logger=self.logger)
-        self.simple_obj_003 = Object(i=3, load=3.5, r_id=2, comm=self.oc)
+        self.simple_obj_003 = Object(i=3, load=3, r_id=2, comm=self.oc)
         self.sent_objects = {Object(i=0, load=1.0): 2.0, Object(i=1, load=0.5): 1.0, Object(i=4, load=0.5): 2.0,
                              Object(i=3, load=0.5): 1.5}
         self.received_objects = {Object(i=5, load=2.0): 2.0, Object(i=6, load=0.5): 1.0, Object(i=2, load=0.5): 1.0,
@@ -39,14 +39,14 @@ def test_object_initialization_002(self):
 
     def test_object_initialization_003(self):
         self.assertEqual(self.simple_obj_003._Object__index, 3)
-        self.assertEqual(self.simple_obj_003._Object__load, 3.5)
+        self.assertEqual(self.simple_obj_003._Object__load, 3.0)
         self.assertEqual(self.simple_obj_003._Object__rank_id, 2)
         self.assertEqual(self.simple_obj_003._Object__communicator, self.oc)
 
     def test_object_repr(self):
         self.assertEqual(str(self.simple_obj_001), "Object id: 1, load: 2.5")
         self.assertEqual(str(self.simple_obj_002), "Object id: 2, load: 4.5")
-        self.assertEqual(str(self.simple_obj_003), "Object id: 3, load: 3.5")
+        self.assertEqual(str(self.simple_obj_003), "Object id: 3, load: 3.0")
 
     def test_object_get_id(self):
         self.assertEqual(self.simple_obj_001.get_id(), 1)
@@ -56,7 +56,7 @@ def test_object_get_id(self):
     def test_object_get_load(self):
         self.assertEqual(self.simple_obj_001.get_load(), 2.5)
         self.assertEqual(self.simple_obj_002.get_load(), 4.5)
-        self.assertEqual(self.simple_obj_003.get_load(), 3.5)
+        self.assertEqual(self.simple_obj_003.get_load(), 3.0)
 
     def test_object_set_rank_id(self):
         self.simple_obj_001.set_rank_id(15)
@@ -97,10 +97,6 @@ def test_object_load_error(self):
             Object(i=1, load="2.5")
         self.assertEqual(err.exception.args[0], "load: incorrect type <class 'str'> or value: 2.5")
 
-        with self.assertRaises(TypeError) as err:
-            Object(i=2, load=3)
-        self.assertEqual(err.exception.args[0], "load: incorrect type <class 'int'> or value: 3")
-
         with self.assertRaises(TypeError) as err:
             Object(i=3, load=True)
         self.assertEqual(err.exception.args[0], "load: incorrect type <class 'bool'> or value: True")

tests/unit/Model/test_lbs_rank.py

@@ -60,6 +60,15 @@ def test_lbs_rank_get_migratable_load(self):
     def test_lbs_rank_get_sentinel_load(self):
         self.assertEqual(self.rank.get_sentinel_load(), 7.0)
 
+    def test_lbs_rank_set_size(self):
+        self.rank.set_size(3.0)
+        self.assertEqual(self.rank.get_size(), 3.0)
+        self.rank.set_size(3)
+        self.assertEqual(self.rank.get_size(), 3.0)
+        with self.assertRaises(TypeError) as err:
+            self.rank.set_size(True)
+        self.assertEqual(err.exception.args[0], "size: incorrect type <class 'bool'> or value: True")
+
     def test_lbs_rank_get_received_volume_001(self):
         sent_objects = {Object(i=123, load=1.0): 2.0, Object(i=1, load=0.5): 1.0, Object(i=4, load=0.5): 2.0,
                         Object(i=3, load=0.5): 1.5}