How to create a Sequence that always returns success and stops when the first child returns failure?

[seantcanavan]

Hey guys! Very new here but have been spending the last two days steeped in this library but I can't figure this one out. I want specific child steps to show [X] in the post_tick_handler print so I know there was nothing to do in that step don't want those Status.FAILURE values to cascade up the tree.

I ended up overriding the Sequence class with a custom tick method:

    def tick(self) -> Iterator[Behaviour]:
        """
        Tick over the children.
        """
        self.logger.debug("%s.tick()" % self.__class__.__name__)

        # initialise
        index = 0
        if self.status != Status.RUNNING:
            self.current_child = self.children[0] if self.children else None
            for child in self.children:
                if child.status != Status.INVALID:
                    child.stop(Status.INVALID)
            self.initialise()  # user specific initialisation
        elif self.memory and Status.RUNNING:
            assert self.current_child is not None  # should never be true, help mypy out
            index = self.children.index(self.current_child)
        elif not self.memory and Status.RUNNING:
            self.current_child = self.children[0] if self.children else None
        else:
            # previous conditional checks should cover all variations
            raise RuntimeError("Sequence reached an unknown / invalid state")

        # nothing to do
        if not self.children:
            self.current_child = None
            self.stop(Status.SUCCESS)
            yield self
            return

        # actual work
        for child in itertools.islice(self.children, index, None):
            for node in child.tick():
                yield node
                if node is child:
                    if node.status == Status.FAILURE:
                        self.status = Status.SUCCESS
                        if not self.memory:
                            # invalidate the remainder of the sequence
                            # i.e. kill dangling runners
                            for child in itertools.islice(self.children, index + 1, None):
                                if child.status != Status.INVALID:
                                    child.stop(Status.INVALID)
                        yield self
                        return
                    elif node.status != Status.SUCCESS:
                        self.status = node.status
                        if not self.memory:
                            # invalidate the remainder of the sequence
                            # i.e. kill dangling runners
                            for child in itertools.islice(self.children, index + 1, None):
                                if child.status != Status.INVALID:
                                    child.stop(Status.INVALID)
                        yield self
                        return
            try:
                # advance if there is 'next' sibling
                self.current_child = self.children[index + 1]
                index += 1
            except IndexError:
                pass

        self.stop(Status.SUCCESS)
        yield self

but this feels like a ton of work, probably has bugs in it, and would be out of date when the library version gets bumped and potentially new functionality is added to Sequences.

here's the output I have now which I really like:

[-] MainDecisionTree [✓]
    --> Step A [✓]
    --> Step B [✓]
    --> Step C [✓]
    [-] Branch 1 [✓]  # normally this would be [X] with a normal sequence
        [-] Sub-sequence 1 [✓]  # normally this would be [X] with a normal sequence
            --> Task 1 [✓]
            --> Task 2 [✕]
            --> Task 3
        [-] Sub-sequence 2 [✓]
            --> Task 4 [✓]
            --> Task 5 [✓]
            --> Task 6 [✓]
        [-] Sub-sequence 3 [✓]
            --> Task 7 [✓]
            --> Task 8 [✓]
            --> Task 9 [✓]
    --> Finalize [✓]

You can see that I have blocked sub-seq 1 task 3 from even executing. I like the idea of cutting off entire branches of the logic during execution to keep bugs down. It also lets me know at a very high level, instantly, that sub-seq 1 task 2's conditions were not met (aka nothing to do) and 3 did not fire at all.

I tried everything I can think of including Parallel with a SuccessOnSome policy but that isn't working for me either unfortunately.