AsyncMachine run ends after first transition

[dedtadeas]

Hi,
I would like to ask a question, why the run goes only from INITIAL to REQUESTED without triggering on_enter_requested function? Thank you!

class AsyncFlightPlanStateModel():

    lock = asyncio.Lock()
    sm_dict_lock = RUNNING_SMS_DICT_LOCK

    def __init__(self, fp_id):
        self.cancel_flag = False
        self.fp_id = fp_id
        self.fp = FlightPlanDAO().get_flight_plan_complete_data_for_id(fp_id)
        self.instance_lock = asyncio.Lock()

    async def wait(self, event):
        LOGGER.debug(f"Waiting for {waittime} seconds")
        await asyncio.sleep(waittime)

    async def set_cancel(self):
        async with self.instance_lock:
            LOGGER.debug("Setting cancel flag")
            self.cancel_flag = True
            if self.current_state.name == "APPROVED":
                await self.check_cancellation()

    async def check_cancellation(self, event):
        async with self.instance_lock:
            if self.cancel_flag:
                LOGGER.info("Cancellation flag is set. Transitioning to cancelled state.")
                await self.receive_cancelled()
                return True
            return False

    # async def emit_status_to_websocket(self, state):
    #     await websocket_mngr.emit_status_to_websocket(self.fp_id, state)
    #     await websocket_mngr.emit_console_message(self.fp_id, self.fp.status, f"Entering {state}")

    async def update_db_status(self, event):
        state = event.transition.dest
        if state == "INITIAL":
            return
        LOGGER.info(f"Updating DB status to {state}")
        inverse_state_dict = {v: k for k, v in FLIGHT_PLAN_STATUS_ENUM.items()}
        state_num = inverse_state_dict.get(state, None)
        if not state_num is None:
            dao = FlightPlanDAO()
            dao.update_plan_status(self.fp_id, state_num) # TODO: handle timeout etc.
            dao.session.close()

    async def on_enter_requested(self, event):
        LOGGER.info("Entered REQUESTED state..............")
        approvals = [
            PilotValidator().validate(self.fp),
            OperatorValidator().validate(self.fp),
            FlightPlanDateValidator().validate(self.fp),
        ]
        denied = [appr for appr in approvals if appr["appr_state"] == "DENIED"]
        if len(denied) > 0:
            msg = str(denied)
            await self.handle_denial(msg)
        else:
            await self.request_route_4D_validation()
.....

transitions = [
    {'trigger': 'to_draft', 'source': 'INITIAL', 'dest': 'DRAFT'},
    {'trigger': 'to_requested', 'source': 'INITIAL', 'dest': 'REQUESTED'},
    {'trigger': 'to_approved', 'source': 'INITIAL', 'dest': 'APPROVED'},
    {'trigger': 'to_in_execution', 'source': 'INITIAL', 'dest': 'IN_EXECUTION'},
    {'trigger': 'to_finished', 'source': 'INITIAL', 'dest': 'FINISHED'},
    {'trigger': 'to_analysis', 'source': 'INITIAL', 'dest': 'ANALYSIS'},
    {'trigger': 'to_completed', 'source': 'INITIAL', 'dest': 'COMPLETED'},
    {'trigger': 'request_flight_plan', 'source': 'DRAFT', 'dest': 'REQUESTED'},
    {'trigger': 'request_route_4D_validation', 'source': 'REQUESTED', 'dest': 'ROUTE_4D_VALIDATION'},

....

if __name__ == "__main__":
    fp_id = 874
    model = AsyncFlightPlanStateModel(fp_id)
    machine = AsyncMachine(
                    model,
                    name=str(fp_id),
                    states=states,
                    transitions=transitions,
                    initial='INITIAL',
                    queued=True,
                    send_event=True,
                    before_state_change=["wait", "check_cancellation"],
                    after_state_change=["update_db_status"],
                    #finalize_event="emit_status_to_websocket",
                    on_exception='handle_error',
                    )
    asyncio.get_event_loop().run_until_complete(model.to_requested())

[dedtadeas]

Just found the solution. I was formally working with the package which was not case sensitive.
I should use on_enter_REQUESTED(....

[aleneum]

Hello @dedtadeas,

as you already figured out transitions is case-sensitive. Names of convenience methods (to_<state>, is_<state>) depend on a state's name while the model attribute attached to a stateful object (either machine or a dedicated model) depends on a state's value. When using strings for states, both should be the same. In case of Enums both can differ. You can use a customized state object in case you always want state names (and values) and thus convenience methods to be lower case:

from transitions import Machine, State


class LowerCaseState(State):

    @property
    def name(self):
        return super().name.lower()

    @property
    def value(self):
        return super().value.lower()


class LowerCaseMachine(Machine):
    state_cls = LowerCaseState


class Model:

    def on_enter_final_state(self):
        self.to_b()


model = Model()
machine = LowerCaseMachine(model, states=["INIT", "A", "b", "fInAL_sTAtE"], initial="init")
assert model.state == "init"
assert hasattr(model, "to_a")
assert hasattr(model, "to_final_state")
model.to_final_state()
assert model.state == "b"
assert not model.is_final_state()

# just for illustration
assert machine.states["init"]._name == "INIT"

You just need to be careful to 'address' states by their normalized/lower case name because even though states still have their original strings internally, Machine has no knowledge about this.
If you do not need to handle Enums, you can also just override the constructor to pass the state name in lower case:

class LowerCaseState(State):

    def __init__(self, name, on_enter=None, on_exit=None, ignore_invalid_triggers=None):
        super().__init__(name.lower(), on_enter=on_enter,
                         on_exit=on_exit, ignore_invalid_triggers=ignore_invalid_triggers)

For AsyncMachine you should inherit from AsyncState instead. This is of course not actual case insensitivity but it might help to 'normalize' state names and methods.