How to transition in a bifurcation (?)

[brunolnetto]

• Python State Machine version: 2.4.0
• Python version: Python 3.10.12
• Operating System: Ubuntu 20.04

Description

This is a simple example: Given states and transitions, I want to transition from state 1 (It could be 3 as well), to either 2 or 3 (respective states 0 or F). I am unable to find API method for this action. The example and diagram follow below.

I undestand it is a misuse of my part since I am able to define single state-to-state instead of or-defined transition coupling. I mean, it is not a library flaw, but also too trivial to be mistake by other library users. I ask politely to disconsider our previous conflicts, I come in peace. In my opinion, it answers the issue #494 as well

What I Did

Code:

from statemachine import StateMachine, State

class MyStateMachine(StateMachine):
    # States
    S0 = State(initial=True)
    S1 = State()
    S2 = State()
    S3 = State()
    SF = State(final=True)
    
    # Transitions
    T0_1 = S0.to(S1)
    T1_23 = S1.to(S3) | S1.to(S2)
    T2_3F = S2.to(S3) | S2.to(SF) 
    T3_0F = S3.to(S0) | S1.to(SF)

msm=MyStateMachine()

print_at_map=lambda state: print(f"You are at state {msm.current_state}") 

print_at_map(msm.current_state)
msm.send('T0_1')
print_at_map(msm.current_state)
msm.send('T1_23')
print_at_map(msm.current_state)
msm.send('T3_0F')
print_at_map(msm.current_state)

Output:

You are at state S0
You are at state S1
You are at state S3
You are at state S0

[fgmacedo]

Hi, @brunolnetto. Thanks for your question. Your use case is covered by conditions.

To address your question about transitioning from state S1 to either S2 or S3 based on certain conditions, the python-statemachine library provides a feature called Conditions (also known as Guards) that allows for conditional transitions. This means you can define multiple transitions from a single state, each with its own condition, and the state machine will evaluate these conditions in the order they are declared, executing the first transition whose condition is met.

Here's an example of how you can implement this:

from statemachine import StateMachine, State

class MyStateMachine(StateMachine):
    # Define states
    S0 = State('S0', initial=True)
    S1 = State('S1')
    S2 = State('S2')
    S3 = State('S3')
    SF = State('SF', final=True)
    
    # Define transitions with conditions
    T0_1 = S0.to(S1)
    T1_23 = (
        S1.to(S3, cond="condition_for_S3") |
        S1.to(S2, cond="condition_for_S2")
    )
    T2_3F = (
        S2.to(S3) |
        S2.to(SF)
    )
    T3_0F = (
        S3.to(S0) |
        S3.to(SF)
    )

    def condition_for_S3(self):
        # Define the logic for the condition
        return True  # Example: condition met for transition to S3

    def condition_for_S2(self):
        # Define the logic for the condition
        return False  # Example: condition not met for transition to S2

# Example usage
msm = MyStateMachine()
print(f"Current state: {msm.current_state.id}")  # Output: S0
msm.T0_1()
print(f"Current state: {msm.current_state.id}")  # Output: S1
msm.T1_23()  # Evaluates conditions: transitions to S3 since condition_for_S3 returns True
print(f"Current state: {msm.current_state.id}")  # Output: S3

In this example:

• States: S0, S1, S2, S3, and SF are defined, with S0 as the initial state and SF as the final state.
• Transitions: Multiple transitions are defined from S1 to S2 and S3, each with its own condition (condition_for_S2 and condition_for_S3, respectively). The state machine evaluates these conditions when the event is triggered and executes the first transition whose condition is met.

This approach allows you to control the flow of your state machine based on dynamic conditions at runtime.

For more detailed information, you can refer to the documentation on Conditions and Validators.

Best regards!

[brunolnetto]

This feels somewhat like code smell to broaden the Correctness guarantees on user usage: given conditions, map all conditions and verify if there is more than a single True statement. Caveat: async and sync conditions; conditions with computational runtime with different magnitudes. It is up to you to check for this vulnerability or not.

I appreciate already the single component and path-check from every non-final node to at least a final node.

I will close this, but I leave this as suggestion.