Skip to content

ConditionNode

dendron.condition_node.ConditionNode

Bases: TreeNode

Source code in src/dendron/condition_node.py 
  8
  9
 10
 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
class ConditionNode(TreeNode):

    _used_names = set(["condition"])

    """
    A condition node is a node that always *must* return either `SUCCESS` 
    or `FAILURE` - it can never be left in a `RUNNING` state. Such nodes
    are intended to model boolean conditions (hence the name). 

    `ConditionNode`s are one of the two kinds of leaf nodes in a Behavior
    Tree - the other being the `ActionNode`.

    Args:
        name (`str`):
            The given name of this node.
    """

    def __init__(self, name : str = "condition") -> None:
        super().__init__()
        self._name = None
        self.name = name

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

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

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

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

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

    def set_logger(self, new_logger) -> None:
        """
        Set the logger for this node.
        """
        self.logger = new_logger

    def set_log_level(self, new_level) -> None:
        """
        Set the log level for this node.
        """
        self.log_level = new_level

    def node_type(self) -> NodeType:
        """
        Get the type of this node.

        Returns:
            `NodeType`: The type (`CONDITION`).
        """
        return NodeType.CONDITION

    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 None

    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}Condition {self.name}"
        return repr

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/condition_node.py 
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
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 None

node_type()

Get the type of this node.

Returns:

Type Description
NodeType

NodeType: The type (CONDITION).
Source code in src/dendron/condition_node.py 
65
66
67
68
69
70
71
72
def node_type(self) -> NodeType:
    """
    Get the type of this node.

    Returns:
        `NodeType`: The type (`CONDITION`).
    """
    return NodeType.CONDITION

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/condition_node.py 
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
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}Condition {self.name}"
    return repr

set_log_level(new_level)

Set the log level for this node.

Source code in src/dendron/condition_node.py 
59
60
61
62
63
def set_log_level(self, new_level) -> None:
    """
    Set the log level for this node.
    """
    self.log_level = new_level

set_logger(new_logger)

Set the logger for this node.

Source code in src/dendron/condition_node.py 
53
54
55
56
57
def set_logger(self, new_logger) -> None:
    """
    Set the logger for this node.
    """
    self.logger = new_logger