Omiting calling on_enter and on_exit callbacks, if origin and target state is the same (reentrant state)

[nadlechSICKAG]

My understanding of having before and after callbacks in additions to on_enter and on_exit was also to differentiate the entranc of the state and the transition itself. But now I tested my state machine and turns out, in case of re-entrant states the callbacks are triggered.

How can I omit this behavior? For example: if I am in State "A" and call the 'to_A' method, then the callback "on_enter_A" will be called (but I don't want to call this because I am already in State "A").

[aleneum]

Hello @nadlechSICKAG,

the convenience "to_" methods behave like standard transitions with source equals target. What you are looking for are probably internal transitions. As mentioned here in the Readme you can define internal transitions by stating a source and None as a destination:

from transitions import Machine

machine = Machine(states=["A"], initial="A", before_state_change=[lambda: print("before state change")])
machine.on_enter_A(lambda: print("enter State A"))
machine.on_exit_A(lambda: print("exit State A"))
machine.add_transition(trigger="internal", source="A", dest=None, after=[lambda: print("action after internal")])


machine.to_A() 
# >> before state change
# exit State A
# enter State A
assert machine.state == "A"
machine.internal()
# >> before state change 
# action after internal (but no exit/enter state change)

This will not trigger on_enter/exit_<state> callbacks BUT global callbacks defined in before/after_state_change.

I hope this helps. If you have further questions let me know,

[nadlechSICKAG]

Yes, I noticed the internal states, but this is not exactly what I am looking for.

what about changing the transition class to:

    def _change_state(self, event_data):
            if self._reentrant or self.source != self.dest:
                event_data.machine.get_state(self.source).exit(event_data)
                event_data.machine.set_state(self.dest, event_data.model)
                event_data.update(getattr(event_data.model, event_data.machine.model_attribute))
                dest = event_data.machine.get_state(self.dest)
                dest.enter(event_data)
                if dest.final:
                    event_data.machine.callbacks(event_data.machine.on_final, event_data)

or even better changing the evaluate method:

if self.dest and (self._reentrant or self.source != self.dest):  # if self.dest is None this is an internal transition with no actual state change
            self._change_state(event_data)

Don't know if this would bring side effects, but then there would be the possibility to configure the desired behavior.

If OK, I would then do the PR

[aleneum]

Yes, I noticed the internal states, but this is not exactly what I am looking for.

Could you specify what you are looking for? If you are looking for transitions that can execute callbacks before and after a trigger has been called but do not exit or enter a state then I'd say internal transitions are what you are looking for. An 'external' transition is the default transitions type (we tried to follow state chart SCXML behaviour here; Section 3.5) should exit a state and enter a state, regardless of their source and destination.

So if you want a trigger to act as an internal transition when in the target state but different when not you could do something like the following:

machine.add_transition("my_event", source="A", dest=None) 
machine.add_transition("my_event", source="*", dest="A")

Transitions will handle transitions associated with the same event in the order they were added. The first one that matches source and with successful condition checks will be executed.

If this still does not cover your use case let me know. I'd appreciate an example so I got a better understanding of why internal transitions are not suitable.

[nadlechSICKAG]

Yes, this will cover my use case indeed and probably be way easier than the PR. Thanks for the idea.

[aleneum]

Nice. In case you want nothing to happen, you could simplify the configuration when setting send_event=True on your machine and checking the source:

from transitions import Machine

machine = Machine(states=["A", "B"], initial="A", send_event=True)
machine.add_transition("my_event", source="*", dest="A", unless=lambda evt: evt.state.name == "A")

assert not machine.my_event()  # transition not successful
machine.to_B()
assert machine.my_event()  # transition successful