updates to tests

Author: quaquel

mesa/experimental/mesa_signals/mesa_signal.py

@@ -118,11 +118,15 @@ def __init__(self):
         """Initialize a Computable."""
         super().__init__()
 
+        # fixme have 2 signal: change and is_dirty?
+        self.signal_types: set = {
+            "change",
+        }
+
     def __get__(self, instance, owner):  # noqa: D105
         computed = getattr(instance, self.private_name)
         old_value = computed._value
 
-        # fixme, we are not detecting if one computable is dependent on another
         if CURRENT_COMPUTED is not None:
             CURRENT_COMPUTED._add_parent(instance, self.public_name, old_value)
 
@@ -139,11 +143,14 @@ def __get__(self, instance, owner):  # noqa: D105
         else:
             return old_value
 
-    def __set__(self, instance: HasObservables, value):  # noqa D103
-        # no on change event?
+    def __set__(self, instance: HasObservables, value: Computed):  # noqa D103
+        if not isinstance(value, Computed):
+            raise ValueError("value has to be a Computable instance")
+
         setattr(instance, self.private_name, value)
         value.name = self.public_name
         value.owner = instance
+        getattr(instance, self.public_name)  # force evaluation of the computed to build the dependency graph
 
 
 class Computed:
@@ -191,7 +198,7 @@ def _remove_parents(self):
         """Remove all parent Observables."""
         # we can unsubscribe from everything on each parent
         for parent in self.parents:
-            parent.unobserve(All(), All())
+            parent.unobserve(All(), All(), self._set_dirty)
 
     def __call__(self):
         global CURRENT_COMPUTED  # noqa: PLW0603
@@ -208,25 +215,26 @@ def __call__(self):
             # we might be dirty but values might have changed
             # back and forth in our parents so let's check to make sure we
             # really need to recalculate
-            for parent in self.parents.keyrefs():
-                # does parent still exist?
-                if parent := parent():
-                    # if yes, compare old and new values for all
-                    # tracked observables on this parent
-                    for name, old_value in self.parents[parent].items():
-                        new_value = getattr(parent, name)
-                        if new_value != old_value:
-                            changed = True
-                            break  # we need to recalculate
+            if not changed:
+                for parent in self.parents.keyrefs():
+                    # does parent still exist?
+                    if parent := parent():
+                        # if yes, compare old and new values for all
+                        # tracked observables on this parent
+                        for name, old_value in self.parents[parent].items():
+                            new_value = getattr(parent, name)
+                            if new_value != old_value:
+                                changed = True
+                                break  # we need to recalculate
+                        else:
+                            # trick for breaking cleanly out of nested for loops
+                            # see https://stackoverflow.com/questions/653509/breaking-out-of-nested-loops
+                            continue
+                        break
                     else:
-                        # trick for breaking cleanly out of nested for loops
-                        # see https://stackoverflow.com/questions/653509/breaking-out-of-nested-loops
-                        continue
-                    break
-                else:
-                    # one of our parents no longer exists
-                    changed = True
-                    break
+                        # one of our parents no longer exists
+                        changed = True
+                        break
 
             if changed:
                 # the dependencies of the computable function might have changed

tests/test_mesa_signals.py

@@ -247,4 +247,41 @@ class MyAgent(Agent, HasObservables):
 
         def __init__(self, model, value):
             super().__init__(model)
-            some_attribute = Computed(lambda x: x, self)  # noqa: F841
+            self.some_other_attribute = value
+            self.some_attribute = Computed(lambda x: x.some_other_attribute*2, self)
+
+    model = Model(seed=42)
+    agent = MyAgent(model, 10)
+    assert agent.some_attribute == 20
+
+    handler = Mock()
+    agent.observe("some_attribute", "change", handler)
+    agent.some_other_attribute = 9  # we change the dependency of computed
+    handler.assert_called_once()
+    agent.unobserve("some_attribute", "change", handler)
+
+    handler = Mock()
+    agent.observe("some_attribute", "change", handler)
+    assert agent.some_attribute == 18  # this forces a re-evaluation of the value of computed
+    handler.assert_called_once()  # and so, our change handler should be called
+    agent.unobserve("some_attribute", "change", handler)
+
+    # cyclical dependencies
+    def computed_func(agent):
+        # this creates a cyclical dependency
+        # our computed is dependent on o1, but also modifies o1
+        agent.o1 = agent.o1 - 1
+    class MyAgent(Agent, HasObservables):
+        c1 = Computable()
+        o1 = Observable()
+
+        def __init__(self, model, value):
+            super().__init__(model)
+            self.o1 = value
+            self.c1 = Computed(computed_func, self)
+
+    model = Model(seed=42)
+    with pytest.raises(ValueError):
+        MyAgent(model, 10)
+
+    # parents disappearing