Merge tag 'fix-concurrency' into develop

Fix shared state

Author: fgmacedo

statemachine/state.py

@@ -1,4 +1,5 @@
 from typing import Any, Optional  # noqa: F401, I001
+from copy import deepcopy
 
 from .callbacks import Callbacks
 from .exceptions import StateMachineError
@@ -9,7 +10,7 @@
 
 class State:
     """
-    A State in a state machine describes a particular behaviour of the machine.
+    A State in a state machine describes a particular behavior of the machine.
     When we say that a machine is “in” a state, it means that the machine behaves
     in the way that state describes.
 
@@ -80,15 +81,27 @@ def __init__(
         self.name = name
         self.value = value
         self._id = None  # type: Optional[str]
+        self._storage = ""
         self._initial = initial
         self.transitions = TransitionList()
         self._final = final
         self.enter = Callbacks().add(enter)
         self.exit = Callbacks().add(exit)
 
-    def _setup(self, resolver):
+    def __eq__(self, other):
+        return (
+            isinstance(other, State) and self.name == other.name and self.id == other.id
+        )
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def _setup(self, machine, resolver):
+        self.machine = machine
         self.enter.setup(resolver)
         self.exit.setup(resolver)
+        machine.__dict__[self._storage] = self
+        return self
 
     def _add_observer(self, *resolvers):
         for r in resolvers:
@@ -108,7 +121,8 @@ def __repr__(self):
         )
 
     def __get__(self, machine, owner):
-        self.machine = machine
+        if machine and self._storage in machine.__dict__:
+            return machine.__dict__[self._storage]
         return self
 
     def __set__(self, instance, value):
@@ -118,12 +132,16 @@ def __set__(self, instance, value):
             )
         )
 
+    def clone(self):
+        return deepcopy(self)
+
     @property
     def id(self):
         return self._id
 
     def _set_id(self, id):
         self._id = id
+        self._storage = f"_{id}"
         if self.value is None:
             self.value = id
 

statemachine/statemachine.py

@@ -28,7 +28,9 @@ def __init__(self, model=None, state_field="state", start_value=None):
         self.state_field = state_field
         self.start_value = start_value
 
-        initial_transition = Transition(None, None, event="__initial__")
+        initial_transition = Transition(
+            None, self._get_initial_state(), event="__initial__"
+        )
         self._setup(initial_transition)
         self._activate_initial_state(initial_transition)
 
@@ -39,21 +41,19 @@ def __repr__(self):
             f"current_state={current_state_id!r})"
         )
 
-    def _activate_initial_state(self, initial_transition):
-
+    def _get_initial_state(self):
         current_state_value = (
             self.start_value if self.start_value else self.initial_state.value
         )
-        if self.current_state_value is None:
-
-            try:
-                initial_state = self.states_map[current_state_value]
-            except KeyError as err:
-                raise InvalidStateValue(current_state_value) from err
+        try:
+            return self.states_map[current_state_value]
+        except KeyError as err:
+            raise InvalidStateValue(current_state_value) from err
 
+    def _activate_initial_state(self, initial_transition):
+        if self.current_state_value is None:
             # send an one-time event `__initial__` to enter the current state.
             # current_state = self.current_state
-            initial_transition.target = initial_state
             initial_transition.before.clear()
             initial_transition.on.clear()
             initial_transition.after.clear()
@@ -93,8 +93,18 @@ def _setup(self, initial_transition):
         model = ObjectConfig(self.model, skip_attrs={self.state_field})
         default_resolver = resolver_factory(machine, model)
 
-        initial_transition._setup(default_resolver)
-        self._visit_states_and_transitions(lambda x: x._setup(default_resolver))
+        # clone states and transitions to avoid sharing callbacks references between instances
+        self.states_map = {
+            state.value: state.clone()._setup(self, default_resolver)
+            for state in self.states
+        }
+        self.states = list(self.states_map.values())
+
+        for state in self.states:
+            for transition in state.transitions:
+                transition._setup(self, default_resolver)
+
+        initial_transition._setup(self, default_resolver)
         self.add_observer(machine, model)
 
     def add_observer(self, *observers):

statemachine/transition.py

@@ -70,7 +70,13 @@ def __repr__(self):
             f"internal={self.internal!r})"
         )
 
-    def _setup(self, resolver):
+    def _upd_state_refs(self, machine):
+        if self.source:
+            self.source = machine.__dict__[self.source._storage]
+        self.target = machine.__dict__[self.target._storage]
+
+    def _setup(self, machine, resolver):
+        self._upd_state_refs(machine)
         self.validators.setup(resolver)
         self.cond.setup(resolver)
         self.before.setup(resolver)

tests/examples/order_control_rich_model_machine.py

@@ -62,7 +62,7 @@ class OrderControl(StateMachine):
     control = OrderControl()
 except AttrNotFound as e:
     assert (  # noqa: PT017
-        str(e) == "Did not found name 'payment_received' from model or statemachine"
+        str(e) == "Did not found name 'wait_for_payment' from model or statemachine"
     )
 
 # %%

tests/test_callbacks_isolation.py

@@ -0,0 +1,80 @@
+import pytest
+
+from statemachine import State
+from statemachine import StateMachine
+
+
+@pytest.fixture()
+def simple_sm_cls():
+    class TestStateMachine(StateMachine):
+        # States
+        initial = State("Initial", initial=True)
+        final = State("Final", final=True, enter="do_enter_final")
+
+        finish = initial.to(final, cond="can_finish", on="do_finish")
+
+        def __init__(self, name):
+            self.name = name
+            self.can_finish = False
+            self.finalized = False
+            super(TestStateMachine, self).__init__()
+
+        def do_finish(self):
+            return self.name, self.can_finish
+
+        def do_enter_final(self):
+            self.finalized = True
+
+    return TestStateMachine
+
+
+class TestCallbacksIsolation:
+    def test_should_conditions_be_isolated(self, simple_sm_cls):
+        sm1 = simple_sm_cls("sm1")
+        sm2 = simple_sm_cls("sm2")
+        sm3 = simple_sm_cls("sm3")
+
+        sm1.can_finish = True
+        assert sm1.initial.transitions[0].cond.call() == [True]
+        assert sm2.initial.transitions[0].cond.call() == [False]
+        assert sm3.initial.transitions[0].cond.call() == [False]
+
+    def test_should_actions_be_isolated(self, simple_sm_cls):
+        sm1 = simple_sm_cls("sm1")
+        sm2 = simple_sm_cls("sm2")
+
+        sm1.can_finish = True
+        sm2.can_finish = True
+
+        sm1_initial = sm1.initial
+        sm1_final = sm1.final
+
+        assert sm2.finish() == ("sm2", True)
+
+        assert not sm2.initial.is_active
+        assert sm2.final.is_active
+        assert sm2.finalized is True
+
+        assert sm1_initial.is_active
+        assert not sm1_final.is_active
+        assert sm1.finalized is False
+
+        assert sm1.initial.is_active
+        assert not sm1.final.is_active
+
+        assert sm1.finish() == ("sm1", True)
+
+        assert sm1.finalized is True
+        assert not sm1.initial.is_active
+        assert sm1.final.is_active
+
+    def test_instance_states_and_transitions_are_isolated(self, simple_sm_cls):
+        sm1 = simple_sm_cls("sm1")
+
+        assert sm1.initial == simple_sm_cls.initial
+        assert sm1.initial is not simple_sm_cls.initial
+
+        assert repr(sm1.initial.transitions[0]) == repr(
+            simple_sm_cls.initial.transitions[0]
+        )
+        assert sm1.initial.transitions[0] is not simple_sm_cls.initial.transitions[0]