PheromoneFlavour: contain Pheromone instead simple tuple

intelligine/simulation/pheromone/PheromoneFlavour.py

 
 class PheromoneFlavour():
 
-    def __init__(self, point_data):
-        self._point_data = point_data
+    @classmethod
+    def new_from_raw_data(cls, raw_data):
+        flavour = {}
+        for category in raw_data:
+            pheromones_by_category = raw_data[category]
+            for type in pheromones_by_category:
+                distance, intensity = pheromones_by_category[type]
+                flavour.update({category: {type: Pheromone(category, type, distance, intensity)}})
+        return cls(flavour)
+
+    def get_raw_data(self):
+        raw_data = {}
+        for category in self._flavour:
+            pheromones_by_category = self._flavour[category]
+            for type in pheromones_by_category:
+                pheromone = pheromones_by_category[type]
+                raw_data.update({category: {type: (pheromone.get_distance(), pheromone.get_intensity())}})
+        return raw_data
+
+    def __init__(self, flavour):
+        self._flavour = flavour
 
     def get_pheromone(self, category, type):
         types = self.get_types(category)
         if type not in types:
             raise NoTypeInPheromone()
-        distance, intensity = types[type]
-        return Pheromone(category, type, distance, intensity)
+        return types[type]
 
     def get_types(self, category):
-        if category not in self._point_data:
+        if category not in self._flavour:
             raise NoCategoryInPheromone()
-        return self._point_data[category]
+        return self._flavour[category]
 
-    def update_pheromone(self, pheromone):
+    def set_pheromone(self, pheromone):
         category = pheromone.get_category()
         type = pheromone.get_type()
 
-        if category not in self._point_data:
-            self._point_data[category] = {}
+        if category not in self._flavour:
+            self._flavour[category] = {}
 
-        self._point_data[category][type] = (pheromone.get_distance(), pheromone.get_intensity())
-
-    def get_raw_data(self):
-        return self._point_data
+        self._flavour[category][type] = pheromone

intelligine/synergy/stigmergy/PheromonesManager.py

                                                          position,
                                                          allow_empty=True,
                                                          empty_value={})
-        return PheromoneFlavour(point_pheromones)
+        return PheromoneFlavour.new_from_raw_data(point_pheromones)
 
         current_check = point_pheromones
         for prepare_key in prepare:
         if apposed_pheromone.get_distance() < position_pheromone.get_distance():
             position_pheromone.set_distance(apposed_pheromone.get_distance())
 
-        flavour.update_pheromone(position_pheromone)
+        flavour.set_pheromone(position_pheromone)
         self.set_flavour(position, flavour)
 
         if apposed_pheromone.get_distance() > position_pheromone.get_distance():

intelligine/tests/simulation/pheromone/TestDirection.py

         if re_init:
             self._context = Context()
         for position in pheromones:
-            self._context.pheromones().set_flavour(position, PheromoneFlavour(pheromones[position]))
+            self._context.pheromones().set_flavour(position, PheromoneFlavour.new_from_raw_data(pheromones[position]))
 
     def _test_direction_for_point(self, pheromones, direction, pheromone_type=PHEROMON_DIR_EXPLO,
                                   reference_point=_p(CENTER), re_init=True):