[blackboard] unregister keys (splintered-reality#241)

Author: stonier

py_trees/blackboard.py

@@ -848,21 +848,37 @@ def _stringify_key_value_pairs(self, keys, key_value_dict, indent):
         s += console.reset
         return s
 
-    def unregister(self, clear=True):
+    def unregister(self, clear: bool=True):
         """
         Unregister this blackboard client and if requested, clear key-value pairs if this
         client is the last user of those variables.
+
+        Args:
+            clear: remove key-values pairs from the blackboard
+        """
+        self.unregister_all_keys(clear)
+        del Blackboard.clients[super().__getattribute__("unique_identifier")]
+
+    def unregister_all_keys(self, clear: bool=True):
+        """
+        Unregister all keys currently registered by this blackboard client and if requested,
+        clear key-value pairs if this client is the last user of those variables.
+
+        Args:
+            clear: remove key-values pairs from the blackboard
         """
-        print("Name: {}".format(self.name))
         for key in self.read:
             Blackboard.metadata[key].read.remove(super().__getattribute__("unique_identifier"))
         for key in self.write:
             Blackboard.metadata[key].write.remove(super().__getattribute__("unique_identifier"))
         if clear:
             for key in (set(self.read) | set(self.write)):
                 if not (set(Blackboard.metadata[key].read) | set(Blackboard.metadata[key].write)):
-                    Blackboard.storage.pop(key, None)
-                    Blackboard.metadata.pop(key, None)
+                    try:
+                        del Blackboard.storage[key]
+                    except KeyError:
+                        pass  # perfectly acceptal for a key to not exist on the blackboard yet
+                    del Blackboard.metadata[key]
 
     def register_key(self, key: str, read: bool=False, write: bool=False):
         """
@@ -881,6 +897,29 @@ def register_key(self, key: str, read: bool=False, write: bool=False):
             super().__getattribute__("write").add(key)
             Blackboard.metadata[key].write.add(super().__getattribute__("unique_identifier"))
 
+    def unregister_key(self, key: str, clear: bool=True):
+        """
+        Unegister a key associated with this client.
+
+        Args:
+            key: key to unregister
+            clear: remove key-values pairs from the blackboard
+
+        Raises:
+            KeyError if the key has not been previously registered
+        """
+        super().__getattribute__("read").discard(key)  # doesn't throw exceptions if it not present
+        super().__getattribute__("write").discard(key)
+        Blackboard.metadata[key].read.discard(super().__getattribute__("unique_identifier"))
+        Blackboard.metadata[key].write.discard(super().__getattribute__("unique_identifier"))
+        if not (Blackboard.metadata[key].read | Blackboard.metadata[key].write):
+            del Blackboard.metadata[key]
+            if clear:
+                try:
+                    del Blackboard.storage[key]
+                except KeyError:
+                    pass  # perfectly legitimate for a registered key to not exist on the blackboard
+
 
 class SubBlackboard(object):
     """

tests/test_blackboard.py

@@ -136,20 +136,20 @@ def test_key_exists():
     console.banner("Nested Read")
     with create_blackboards() as (foo, unused_bar):
         print("foo.exists('dude') [{}][{}]".format(foo.exists("dude"), True))
-        assert(foo.exists("dude"), True)
+        assert(foo.exists("dude"))
         with nose.tools.assert_raises_regexp(AttributeError, "does not have read/write access"):
             print("Expecting Attribute Error with substring 'does not have read/write access'")
             print("foo.exists('dude_not_here') [{}][{}]".format(foo.exists("dude_not_here"), False))
-            assert(foo.exists("dude_not_here"), False)
+            assert(not foo.exists("dude_not_here"))
 
 
 def test_nested_exists():
     console.banner("Nested Read")
     with create_blackboards() as (foo, unused_bar):
         print("foo.exists('motley.nested') [{}][{}]".format(foo.exists("foo.nested"), True))
-        assert(foo.exists("motley.nested"), True)
+        assert(foo.exists("motley.nested"))
         print("foo.exists('motley.not_here') [{}][{}]".format(foo.exists("foo.not_here"), False))
-        assert(foo.exists("motley.not_here"), False)
+        assert(not foo.exists("motley.not_here"))
 
 
 def test_nested_read():
@@ -276,7 +276,7 @@ def test_lists():
         foo.dude = ["Bob", "Bill"]
         name = bar.dude[0]
         print("Read first element of the list: {} [{}]".format(name, "Bob"))
-        assert(name, "Bob")
+        assert(name == "Bob")
 
 
 def test_dicts():
@@ -285,7 +285,7 @@ def test_dicts():
         foo.dude = {"Bob": 5, "Bill": 3}
         value = bar.dude["Bob"]
         print("Read Bob's score: {} [{}]".format(value, 5))
-        assert(value, 5)
+        assert(value == 5)
 
 
 def test_static_get_set():
@@ -305,15 +305,32 @@ def test_static_get_set():
     Blackboard.set("motley", Motley())
     print("Set motley.nested: nooo")
     Blackboard.set("motley.nested", "nooo")
-    assert(Blackboard.get("motley.nested"), "nooo")
+    assert(Blackboard.get("motley.nested") == "nooo")
     print("Get motley.foo")
     with nose.tools.assert_raises_regexp(KeyError, "nested attributes"):
         print(" - Expecting a KeyError")
         unused_value = Blackboard.get("motley.foo")
     print("Set motley.other: floosie")
     Blackboard.set("motley.other", "floosie")
-    assert(Blackboard.get("motley.other"), "floosie")
+    assert(Blackboard.get("motley.other") == "floosie")
     print("Get missing")
     with nose.tools.assert_raises_regexp(KeyError, "missing"):
         print(" - Expecting a KeyError")
         unused_value = Blackboard.get("missing")
+
+
+def test_unregister_key():
+    console.banner("Unregister Keys")
+    with create_blackboards() as (foo, bar):
+        print("'foo' in foo.write")
+        assert ("foo" in foo.write)
+        print("Foo unregisters 'foo'")
+        foo.unregister_key("foo")
+        print("'foo' not in foo.write")
+        assert ("foo" not in foo.write)
+        print("Bar unregisters 'dudette' with clearing")
+        print("'dudette' not in bar.write")
+        bar.unregister_key("dudette", clear=True)
+        assert("dudette" not in bar.write)
+        print("'dudette' not on the blackboard")
+        assert("dudette" not in Blackboard.storage)

tests/test_blackboard_behaviours.py

@@ -340,7 +340,7 @@ def test_wait_for_variable_value():
         assert(b.status == asserted_result)
 
 
-def untest_wait_for_blackboard_variable():
+def test_wait_for_blackboard_variable():
     console.banner("Wait for Blackboard Variable")
     create_blackboard()
 
@@ -353,18 +353,18 @@ def untest_wait_for_blackboard_variable():
         name="check_nested_foo_exists", variable_name="nested.foo"), Status.SUCCESS))
     tuples.append((py_trees.behaviours.WaitForBlackboardVariable(
         name="check_nested_bar_exists", variable_name="nested.bar"), Status.RUNNING))
-    tuples.append((py_trees.behaviours.WaitForBlackboardVariable(
+    tuples.append((py_trees.behaviours.WaitForBlackboardVariableValue(
         name="check_foo_equals_bar", variable_name="foo", expected_value="bar"), Status.SUCCESS))
-    tuples.append((py_trees.behaviours.WaitForBlackboardVariable(
+    tuples.append((py_trees.behaviours.WaitForBlackboardVariableValue(
         name="check_foo_equals_foo", variable_name="foo", expected_value="foo"), Status.RUNNING))
-    tuples.append((py_trees.behaviours.WaitForBlackboardVariable(
+    tuples.append((py_trees.behaviours.WaitForBlackboardVariableValue(
         name="check_bar_equals_bar", variable_name="bar", expected_value="bar"), Status.RUNNING))
-    tuples.append((py_trees.behaviours.WaitForBlackboardVariable(
+    tuples.append((py_trees.behaviours.WaitForBlackboardVariableValue(
         name="check_bar_equals_foo", variable_name="bar", expected_value="foo"), Status.RUNNING))
-    tuples.append((py_trees.behaviours.WaitForBlackboardVariable(
+    tuples.append((py_trees.behaviours.WaitForBlackboardVariableValue(
         name="check_nested_foo_equals_bar", variable_name="nested.foo", expected_value="bar"),
         Status.SUCCESS))
-    tuples.append((py_trees.behaviours.WaitForBlackboardVariable(
+    tuples.append((py_trees.behaviours.WaitForBlackboardVariableValue(
         name="check_nested_foo_equals_foo", variable_name="nested.foo", expected_value="foo"),
         Status.RUNNING))
     for b, unused in tuples: