Skip to content

DecoratorNode

dendron.decorator_node.DecoratorNode

Bases: TreeNode

Source code in src/dendron/decorator_node.py 
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
class DecoratorNode(TreeNode):

    _used_names = set(["decorator"])

    """
    A decorator is a "wrapper" around a single node. The purpose of 
    the decorator is to modify or support the action of its child in
    some way.

    Args:
        name (`str`):
            The given name of this node.
        child (`dendron.tree_node.TreeNode`):
            An optional child node. If not specified, the child must be 
            set before this node's `tick()` function is first called.
    """

    def __init__(self, child : TreeNode = None, name : str = "decorator") -> None:
        super().__init__()

        self._name = None
        self.name = name

        self.child_node : TreeNode = child

    @property
    def name(self) -> str:
        return self._name

    @name.setter
    def name(self, value: str) -> None:
        if self._name is not None:
            DecoratorNode._used_names.remove(self._name)

        if value in DecoratorNode._used_names:
            suffix = 0
            new_name = f"{value}_{suffix}"
            while new_name in DecoratorNode._used_names:
                suffix += 1
                new_name = f"{value}_{suffix}"
            value = new_name

        DecoratorNode._used_names.add(value)
        self._name = value

    def children(self) -> List[TreeNode]:
        return [self.child_node]

    def set_logger(self, new_logger) -> None:
        """
        Set the logger for this node, and then forward the logger to the 
        child node.
        """
        self.logger = new_logger
        self.child_node.set_logger(new_logger)

    def set_log_level(self, new_level) -> None:
        """
        Set the log level for this node, and then forward that level to 
        the child node.
        """
        self.log_level = new_level
        self.child_node.set_log_level(new_level)

    def node_type(self) -> NodeType:
        """
        Return this node's type.
        """
        return NodeType.DECORATOR 

    def set_child(self, child : TreeNode) -> None:
        """
        Set the child of this node to a new `TreeNode`.

        Args:
            child (`dendron.tree_node.TreeNode`):
                The new child of this decorator.
        """
        self.child_node = child

    def get_child(self) -> TreeNode:
        """
        Get the child of this decorator.

        Returns:
            `TreeNode`: The child of this node.
        """
        return self.child_node

    def get_node_by_name(self, name : str) -> Optional[TreeNode]:
        """
        Search for a node by its name.

        Args:
            name (`str`):
                The name of the node we are looking for.

        Returns:
            `Optional[TreeNode]`: Either a node with the given name,
            or None.
        """
        if self.name == name:
            return self
        else:
            return self.child_node.get_node_by_name(name)

    def halt_child(self) -> None:
        """
        Instruct the child node to halt.
        """
        self.child_node.halt_node()

    def set_tree(self, tree : BehaviorTree) -> None:
        """
        Set the tree of this node, and then forward the tree to the child
        to have it set its tree.

        Args:
            tree (`dendron.behavior_tree.BehaviorTree`):
                The tree that contains this node.
        """
        self.tree = tree
        self.child_node.set_tree(tree)

    def reset(self) -> None:
        """
        Set the status of this node to IDLE and instruct the child node to
        reset.
        """
        self.node_status = NodeStatus.IDLE
        self.child_node.reset()

    def pretty_repr(self, depth = 0) -> str:
        """
        Return a string representation of this node at the given depth.

        Args:
            depth (`int`):
                The depth of this node in a surrounding tree.

        Returns:
            `str`: The indented string representation.
        """
        tabs = '\t'*depth
        repr = f"{tabs}Decorator {self.name}\n{self.child_node.pretty_repr(depth+1)}"
        return repr

get_child()

Get the child of this decorator.

Returns:

Type Description
TreeNode

TreeNode: The child of this node.
Source code in src/dendron/decorator_node.py 
91
92
93
94
95
96
97
98
def get_child(self) -> TreeNode:
    """
    Get the child of this decorator.

    Returns:
        `TreeNode`: The child of this node.
    """
    return self.child_node

get_node_by_name(name)

Search for a node by its name.

Parameters:

Name Type Description Default
name `str`

The name of the node we are looking for.

 required

Returns:

Type Description
Optional[TreeNode]

Optional[TreeNode]: Either a node with the given name,
Optional[TreeNode]

or None.
Source code in src/dendron/decorator_node.py 
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
def get_node_by_name(self, name : str) -> Optional[TreeNode]:
    """
    Search for a node by its name.

    Args:
        name (`str`):
            The name of the node we are looking for.

    Returns:
        `Optional[TreeNode]`: Either a node with the given name,
        or None.
    """
    if self.name == name:
        return self
    else:
        return self.child_node.get_node_by_name(name)

halt_child()

Instruct the child node to halt.

Source code in src/dendron/decorator_node.py 
117
118
119
120
121
def halt_child(self) -> None:
    """
    Instruct the child node to halt.
    """
    self.child_node.halt_node()

node_type()

Return this node's type.

Source code in src/dendron/decorator_node.py 
75
76
77
78
79
def node_type(self) -> NodeType:
    """
    Return this node's type.
    """
    return NodeType.DECORATOR

pretty_repr(depth=0)

Return a string representation of this node at the given depth.

Parameters:

Name Type Description Default
depth `int`

The depth of this node in a surrounding tree.

 0

Returns:

Type Description
str

str: The indented string representation.
Source code in src/dendron/decorator_node.py 
143
144
145
146
147
148
149
150
151
152
153
154
155
156
def pretty_repr(self, depth = 0) -> str:
    """
    Return a string representation of this node at the given depth.

    Args:
        depth (`int`):
            The depth of this node in a surrounding tree.

    Returns:
        `str`: The indented string representation.
    """
    tabs = '\t'*depth
    repr = f"{tabs}Decorator {self.name}\n{self.child_node.pretty_repr(depth+1)}"
    return repr

reset()

Set the status of this node to IDLE and instruct the child node to reset.

Source code in src/dendron/decorator_node.py 
135
136
137
138
139
140
141
def reset(self) -> None:
    """
    Set the status of this node to IDLE and instruct the child node to
    reset.
    """
    self.node_status = NodeStatus.IDLE
    self.child_node.reset()

set_child(child)

Set the child of this node to a new TreeNode.

Parameters:

Name Type Description Default
child `dendron.tree_node.TreeNode`

The new child of this decorator.

 required
Source code in src/dendron/decorator_node.py 
81
82
83
84
85
86
87
88
89
def set_child(self, child : TreeNode) -> None:
    """
    Set the child of this node to a new `TreeNode`.

    Args:
        child (`dendron.tree_node.TreeNode`):
            The new child of this decorator.
    """
    self.child_node = child

set_log_level(new_level)

Set the log level for this node, and then forward that level to the child node.

Source code in src/dendron/decorator_node.py 
67
68
69
70
71
72
73
def set_log_level(self, new_level) -> None:
    """
    Set the log level for this node, and then forward that level to 
    the child node.
    """
    self.log_level = new_level
    self.child_node.set_log_level(new_level)

set_logger(new_logger)

Set the logger for this node, and then forward the logger to the child node.

Source code in src/dendron/decorator_node.py 
59
60
61
62
63
64
65
def set_logger(self, new_logger) -> None:
    """
    Set the logger for this node, and then forward the logger to the 
    child node.
    """
    self.logger = new_logger
    self.child_node.set_logger(new_logger)

set_tree(tree)

Set the tree of this node, and then forward the tree to the child to have it set its tree.

Parameters:

Name Type Description Default
tree `dendron.behavior_tree.BehaviorTree`

The tree that contains this node.

 required
Source code in src/dendron/decorator_node.py 
123
124
125
126
127
128
129
130
131
132
133
def set_tree(self, tree : BehaviorTree) -> None:
    """
    Set the tree of this node, and then forward the tree to the child
    to have it set its tree.

    Args:
        tree (`dendron.behavior_tree.BehaviorTree`):
            The tree that contains this node.
    """
    self.tree = tree
    self.child_node.set_tree(tree)