Skip to content

Fallback

dendron.controls.fallback.Fallback

Bases: ControlNode

Source code in src/dendron/controls/fallback.py 
  7
  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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
class Fallback(ControlNode):

    _used_names = set(["fallback"])

    """
    A Fallback node is a control node that ticks its children in 
    sequence, until a child returns `SUCCESS`, at which point it
    returns success. If all children return `FAILURE`, then the
    Fallback node returns `FAILURE`. The intuition is that the
    Fallback node is trying different options until it finds one
    that works.

    Args:
        name (`str`):
            The given name of this node.
        children (`List[TreeNode]`):
            A list of `TreeNode`s to initialize the children of this
            node. Will be ticked in the order they are given.            
    """

    def __init__(self, children : List[TreeNode] = [], name : str = "fallback") -> None:
        super().__init__(children)

        self._name = None
        self.name = name

        self.current_child_idx = 0

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

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

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

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

    def reset(self) -> None:
        """
        Set the current child index to 0 and instruct all children
        to reset.
        """
        self.current_child_idx = 0
        for child in self.children:
            child.reset()

    def halt_node(self) -> None:
        """
        Set the current child index to 0 and instruct all children
        to halt via the parent class `halt()`.
        """
        self.current_child_idx = 0
        ControlNode.halt(self)

    def tick(self) -> NodeStatus:
        """
        Successively `tick()` each child node until one returns a
        status of `SUCCESS`. If all children fail, return `FAILURE`.

        Returns:
            `NodeStatus`: `SUCCESS` if at least one child succeeds,
            `FAILURE` otherwise. May return `RUNNING` or `SKIPPED`
            depending on children's behavior.
        """
        n_children = self.children_count()
        self.set_status(NodeStatus.RUNNING)

        while(self.current_child_idx < n_children):
            current_child = self.children[self.current_child_idx]

            child_status = current_child.execute_tick()

            match child_status:
                case NodeStatus.RUNNING:
                    return NodeStatus.RUNNING
                case NodeStatus.FAILURE:
                    self.current_child_idx += 1
                case NodeStatus.SUCCESS:
                    self.reset()
                    self.current_child_idx = 0
                    return child_status
                case NodeStatus.SKIPPED:
                    self.current_child_idx += 1
                case NodeStatus.IDLE:
                    raise RuntimeError("Child can't return IDLE")

        if self.current_child_idx == n_children:
            self.reset()

        return NodeStatus.FAILURE

    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}Fallback {self.name}"
        for child in self.children:
            child_repr = child.pretty_repr(depth+1)
            repr += f"\n{child_repr}"
        repr += "\n"
        return repr

halt_node()

Set the current child index to 0 and instruct all children to halt via the parent class halt().

Source code in src/dendron/controls/fallback.py 
64
65
66
67
68
69
70
def halt_node(self) -> None:
    """
    Set the current child index to 0 and instruct all children
    to halt via the parent class `halt()`.
    """
    self.current_child_idx = 0
    ControlNode.halt(self)

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/controls/fallback.py 
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
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}Fallback {self.name}"
    for child in self.children:
        child_repr = child.pretty_repr(depth+1)
        repr += f"\n{child_repr}"
    repr += "\n"
    return repr

reset()

Set the current child index to 0 and instruct all children to reset.

Source code in src/dendron/controls/fallback.py 
55
56
57
58
59
60
61
62
def reset(self) -> None:
    """
    Set the current child index to 0 and instruct all children
    to reset.
    """
    self.current_child_idx = 0
    for child in self.children:
        child.reset()

tick()

Successively tick() each child node until one returns a status of SUCCESS. If all children fail, return FAILURE.

Returns:

Type Description
NodeStatus

NodeStatus: SUCCESS if at least one child succeeds,
NodeStatus

FAILURE otherwise. May return RUNNING or SKIPPED
NodeStatus

depending on children's behavior.
Source code in src/dendron/controls/fallback.py 
 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
def tick(self) -> NodeStatus:
    """
    Successively `tick()` each child node until one returns a
    status of `SUCCESS`. If all children fail, return `FAILURE`.

    Returns:
        `NodeStatus`: `SUCCESS` if at least one child succeeds,
        `FAILURE` otherwise. May return `RUNNING` or `SKIPPED`
        depending on children's behavior.
    """
    n_children = self.children_count()
    self.set_status(NodeStatus.RUNNING)

    while(self.current_child_idx < n_children):
        current_child = self.children[self.current_child_idx]

        child_status = current_child.execute_tick()

        match child_status:
            case NodeStatus.RUNNING:
                return NodeStatus.RUNNING
            case NodeStatus.FAILURE:
                self.current_child_idx += 1
            case NodeStatus.SUCCESS:
                self.reset()
                self.current_child_idx = 0
                return child_status
            case NodeStatus.SKIPPED:
                self.current_child_idx += 1
            case NodeStatus.IDLE:
                raise RuntimeError("Child can't return IDLE")

    if self.current_child_idx == n_children:
        self.reset()

    return NodeStatus.FAILURE