Simplification of shared data design and usage

perf.py

@@ -21,12 +21,8 @@ from synergine2.simulation import Simulation, Subjects
 def simulate(complexity, subject_count, cycle_count, cores):
     config = Config(dict(complexity=complexity, core=dict(use_x_cores=cores)))
     simulation = Simulation(config)
-
-    simulation.add_to_index(ComputeSubject)
-    simulation.add_to_index(ComputeBehaviour)
-    simulation.add_to_index(ComputeMechanism)
-
     subjects = Subjects(simulation=simulation)
+
     for i in range(subject_count):
         subject = ComputeSubject(
             config=config,

sandbox/perf/simulation.py

@@ -55,7 +55,7 @@ class ComputeBehaviour(SubjectBehaviour):
 
 class ComputeSubject(Subject):
     behaviours_classes = [ComputeBehaviour]
-    data = shared.create(['{id}', 'data'], [])
+    data = shared.create_self('data', lambda: [])
 
     def __init__(
         self,

sandbox/tile/run.py

@@ -30,8 +30,6 @@ def main(map_dir_path: str, seed_value: int=42):
     map_file_path = 'sandbox/tile/{}.tmx'.format(os.path.join(map_dir_path, os.path.basename(map_dir_path)))
 
     simulation = TileStrategySimulation(config, map_file_path=map_file_path)
-    simulation.add_to_index(Man, MoveToBehaviour, MoveToMechanism)
-
     subjects = TileStrategySubjects(simulation=simulation)
 
     for position in ((0, 2),):

sandbox/tile/simulation/subject.py

@@ -5,7 +5,7 @@ from synergine2_xyz.move import MoveToBehaviour
 
 
 class Man(BaseSubject):
-    collections = [
+    start_collections = [
         COLLECTION_ALIVE,
     ]
     behaviours_classes = [

synergine2/base.py

@@ -4,3 +4,12 @@
 class BaseObject(object):
     def repr_debug(self) -> str:
         return type(self).__name__
+
+
+class IdentifiedObject(BaseObject):
+    def __init__(self, *args, **kwargs):
+        self._id = id(self)
+
+    @property
+    def id(self) -> int:
+        return self._id

synergine2/cycle.py

@@ -35,9 +35,6 @@ class CycleManager(BaseObject):
         self.current_cycle = -1
         self.first_cycle = True
 
-        self.subject_mechanisms_cache = {}  # type: typing.Dict[int, typing.Dict[str, SubjectMechanism]]
-        self.subject_behaviours_cache = {}  # type: typing.Dict[int, typing.Dict[str, SubjectBehaviour]]
-
         # TODO NOW: Les processes devront maintenir une liste des subjects qui sont nouveaux.ne connaissent pas
         # Attention a ce qu'in ne soient pas "expose" quand on créer ces subjects au sein du process.
         # Ces subjects ont vocation à adopter l'id du vrau subject tout de suite après leur instanciation
@@ -107,7 +104,7 @@ class CycleManager(BaseObject):
                     str(mechanism_data),
                 ))
 
-            mechanisms_data[mechanism.__class__.__name__] = mechanism_data
+            mechanisms_data[mechanism.__class__] = mechanism_data
 
         behaviours = self.simulation.behaviours.values()
         self.logger.info('{} behaviours to compute'.format(str(len(behaviours))))
@@ -126,7 +123,7 @@ class CycleManager(BaseObject):
                 ))
 
             if behaviour_data:
-                behaviours_data[id(behaviour.__class__)] = behaviour_data
+                behaviours_data[behaviour.__class__] = behaviour_data
 
         return behaviours_data
 
@@ -168,8 +165,7 @@ class CycleManager(BaseObject):
         results_by_processes = self.process_manager.make_them_work(JOB_TYPE_SIMULATION)
 
         for process_result in results_by_processes:
-            for behaviour_class_id, behaviour_result in process_result.items():
-                behaviour_class = self.simulation.index[behaviour_class_id]
+            for behaviour_class, behaviour_result in process_result.items():
                 results[behaviour_class] = behaviour_class.merge_data(
                     behaviour_result,
                     results.get(behaviour_class),
@@ -179,7 +175,7 @@ class CycleManager(BaseObject):
 
         # Make events
         for behaviour_class, behaviour_data in results.items():
-            behaviour_events = self.simulation.behaviours[behaviour_class.__name__].action(behaviour_data)
+            behaviour_events = self.simulation.behaviours[behaviour_class].action(behaviour_data)
             self.logger.info('{} behaviour generate {} events'.format(
                 str(behaviour_class),
                 str(len(behaviour_events)),
@@ -215,21 +211,21 @@ class CycleManager(BaseObject):
                     subject_behaviours_results,
                 ))
 
-            subject_behaviours = self.get_subject_behaviours(subject)
-            for behaviour_class_name, behaviour_data in subject_behaviours_results.items():
+            subject_behaviours = subject.behaviours
+            for behaviour_class, behaviour_data in subject_behaviours_results.items():
                 # TODO: Ajouter une etape de selection des actions a faire (genre neuronnal)
                 # (genre se cacher et fuir son pas compatibles)
-                behaviour_events = subject_behaviours[behaviour_class_name].action(behaviour_data)
+                behaviour_events = subject_behaviours[behaviour_class].action(behaviour_data)
 
                 self.logger.info('{} behaviour for subject {} generate {} events'.format(
-                    str(behaviour_class_name),
+                    str(behaviour_class.__name__),
                     str(subject.id),
                     str(len(behaviour_events)),
                 ))
 
                 if self.logger.is_debug:
                     self.logger.debug('{} behaviour for subject {} generated events: {}'.format(
-                        str(behaviour_class_name),
+                        str(behaviour_class.__name__),
                         str(subject.id),
                         str([e.repr_debug() for e in behaviour_events]),
                     ))
@@ -249,7 +245,7 @@ class CycleManager(BaseObject):
         self.logger.info('Subjects computing: {} subjects to compute'.format(str(len(subjects))))
 
         for subject in subjects:
-            mechanisms = self.get_subject_mechanisms(subject)
+            mechanisms = subject.mechanisms.values()
 
             if mechanisms:
                 self.logger.info('Subject {}: {} mechanisms'.format(
@@ -260,13 +256,13 @@ class CycleManager(BaseObject):
                 if self.logger.is_debug:
                     self.logger.info('Subject {}: mechanisms are: {}'.format(
                         str(subject.id),
-                        str([m.repr_debug for n, m in mechanisms.items()])
+                        str([m.repr_debug for m in mechanisms])
                     ))
 
             mechanisms_data = {}
             behaviours_data = {}
 
-            for mechanism_class_name, mechanism in mechanisms.items():
+            for mechanism in mechanisms:
                 with time_it() as elapsed_time:
                     mechanism_data = mechanism.run()
                 if self.logger.is_debug:
@@ -277,7 +273,7 @@ class CycleManager(BaseObject):
                         elapsed_time.get_final_time(),
                     ))
 
-                mechanisms_data[mechanism_class_name] = mechanism_data
+                mechanisms_data[mechanism.__class__] = mechanism_data
 
             if mechanisms:
                 if self.logger.is_debug:
@@ -286,7 +282,7 @@ class CycleManager(BaseObject):
                         str(mechanisms_data),
                     ))
 
-            subject_behaviours = self.get_subject_behaviours(subject)
+            subject_behaviours = subject.behaviours
             if not subject_behaviours:
                 break
 
@@ -295,7 +291,7 @@ class CycleManager(BaseObject):
                 str(len(subject_behaviours)),
             ))
 
-            for behaviour_class_name, behaviour in subject_behaviours.items():
+            for behaviour in subject_behaviours.values():
                 self.logger.info('Subject {}: run {} behaviour'.format(
                     str(subject.id),
                     str(type(behaviour)),
@@ -314,47 +310,11 @@ class CycleManager(BaseObject):
                     ))
 
                 if behaviour_data:
-                    behaviours_data[behaviour_class_name] = behaviour_data
+                    behaviours_data[behaviour.__class__] = behaviour_data
 
             results[subject.id] = behaviours_data
         return results
 
-    def get_subject_mechanisms(self, subject: Subject) -> typing.Dict[str, SubjectMechanism]:
-        # TODO: Implementer un systeme qui inhibe des mechanisme (ex. someil inhibe l'ouie)
-        # Attention: c'est utilisé dans le main process aussi, pertinent de la faire là ?
-        try:
-            return self.subject_mechanisms_cache[subject.id]
-        except KeyError:
-            mechanisms = {}
-            for mechanism_class_id in shared.get('subject_mechanisms_index')[subject.id]:
-                mechanism_class = self.simulation.index[mechanism_class_id]
-                mechanism = mechanism_class(
-                    self.config,
-                    self.simulation,
-                    subject,
-                )
-                mechanisms[mechanism_class.__name__] = mechanism
-            self.subject_mechanisms_cache[subject.id] = mechanisms
-            return mechanisms
-
-    def get_subject_behaviours(self, subject: Subject) -> typing.Dict[str, SubjectBehaviour]:
-        # TODO: Implementer un systeme qui inhibe des behaviours (ex. someil inhibe avoir faim)
-        # Attention: c'est utilisé dans le main process aussi, pertinent de la faire là ?
-        try:
-            return self.subject_behaviours_cache[subject.id]
-        except KeyError:
-            behaviours = {}
-            for behaviour_class_id in shared.get('subject_behaviours_index')[subject.id]:
-                behaviour_class = self.simulation.index[behaviour_class_id]
-                behaviour = behaviour_class(
-                    self.config,
-                    self.simulation,
-                    subject,
-                )
-                behaviours[behaviour_class.__name__] = behaviour
-            self.subject_behaviours_cache[subject.id] = behaviours
-            return behaviours
-
     def apply_actions(
             self,
             simulation_actions: [tuple]=None,

synergine2/share.py

@@ -2,13 +2,17 @@
 import pickle
 import typing
 
-import collections
 import redis
 
+from synergine2.base import IdentifiedObject
 from synergine2.exceptions import SynergineException
 from synergine2.exceptions import UnknownSharedData
 
 
+class NoSharedDataInstance(SynergineException):
+    pass
+
+
 class SharedDataIndex(object):
     def __init__(
         self,
@@ -25,22 +29,58 @@ class SharedDataIndex(object):
         raise NotImplementedError()
 
 
+class SharedData(object):
+    def __init__(
+        self, key: str,
+        self_type: bool=False,
+        default: typing.Any=None,
+    ) -> None:
+        """
+        :param key: shared data key
+        :param self_type: if it is a magic shared data where real key is association of key and instance id
+        :param default: default/initial value to shared data. Can be a callable to return list or dict
+        """
+        self._key = key
+        self.self_type = self_type
+        self._default = default
+        self.is_special_type = isinstance(self.default_value, (list, dict))
+        if self.is_special_type:
+            if isinstance(self.default_value, list):
+                self.special_type = TrackedList
+            elif isinstance(self.default_value, dict):
+                self.special_type = TrackedDict
+            else:
+                raise NotImplementedError()
+
+    def get_final_key(self, instance: IdentifiedObject) -> str:
+        if self.self_type:
+            return '{}_{}'.format(instance.id, self._key)
+        return self._key
+
+    @property
+    def default_value(self) -> typing.Any:
+        if callable(self._default):
+            return self._default()
+
+        return self._default
+
+
 class TrackedDict(dict):
     base = dict
 
     def __init__(self, seq=None, **kwargs):
-        self.key = kwargs.pop('key')
-        self.original_key = kwargs.pop('original_key')
+        self.shared_data = kwargs.pop('shared_data')
         self.shared = kwargs.pop('shared')
+        self.instance = kwargs.pop('instance')
         super().__init__(seq, **kwargs)
 
     def __setitem__(self, key, value):
         super().__setitem__(key, value)
-        self.shared.set(self.key, dict(self), original_key=self.original_key)
+        self.shared.set(self.shared_data.get_final_key(self.instance), dict(self))
 
     def setdefault(self, k, d=None):
         v = super().setdefault(k, d)
-        self.shared.set(self.key, dict(self), original_key=self.original_key)
+        self.shared.set(self.shared_data.get_final_key(self.instance), dict(self))
         return v
     # TODO: Cover all methods
 
@@ -49,14 +89,14 @@ class TrackedList(list):
     base = list
 
     def __init__(self, seq=(), **kwargs):
-        self.key = kwargs.pop('key')
-        self.original_key = kwargs.pop('original_key')
+        self.shared_data = kwargs.pop('shared_data')
         self.shared = kwargs.pop('shared')
+        self.instance = kwargs.pop('instance')
         super().__init__(seq)
 
     def append(self, p_object):
         super().append(p_object)
-        self.shared.set(self.key, list(self), original_key=self.original_key)
+        self.shared.set(self.shared_data.get_final_key(self.instance), list(self))
 
     # TODO: Cover all methods
 
@@ -69,6 +109,8 @@ class SharedDataManager(object):
     def __init__(self, clear: bool=True):
         self._r = redis.StrictRedis(host='localhost', port=6379, db=0)  # TODO: configs
 
+        self._shared_data_list = []  # type: typing.List[SharedData]
+
         self._data = {}
         self._modified_keys = set()
         self._default_values = {}
@@ -88,61 +130,31 @@ class SharedDataManager(object):
         self.commit()
         self._data = {}
 
-    def set(self, key: str, value: typing.Any, original_key: str=None) -> None:
-        try:
-            special_type, original_key_ = self._special_types[key]
-            value = special_type(value, key=key, shared=self, original_key=original_key)
-        except KeyError:
-            try:
-                # TODO: Code degeu pour gerer les {id}_truc
-                special_type, original_key_ = self._special_types[original_key]
-                value = special_type(value, key=key, shared=self, original_key=original_key)
-            except KeyError:
-                pass
+    def purge_data(self):
+        self._data = {}
 
+    def set(self, key: str, value: typing.Any) -> None:
         self._data[key] = value
-        self._modified_keys.add((key, original_key))
-
-    def get(self, *key_args: typing.Union[str, float, int]) -> typing.Any:
-        key = '_'.join([str(v) for v in key_args])
+        self._modified_keys.add(key)
 
+    def get(self, key: str) -> typing.Any:
         try:
             return self._data[key]
         except KeyError:
-            b_value = self._r.get(key)
-            if b_value is None:
+            database_value = self._r.get(key)
+            if database_value is None:
                 # We not allow None value storage
                 raise UnknownSharedData('No shared data for key "{}"'.format(key))
-
-            value = pickle.loads(b_value)
-            special_type = None
-
-            try:
-                special_type, original_key = self._special_types[key]
-            except KeyError:
-                pass
-
-            if special_type:
-                self._data[key] = special_type(value, key=key, shared=self, original_key=original_key)
-            else:
-                self._data[key] = value
+            value = pickle.loads(database_value)
+            self._data[key] = value
 
         return self._data[key]
 
     def commit(self) -> None:
-        for key, original_key in self._modified_keys:
-            try:
-                special_type, original_key = self._special_types[key]
-                value = special_type.base(self.get(key))
-                self._r.set(key, pickle.dumps(value))
-            except KeyError:
-                # Code degeu pour gerer les {id}_truc
-                try:
-                    special_type, original_key = self._special_types[original_key]
-                    value = special_type.base(self.get(key))
-                    self._r.set(key, pickle.dumps(value))
-                except KeyError:
-                    self._r.set(key, pickle.dumps(self.get(key)))
+        for key in self._modified_keys:
+            value = self.get(key)
+            self._r.set(key, pickle.dumps(value))
+
         self._modified_keys = set()
 
     def refresh(self) -> None:
@@ -157,55 +169,63 @@ class SharedDataManager(object):
     ) -> SharedDataIndex:
         return shared_data_index_class(self, key, *args, **kwargs)
 
+    def create_self(
+        self,
+        key: str,
+        default: typing.Any,
+        indexes: typing.List[SharedDataIndex]=None,
+    ):
+        return self.create(key, self_type=True, value=default, indexes=indexes)
+
     def create(
         self,
-        key_args: typing.Union[str, typing.List[typing.Union[str, int, float]]],
+        key: str,
         value: typing.Any,
+        self_type: bool=False,
         indexes: typing.List[SharedDataIndex]=None,
     ):
-        key = key_args
-        if not isinstance(key, str):
-            key = '_'.join(key_args)
+        # TODO: Store all keys and forbid re-use one
         indexes = indexes or []
+        shared_data = SharedData(
+            key=key,
+            self_type=self_type,
+            default=value,
+        )
+        self._shared_data_list.append(shared_data)
 
-        if type(value) is dict:
-            value = TrackedDict(value, key=key, shared=shared, original_key=key)
-            self._special_types[key] = TrackedDict, key
-        elif type(value) is list:
-            value = TrackedList(value, key=key, shared=shared, original_key=key)
-            self._special_types[key] = TrackedList, key
-
-        def get_key(obj):
-            return key
+        def fget(instance):
+            final_key = shared_data.get_final_key(instance)
 
-        def get_key_with_id(obj):
-            return key.format(id=obj.id)
+            try:
+                value_ = self.get(final_key)
+                if not shared_data.is_special_type:
+                    return value_
+                else:
+                    return shared_data.special_type(value_, shared_data=shared_data, shared=self, instance=instance)
 
-        if '{id}' in key:
-            key_formatter = get_key_with_id
-        else:
-            self.set(key, value)
-            self._default_values[key] = value
-            key_formatter = get_key
+            except UnknownSharedData:
+                # If no data in database, value for this shared_data have been never set
+                self.set(final_key, shared_data.default_value)
+                self._default_values[final_key] = shared_data.default_value
+                return self.get(final_key)
 
-        def fget(self_):
-            return self.get(key_formatter(self_))
+        def fset(instance, value_):
+            final_key = shared_data.get_final_key(instance)
 
-        def fset(self_, value_):
             try:
-                previous_value = self.get(key_formatter(self_))
+                previous_value = self.get(final_key)
                 for index in indexes:
                     index.remove(previous_value)
             except UnknownSharedData:
                 pass  # If no shared data, no previous value to remove
 
-            self.set(key_formatter(self_), value_, original_key=key)
+            self.set(final_key, value_)
 
             for index in indexes:
                 index.add(value_)
 
         def fdel(self_):
-            raise SynergineException('You cannot delete a shared data')
+            raise SynergineException('You cannot delete a shared data: not implemented yet')
 
         shared_property = property(
             fget=fget,
@@ -213,6 +233,11 @@ class SharedDataManager(object):
             fdel=fdel,
         )
 
+        # A simple shared data can be set now because no need to build key with instance id
+        if not self_type:
+            self.set(key, shared_data.default_value)
+            self._default_values[key] = shared_data.default_value
+
         return shared_property
 
 # TODO: Does exist a way to permit overload of SharedDataManager class ?

synergine2/simulation.py

@@ -1,8 +1,8 @@
 # coding: utf-8
-import collections
 import typing
 
 from synergine2.base import BaseObject
+from synergine2.base import IdentifiedObject
 from synergine2.config import Config
 from synergine2.share import shared
 from synergine2.utils import get_mechanisms_classes
@@ -13,11 +13,10 @@ class Intention(object):
 
 
 class IntentionManager(object):
-    intentions = shared.create(['{id}', 'intentions'], {})  # type: typing.Dict[typing.Type[Intention], Intention]
+    intentions = shared.create_self('intentions', lambda: {})  # type: typing.Dict[typing.Type[Intention], Intention]
 
     def __init__(self):
         self._id = id(self)
-        self.intentions = {}
 
     @property
     def id(self) -> int:
@@ -31,8 +30,8 @@ class IntentionManager(object):
         return self.intentions[intention_type]
 
 
-class Subject(BaseObject):
-    collections = []
+class Subject(IdentifiedObject):
+    start_collections = []
     behaviours_classes = []
     behaviour_selector_class = None  # type: typing.Type[SubjectBehaviourSelector]
     intention_manager_class = None  # type: typing.Type[IntentionManager]
@@ -42,8 +41,9 @@ class Subject(BaseObject):
         config: Config,
         simulation: 'Simulation',
     ):
-        # TODO: Bannir les attribut de classe passé en reference ! Et meme virer les attr de classe tout court.
-        self.collections = self.collections[:]
+        super().__init__()
+        # FIXME: use shared data to permit dynamic start_collections
+        self.collections = self.start_collections[:]
 
         self.config = config
         self._id = id(self)  # We store object id because it's lost between process
@@ -60,27 +60,43 @@ class Subject(BaseObject):
         else:
             self.intentions = IntentionManager()
 
+        self._mechanisms = None  # type: typing.Dict[typing.Type['SubjectMechanism'], 'SubjectMechanism']
+        self._behaviours = None  # type: typing.Dict[typing.Type['SubjectBehaviour'], 'SubjectBehaviour']
+
     @property
-    def id(self) -> int:
-        try:
-            return self._id
-        except AttributeError:
-            pass
+    def mechanisms(self) -> typing.Dict[typing.Type['SubjectMechanism'], 'SubjectMechanism']:
+        if self._mechanisms is None:
+            self._mechanisms = {}
+            for behaviour_class in self.behaviours_classes:
+                for mechanism_class in behaviour_class.use:
+                    mechanism = mechanism_class(
+                        self.config,
+                        self.simulation,
+                        self,
+                    )
+                    self._mechanisms[mechanism_class] = mechanism
+        return self._mechanisms
+
+    @property
+    def behaviours(self) -> typing.Dict[typing.Type['SubjectBehaviour'], 'SubjectBehaviour']:
+        if self._behaviours is None:
+            self._behaviours = {}
+            for behaviour_class in self.behaviours_classes:
+                behaviour = behaviour_class(
+                    self.config,
+                    self.simulation,
+                    self,
+                )
+                self._behaviours[behaviour_class] = behaviour
+        return self._behaviours
 
     def change_id(self, id_: int) -> None:
         self._id = id_
 
     def expose(self) -> None:
-        subject_behaviours_index = shared.get('subject_behaviours_index').setdefault(self._id, [])
-        subject_mechanisms_index = shared.get('subject_mechanisms_index').setdefault(self._id, [])
         subject_classes = shared.get('subject_classes')
-
-        for behaviour_class in self.behaviours_classes:
-            subject_behaviours_index.append(id(behaviour_class))
-            for mechanism_class in behaviour_class.use:
-                subject_mechanisms_index.append(id(mechanism_class))
-
-        subject_classes[self._id] = id(type(self))
+        subject_classes[self._id] = type(self)
+        shared.set('subject_classes', subject_classes)
 
         for collection in self.collections:
             self.simulation.collections.setdefault(collection, []).append(self.id)
@@ -129,7 +145,7 @@ class Subjects(list):
         self.subject_ids.remove(value.id)
         # Remove from subjects list
         super().remove(value)
-        # Remove from collections
+        # Remove from start_collections
         for collection_name in value.collections:
             self.simulation.collections[collection_name].remove(value)
         # Add to removed listing
@@ -158,10 +174,8 @@ class Simulation(BaseObject):
     accepted_subject_class = Subjects
     behaviours_classes = []
 
-    subject_behaviours_index = shared.create('subject_behaviours_index', {})
-    subject_mechanisms_index = shared.create('subject_mechanisms_index', {})
     subject_classes = shared.create('subject_classes', {})
-    collections = shared.create('collections', {})
+    collections = shared.create('start_collections', {})
 
     def __init__(
         self,
@@ -170,35 +184,23 @@ class Simulation(BaseObject):
         self.config = config
         self._subjects = None  # type: Subjects
 
-        # Should contain all usable class of Behaviors, Mechanisms, SubjectBehaviourSelectors,
-        # IntentionManagers, Subject
-        self._index = {}  # type: typing.Dict[int, type]
         self._index_locked = False
 
         self.behaviours = {}
         self.mechanisms = {}
 
         for mechanism_class in get_mechanisms_classes(self):
-            self.mechanisms[mechanism_class.__name__] = mechanism_class(
+            self.mechanisms[mechanism_class] = mechanism_class(
                 config=self.config,
                 simulation=self,
             )
 
         for behaviour_class in self.behaviours_classes:
-            self.behaviours[behaviour_class.__name__] = behaviour_class(
+            self.behaviours[behaviour_class] = behaviour_class(
                 config=self.config,
                 simulation=self,
             )
 
-    def add_to_index(self, *classes: type) -> None:
-        assert not self._index_locked
-        for class_ in classes:
-            self._index[id(class_)] = class_
-
-    @property
-    def index(self) -> typing.Dict[int, type]:
-        return self._index
-
     def lock_index(self) -> None:
         self._index_locked = True
 
@@ -219,8 +221,7 @@ class Simulation(BaseObject):
             return self._subjects.index[subject_id]
         except KeyError:
             # We should be in process context and subject have to been created
-            subject_class_id = shared.get('subject_classes')[subject_id]
-            subject_class = self.index[subject_class_id]
+            subject_class = shared.get('subject_classes')[subject_id]
             subject = subject_class(self.config, self)
             subject.change_id(subject_id)
             self.subjects.append(subject)

synergine2_xyz/mechanism.py

@@ -9,4 +9,4 @@ class ProximitySubjectMechanism(ProximityMixin, SubjectMechanism):
             position=self.subject.position,
             simulation=self.simulation,
             exclude_subject=self.subject,
-        )
+        )

synergine2_xyz/move.py

@@ -127,7 +127,7 @@ class MoveToBehaviour(SubjectBehaviour):
     def run(self, data):
         # TODO: on fait vraiment rien ici ? Note: meme si il n'y a pas de new_path, l'action doit s'effectuer
         # du moment qu'il y a une intention de move
-        move_to_data = data[self.move_to_mechanism.__name__]
+        move_to_data = data[self.move_to_mechanism]
         if move_to_data:
             return move_to_data
         return False

synergine2_xyz/xyz.py

@@ -110,13 +110,13 @@ def get_degree_from_north(a, b):
 class XYZSubjectMixinMetaClass(type):
     def __init__(cls, name, parents, attribs):
         super().__init__(name, parents, attribs)
-        collections = getattr(cls, "collections", [])
+        collections = getattr(cls, "start_collections", [])
         if COLLECTION_XYZ not in collections:
             collections.append(COLLECTION_XYZ)
 
 
 class XYZSubjectMixin(object, metaclass=XYZSubjectMixinMetaClass):
-    position = shared.create(['{id}', 'counter'], (0, 0, 0))
+    position = shared.create_self('position', lambda: (0, 0, 0))
 
     def __init__(self, *args, **kwargs):
         """

tests/test_cycle.py

@@ -28,8 +28,7 @@ class MySubjectBehavior(SubjectBehaviour):
     use = [MySubjectMechanism]
 
     def run(self, data):
-        class_name = MySubjectMechanism.__name__
-        if class_name in data and data[class_name] == 42:
+        if MySubjectMechanism in data and data[MySubjectMechanism] == 42:
             return self.subject.id
 
     def action(self, data) -> [Event]:
@@ -58,7 +57,7 @@ class MySimulationBehaviour(SimulationBehaviour):
         return start_data + new_data
 
     def run(self, data):
-        return data['MySimulationMechanism'] * 2
+        return data[MySimulationMechanism] * 2
 
     def action(self, data) -> [Event]:
         return [MyEvent(data)]
@@ -78,11 +77,6 @@ class TestCycle(BaseTest):
         subjects = MySubjects(simulation=simulation)
         simulation.subjects = subjects
 
-        # Prepare simulation class index
-        simulation.add_to_index(MySubjectBehavior)
-        simulation.add_to_index(MySubjectMechanism)
-        simulation.add_to_index(MySubject)
-
         for i in range(3):
             subjects.append(MySubject(config, simulation=simulation))
 
@@ -108,11 +102,6 @@ class TestCycle(BaseTest):
         subjects = MySubjects(simulation=simulation)
         simulation.subjects = subjects
 
-        # Prepare simulation class index
-        simulation.add_to_index(MySubjectBehavior)
-        simulation.add_to_index(MySubjectMechanism)
-        simulation.add_to_index(MySubject)
-
         for i in range(3):
             subjects.append(MySubject(config, simulation=simulation))
 
@@ -143,9 +132,6 @@ class TestCycle(BaseTest):
 
         simulation = MySimulation(config)
 
-        # Prepare simulation class index
-        simulation.add_to_index(MySimulationBehaviour, MySimulationMechanism)
-
         subjects = MySubjects(simulation=simulation)
         simulation.subjects = subjects
 

tests/test_share.py

@@ -3,6 +3,7 @@ import pickle
 
 import pytest
 
+from synergine2.base import IdentifiedObject
 from synergine2.exceptions import UnknownSharedData
 from synergine2 import share
 from tests import BaseTest
@@ -13,21 +14,6 @@ class TestShare(BaseTest):
         shared = share.SharedDataManager()
 
         class Foo(object):
-            counter = shared.create('counter', value=0)
-
-        foo = Foo()
-        foo.counter = 42
-
-        assert shared.get('counter') == 42
-
-        foo.counter = 48
-
-        assert shared.get('counter') == 48
-
-    def test_default_value(self):
-        shared = share.SharedDataManager()
-
-        class Foo(object):
             counter = shared.create('counter', 0)
 
         foo = Foo()
@@ -39,126 +25,6 @@ class TestShare(BaseTest):
 
         assert shared.get('counter') == 48
 
-    def test_dynamic_key(self):
-        shared = share.SharedDataManager()
-
-        class Foo(object):
-            counter = shared.create(
-                ['{id}', 'counter'],
-                value=0,
-                indexes=[],
-            )
-
-            @property
-            def id(self):
-                return id(self)
-
-        foo = Foo()
-        foo.counter = 42
-
-        assert shared.get(foo.id, 'counter') == 42
-
-        foo.counter = 48
-
-        assert shared.get(foo.id, 'counter') == 48
-
-    def test_multiple_uses(self):
-        shared = share.SharedDataManager()
-
-        class Foo(object):
-            position = shared.create(
-                '{id}_position',
-                (0, 0, 0),
-                indexes=[],
-            )
-
-            @property
-            def id(self):
-                return id(self)
-
-        foo = Foo()
-        foo.position = (0, 1, 2)
-
-        assert shared.get('{}_position'.format(foo.id)) == (0, 1, 2)
-
-        foo2 = Foo()
-        foo2.position = (3, 4, 5)
-
-        assert shared.get('{}_position'.format(foo.id)) == (0, 1, 2)
-        assert shared.get('{}_position'.format(foo2.id)) == (3, 4, 5)
-
-    def test_update_dict_with_pointer(self):
-        shared = share.SharedDataManager()
-
-        class Foo(object):
-            data = shared.create('data', {})
-
-        foo = Foo()
-        foo.data = {'foo': 'bar'}
-
-        assert shared.get('data') == {'foo': 'bar'}
-
-        foo.data['foo'] = 'buz'
-        assert shared.get('data') == {'foo': 'buz'}
-
-        shared.commit()
-        assert shared.get('data') == {'foo': 'buz'}
-        assert pickle.loads(shared._r.get('data')) == {'foo': 'buz'}
-
-        foo.data['foo'] = 'bAz'
-        shared.commit()
-        assert shared.get('data') == {'foo': 'bAz'}
-        assert pickle.loads(shared._r.get('data')) == {'foo': 'bAz'}
-
-    def test_update_list_with_pointer(self):
-        shared = share.SharedDataManager()
-
-        class Foo(object):
-            data = shared.create('data', [])
-
-        foo = Foo()
-        foo.data = ['foo']
-
-        assert shared.get('data') == ['foo']
-
-        foo.data.append('bar')
-        assert shared.get('data') == ['foo', 'bar']
-
-        shared.commit()
-        assert shared.get('data') == ['foo', 'bar']
-        assert pickle.loads(shared._r.get('data')) == ['foo', 'bar']
-
-        foo.data.append('bAr')
-        shared.commit()
-        assert shared.get('data') == ['foo', 'bar', 'bAr']
-        assert pickle.loads(shared._r.get('data')) == ['foo', 'bar', 'bAr']
-
-    def test_update_list_with_pointer__composite_key(self):
-        shared = share.SharedDataManager()
-
-        class Foo(object):
-            data = shared.create(['{id}', 'data'], [])
-
-            def __init__(self):
-                self.id = id(self)
-
-        foo = Foo()
-        foo.data = ['foo']
-
-        assert shared.get(str(id(foo)) + '_data') == ['foo']
-
-        foo.data.append('bar')
-        assert shared.get(str(id(foo)) + '_data') == ['foo', 'bar']
-
-        shared.commit()
-        assert shared.get(str(id(foo)) + '_data') == ['foo', 'bar']
-        assert pickle.loads(shared._r.get(str(id(foo)) + '_data')) == ['foo', 'bar']
-
-        foo.data.append('bAr')
-        shared.commit()
-        assert shared.get(str(id(foo)) + '_data') == ['foo', 'bar', 'bAr']
-        assert pickle.loads(shared._r.get(str(id(foo)) + '_data')) == ['foo', 'bar', 'bAr']
-
     def test_refresh_without_commit(self):
         shared = share.SharedDataManager()
 
@@ -221,17 +87,13 @@ class TestShare(BaseTest):
 
         shared = share.SharedDataManager()
 
-        class Foo(object):
-            position = shared.create(
-                '{id}_position',
+        class Foo(IdentifiedObject):
+            position = shared.create_self(
+                'position',
                 (0, 0, 0),
                 indexes=[shared.make_index(ListIndex, 'positions')],
             )
 
-            @property
-            def id(self):
-                return id(self)
-
         with pytest.raises(UnknownSharedData):
             shared.get('positions')
 
@@ -252,22 +114,132 @@ class TestShare(BaseTest):
         assert shared.get('{}_position'.format(foo2.id)) == (6, 7, 8)
         assert shared.get('positions') == [(0, 1, 2), (6, 7, 8)]
 
+    def test_auto_self_shared_data(self):
+        shared = share.SharedDataManager()
+
+        class MySubject(IdentifiedObject):
+            age = shared.create_self('age', 0)
+
+            @property
+            def id(self):
+                return id(self)
+
+        subject = MySubject()
+        assert subject.age == 0
+
+    def test_auto_self_shared_data_with_callable(self):
+        shared = share.SharedDataManager()
+
+        class MySubject(IdentifiedObject):
+            colors = shared.create_self('colors', lambda: [])
+
+            @property
+            def id(self):
+                return id(self)
+
+        subjecta = MySubject()
+        subjectb = MySubject()
+
+        assert subjecta.colors == []
+        assert subjectb.colors == []
+
+        subjecta.colors = ['toto']
+        subjectb.colors = ['tata']
+
+        assert subjecta.colors == ['toto']
+        assert subjectb.colors == ['tata']
+
+    def test_update_self_dict_with_pointer(self):
+        shared = share.SharedDataManager()
+
+        class Foo(IdentifiedObject):
+            data = shared.create_self('data', lambda: {})
+
+        foo = Foo()
+        foo.data = {'foo': 'bar'}
+
+        assert foo.data == {'foo': 'bar'}
+
+        foo.data['foo'] = 'buz'
+        # In this case local data is used
+        assert foo.data == {'foo': 'buz'}
+
+        shared.commit()
+        shared.purge_data()
+
+        # In this case, "data" key was pending and has been commit
+        assert foo.data == {'foo': 'buz'}
+
+        # In this case "data" key was NOT pending and has not been commit
+        foo.data['foo'] = 'bAz'
+        shared.commit()
+        shared.purge_data()
+
+        assert foo.data == {'foo': 'bAz'}
+
+    def test_update_self_list_with_pointer(self):
+        shared = share.SharedDataManager()
+
+        class Foo(IdentifiedObject):
+            data = shared.create_self('data', [])
+
+        foo = Foo()
+        foo.data = ['foo']
+
+        assert foo.data == ['foo']
+
+        foo.data.append('bar')
+        assert foo.data == ['foo', 'bar']
+
+        shared.commit()
+        assert foo.data == ['foo', 'bar']
+
+        foo.data.append('bAr')
+        shared.commit()
+        assert foo.data == ['foo', 'bar', 'bAr']
+
+    def test_update_list_with_pointer(self):
+        shared = share.SharedDataManager()
+
+        class Foo(IdentifiedObject):
+            data = shared.create('data', [])
+
+        foo = Foo()
+        foo.data = ['foo']
+
+        assert foo.data == ['foo']
+        assert shared.get('data') == ['foo']
+
+        foo.data.append('bar')
+        assert shared.get('data') == ['foo', 'bar']
+
+    def test_update_dict_with_pointer(self):
+        shared = share.SharedDataManager()
+
+        class Foo(IdentifiedObject):
+            data = shared.create('data', lambda: {})
+
+        foo = Foo()
+        foo.data = {'foo': 'bar'}
+
+        assert shared.get('data') == {'foo': 'bar'}
+
+        foo.data['foo'] = 'buz'
+        # In this case local data is used
+        assert shared.get('data') == {'foo': 'buz'}
+
 
 class TestIndexes(BaseTest):
     def test_list_index(self):
         shared = share.SharedDataManager()
 
-        class Foo(object):
-            position = shared.create(
-                '{id}_position',
+        class Foo(IdentifiedObject):
+            position = shared.create_self(
+                'position',
                 (0, 0, 0),
                 indexes=[shared.make_index(share.ListIndex, 'positions')],
             )
 
-            @property
-            def id(self):
-                return id(self)
-
         with pytest.raises(UnknownSharedData):
             shared.get('positions')
 

tests/test_xyz.py

@@ -25,11 +25,6 @@ class TestXYZ(BaseTest):
     def test_proximity_mechanism_with_one(self):
         shared.reset()
         simulation = XYZSimulation(Config())
-        simulation.add_to_index(
-            MyProximityMechanism,
-            MySubject,
-        )
-
         subject = MySubject(Config(), simulation, position=(0, 0, 0))
         other_subject = MySubject(Config(), simulation, position=(5, 0, 0))
 
@@ -58,10 +53,6 @@ class TestXYZ(BaseTest):
     def test_proximity_mechanism_excluding(self):
         shared.reset()
         simulation = XYZSimulation(Config())
-        simulation.add_to_index(
-            MyProximityMechanism,
-            MySubject,
-        )
 
         subject = MySubject(Config(), simulation, position=(0, 0, 0))
         other_subject = MySubject(Config(), simulation, position=(11, 0, 0))
@@ -88,10 +79,6 @@ class TestXYZ(BaseTest):
     def test_proximity_mechanism_with_multiple(self):
         shared.reset()
         simulation = XYZSimulation(Config())
-        simulation.add_to_index(
-            MyProximityMechanism,
-            MySubject,
-        )
 
         subject = MySubject(Config(), simulation, position=(0, 0, 0))
         other_subjects = []