Cleanup (#95)

Author: Flova

README.md

@@ -170,6 +170,9 @@ More information can be added to the right side by calling `self.publish_debug_d
 ## DSD Development GUI
 If you want to use a graphical user interface to define your DSD, we recommend [this repository](https://github.com/bit-bots/dsd-gui)
 
+## VSCode Extension
+If you use VSCode, you can use the [DSD extension](https://marketplace.visualstudio.com/items?itemName=Mastermori.dsd) which provides syntax highlighting.
+
 ## Examples
 
 Here are a few projects that use the DSD and can be used for reference:

dynamic_stack_decider/dynamic_stack_decider/dsd.py

@@ -153,16 +153,18 @@ def _bind_modules(self, element):
         :param element: The starting element
         """
         if isinstance(element, ActionTreeElement):
+            assert element.name in self.actions, f'Provided element "{element.name}" was not found in registered actions!'
             element.module = self.actions[element.name]
         elif isinstance(element, DecisionTreeElement):
+            assert element.name in self.decisions, f'Provided element "{element.name}" was not found in registered decisions!'
             element.module = self.decisions[element.name]
             for child in element.children.values():
                 self._bind_modules(child)
         elif isinstance(element, SequenceTreeElement):
             for action in element.action_elements:
                 self._bind_modules(action)
         else:
-            raise KeyError('Provided element ' + str(element) + 'was not found in registered actions or decisions')
+            raise ValueError(f'Unknown parser tree element type "{type(element)}" for element "{element}"!')
 
     def _init_element(self, element):
         """ Initialises the module belonging to the given element. """

dynamic_stack_decider/dynamic_stack_decider/parser.py

@@ -1,18 +1,16 @@
 import copy
 import re
-from dynamic_stack_decider.tree import Tree, AbstractTreeElement, DecisionTreeElement, ActionTreeElement, \
-    SequenceTreeElement
+from dynamic_stack_decider.tree import Tree, DecisionTreeElement, ActionTreeElement, SequenceTreeElement
 import yaml
-import rclpy
 from rclpy.node import Node
-from typing import List, Union
+from typing import Optional
 
 
 class DsdParser:
-    def __init__(self, node):
+    def __init__(self, node: Optional[Node] = None):
         self.node = node
 
-    def parse(self, file_path):
+    def parse(self, file_path: str) -> Tree:
         """
         Parse a .dsd file to a Tree
 
@@ -202,7 +200,7 @@ def _extract_parameters(self, token, lnr):
                                  'Did you forget a comma?'.format(lnr))
 
             if parameter_value.startswith('%'):
-                parameter_value = self.node.get_parameter(parameter_value[1:]).value
+                parameter_value = self.node.get_parameter(parameter_value[1:]).value if self.node is not None else None
                 parameter_dict[parameter_key] = parameter_value
             elif parameter_value.startswith('*'):
                 # This is a reference to the value specified in the subtree

dynamic_stack_decider/dynamic_stack_decider/tree.py

@@ -6,15 +6,14 @@ class Tree:
 
     def __init__(self):
         # The root element of the tree
-        self.root_element = None
+        self.root_element: Optional[AbstractTreeElement] = None
         self.parameter_list = []
 
-    def set_root_element(self, element):
+    def set_root_element(self, element: "AbstractTreeElement"):
         """
         Set the root element of the tree
 
         :param element: The root element
-        :type element: AbstractTreeElement
         """
         self.root_element = element
 
@@ -28,15 +27,14 @@ class AbstractTreeElement:
     use one of DecisionTreeElement and ActionTreeElement instead
     """
 
-    def __init__(self, name, parent):
+    def __init__(self, name: str, parent: Optional["AbstractTreeElement"]):
         self.name = name
         self.parent = parent
         self.module = None
         self.parameters = None
         self.activation_reason = None
 
-    def get_child(self, activating_result):
-        # type: (str) -> Optional[AbstractTreeElement]
+    def get_child(self, activating_result: str) -> Optional["AbstractTreeElement"]:
         """
         Get the child that should be activated for the given result.
         This makes only sense for DecisionTreeElements; others return None
@@ -70,14 +68,14 @@ def __init__(self, name, parent, parameters=None, unset_parameters=None):
         self.unset_parameters = unset_parameters or dict()
 
         # Dictionary that maps results of the decision to the corresponding child
-        self.children = dict()
+        self.children: dict[str, AbstractTreeElement] = dict()
 
-    def add_child_element(self, element, activating_result):
+    def add_child_element(self, element: AbstractTreeElement, activating_result: str):
         """Add a child that will be executed when activating_result is returned"""
         self.children[activating_result] = element
         element.set_activation_reason(activating_result)
 
-    def get_child(self, activating_result):
+    def get_child(self, activating_result: str) -> Optional[AbstractTreeElement]:
         """Get the child for a given result"""
         if not activating_result:
             # give advice about error

dynamic_stack_decider/setup.py

@@ -14,13 +14,9 @@
     install_requires=[
         'setuptools',
     ],
-    test_suite='tests',
+    tests_require=['pytest'],
     zip_safe=True,
     keywords=['ROS'],
     license='MIT',
-    entry_points={
-        #  'console_scripts': [
-            #  'dynamic_stack_decider = dynamic_stack_decider.parser:parse',
-        #  ],
-    }
+    entry_points={}
 )

dynamic_stack_decider/tests/__init__.py dynamic_stack_decider/test/__init__.py

@@ -0,0 +1,126 @@
+import os
+import pytest
+
+from dynamic_stack_decider.parser import DsdParser, Tree
+from dynamic_stack_decider.tree import DecisionTreeElement, ActionTreeElement, SequenceTreeElement
+
+
+@pytest.fixture()
+def dsd_tree():
+    parser = DsdParser()
+    yield parser.parse(os.path.join(os.path.dirname(__file__), 'test.dsd'))
+
+
+def test_root_element(dsd_tree: Tree):
+    root_element = dsd_tree.root_element
+    assert isinstance(root_element, DecisionTreeElement)
+    assert root_element.name == 'FirstDecision'
+
+def test_possible_results(dsd_tree: Tree):
+    assert set(dsd_tree.root_element.children.keys()) == \
+        {'ACTION', 'DECISION', 'SUBBEHAVIOR', 'SEQUENCE', 'PARAMETERS',
+        'LINE_COMMENT', 'BLOCK_COMMENT', 'COMPLICATED_COMMENT',
+        'MULTIPLE_PARAMETERS', 'SECOND_SUBBEHAVIOR_1', 'SECOND_SUBBEHAVIOR_2',
+        'PARAMETER_DECISION', 'PARAMETER_SUBBEHAVIOR', 'NESTED_PARAMETER_SUBBEHAVIOR',
+        'SEQUENCE_TREE'}
+
+def test_following_elements(dsd_tree: Tree):
+    first_child = dsd_tree.root_element.get_child('ACTION')
+    assert first_child.name == 'FirstAction'
+    assert isinstance(first_child, ActionTreeElement)
+
+    second_child = dsd_tree.root_element.get_child('DECISION')
+    assert second_child.name == 'SecondDecision'
+    assert isinstance(second_child, DecisionTreeElement)
+
+def test_nested_decision(dsd_tree: Tree):
+    decision_child = dsd_tree.root_element.get_child('DECISION')
+    assert set(decision_child.children.keys()) == {'FIRST', 'SECOND'}
+    assert decision_child.get_child('FIRST').name == 'FirstAction'
+    assert isinstance(decision_child.get_child('FIRST'), ActionTreeElement)
+    assert decision_child.get_child('SECOND').name == 'SecondAction'
+    assert isinstance(decision_child.get_child('SECOND'), ActionTreeElement)
+
+def test_sub_behavior(dsd_tree: Tree):
+    sub_behavior_root_decision = dsd_tree.root_element.get_child('SUBBEHAVIOR')
+    assert sub_behavior_root_decision.name == 'ThirdDecision'
+    assert set(sub_behavior_root_decision.children.keys()) == {'FIRST', 'SECOND'}
+    assert sub_behavior_root_decision.get_child('FIRST').name == 'FirstAction'
+    assert isinstance(sub_behavior_root_decision.get_child('FIRST'), ActionTreeElement)
+    assert sub_behavior_root_decision.get_child('SECOND').name == 'SecondAction'
+    assert isinstance(sub_behavior_root_decision.get_child('SECOND'), ActionTreeElement)
+
+def test_sequence_element(dsd_tree: Tree):
+    sequence_element = dsd_tree.root_element.get_child('SEQUENCE')
+    assert isinstance(sequence_element, SequenceTreeElement)
+    assert len(sequence_element.action_elements) == 2
+    first_action = sequence_element.action_elements[0]
+    assert first_action.name == 'FirstAction'
+    assert isinstance(first_action, ActionTreeElement)
+    second_action = sequence_element.action_elements[1]
+    assert second_action.name == 'SecondAction'
+    assert isinstance(second_action, ActionTreeElement)
+
+def test_action_parameters(dsd_tree: Tree):
+    parameter_element = dsd_tree.root_element.get_child('PARAMETERS')
+    assert parameter_element.name == 'FirstAction'
+    assert isinstance(parameter_element, ActionTreeElement)
+    assert parameter_element.parameters == {'key': 'value'}
+
+def test_decision_parameters(dsd_tree: Tree):
+    parameter_element = dsd_tree.root_element.get_child('PARAMETER_DECISION')
+    assert parameter_element.name == 'FirstDecision'
+    assert isinstance(parameter_element, DecisionTreeElement)
+    assert parameter_element.parameters == {'key': 'value'}
+
+def test_line_comment(dsd_tree: Tree):
+    comment_element = dsd_tree.root_element.get_child('LINE_COMMENT')
+    assert comment_element.name == 'FirstAction'
+    assert isinstance(comment_element, ActionTreeElement)
+
+def test_block_comment(dsd_tree: Tree):
+    comment_element = dsd_tree.root_element.get_child('BLOCK_COMMENT')
+    assert comment_element.name == 'FirstAction'
+    assert isinstance(comment_element, ActionTreeElement)
+    assert comment_element.parameters == {'key': 'value'}
+
+def test_complicated_comment(dsd_tree: Tree):
+    comment_element = dsd_tree.root_element.get_child('COMPLICATED_COMMENT')
+    assert comment_element.name == 'FirstAction'
+    assert isinstance(comment_element, ActionTreeElement)
+
+def test_multiple_parameters(dsd_tree: Tree):
+    parameter_element = dsd_tree.root_element.get_child('MULTIPLE_PARAMETERS')
+    assert parameter_element.name == 'FirstAction'
+    assert isinstance(parameter_element, ActionTreeElement)
+    assert parameter_element.parameters == {'key1': 'value1', 'key2': 'value2'}
+
+def test_multiple_subbehavior_references(dsd_tree: Tree):
+    sub_behavior_1_root_decision = dsd_tree.root_element.get_child('SECOND_SUBBEHAVIOR_1')
+    sub_behavior_2_root_decision = dsd_tree.root_element.get_child('SECOND_SUBBEHAVIOR_2')
+    assert sub_behavior_1_root_decision.name == sub_behavior_2_root_decision.name
+    assert sub_behavior_1_root_decision.activation_reason == 'SECOND_SUBBEHAVIOR_1'
+    assert sub_behavior_2_root_decision.activation_reason == 'SECOND_SUBBEHAVIOR_2'
+
+def test_parameter_subbehavior(dsd_tree: Tree):
+    parameter_subbehavior_decision = dsd_tree.root_element.get_child('PARAMETER_SUBBEHAVIOR')
+    first_action = parameter_subbehavior_decision.get_child('FIRST')
+    assert first_action.parameters == {'key': 'value1'}
+    action_sequence = parameter_subbehavior_decision.get_child('SECOND')
+    assert action_sequence.action_elements[0].parameters == {'key': 'value2'}
+    assert action_sequence.action_elements[1].parameters == {'key': 'value2'}
+
+def test_nested_parameter_subbehavior(dsd_tree: Tree):
+    subbehavior_decision = dsd_tree.root_element.get_child('NESTED_PARAMETER_SUBBEHAVIOR')
+    inner_subbehavior_decision = subbehavior_decision.get_child('FIRST')
+    first_action = inner_subbehavior_decision.get_child('FIRST')
+    assert first_action.parameters == {'key': 'nested1'}
+    action_sequence = inner_subbehavior_decision.get_child('SECOND')
+    assert action_sequence.action_elements[0].parameters == {'key': 'nested2'}
+    assert action_sequence.action_elements[1].parameters == {'key': 'nested2'}
+
+def test_sequence_tree(dsd_tree: Tree):
+    sequence_tree = dsd_tree.root_element.get_child('SEQUENCE_TREE')
+    assert isinstance(sequence_tree, SequenceTreeElement)
+    assert sequence_tree.action_elements[0].name == 'FirstAction'
+    assert sequence_tree.action_elements[1].name == 'SecondAction'