Introduced PreActions in state machine

Author: ZigRazor

sample/sample3.xml

@@ -0,0 +1,46 @@
+<?xml version="1.0"?>
+<x:States xmlns:x="pystatemachine:sm">
+    <State>
+        <Name>Enter</Name>
+        <Event>
+            <Name>ToExit</Name>
+            <ToState>Exit</ToState>
+            <PreConditions>
+                <Condition>
+                    <Expression>test3.everFalse</Expression>
+                    <Result>False</Result>
+                </Condition>
+                <Condition>
+                    <Expression>test3.test</Expression>
+                    <Result>2</Result>
+                </Condition>
+            </PreConditions>            
+            <PreActions>
+                <Action>
+                    <Expression>test3.testPrint</Expression>
+                </Action>
+            </PreActions>
+        </Event>
+    </State>
+    <State>
+        <Name>Exit</Name>
+        <Event>
+            <Name>ToNull</Name>
+            <ToState>Null</ToState>
+            <PreConditions>
+                <Condition>
+                    <Expression>test3.everFalse</Expression>
+                    <Result>True</Result>
+                </Condition>
+            </PreConditions>
+        </Event>
+    </State>
+    <State>
+        <Name>Null</Name>
+        <Event>
+            <Name>ToNull</Name>
+            <ToState>Null</ToState>
+        </Event>
+    </State>
+    <Initial_State>Enter</Initial_State>
+</x:States>

schema/StateMachine.xsd

@@ -4,7 +4,7 @@
             xmlns:sm="pystatemachine:sm">
     <!-- definition of simple elements -->
     <!--xs:element name="Condition" type="sm:NonEmptyString"/-->
-    <xs:element name="Action" type="sm:NonEmptyString"/>
+    <!--xs:element name="Action" type="sm:NonEmptyString"/-->
     <!-- definition of simple type -->
     <xs:simpleType name="NonEmptyString"> <!-- we can describe our types separately to reuse them later -->
         <xs:restriction base="xs:string">
@@ -21,6 +21,12 @@
         </xs:sequence>
     </xs:complexType>
 
+    <xs:complexType name="Action">
+        <xs:sequence>
+            <xs:element name="Expression" type="sm:NonEmptyString" minOccurs="1" maxOccurs="1"/>
+        </xs:sequence>
+    </xs:complexType>
+
 
     <xs:complexType name="Conditions">
         <xs:sequence>
@@ -30,7 +36,7 @@
 
     <xs:complexType name="Actions">
         <xs:sequence>
-            <xs:element ref="sm:Action" minOccurs="1"/>
+            <xs:element name="Action" type="sm:Action" minOccurs="1" maxOccurs="1"/>
         </xs:sequence>
     </xs:complexType>
 

src/Action.py

@@ -0,0 +1,7 @@
+class Action:
+    def __init__(self, expression :str):
+        self.expression = expression
+                
+    def to_string(self):
+        result_s = ""
+        return result_s

src/Actions.py

@@ -1,6 +1,6 @@
 class Actions:
-    def __init__(self, action : str):
-        self.action = action
+    def __init__(self, actions = []):
+        self.actions = actions
 
     def to_string(self):
         result_s = ""

src/ReadStateMachine.py

@@ -1,6 +1,7 @@
 from Condition import Condition
 from Conditions import Conditions
 from Actions import Actions
+from Action import Action
 from Event import Event
 from State import State
 import xml.etree.ElementTree as ET
@@ -28,8 +29,8 @@ def ReadStateMachineFile(xml_file : str):
                     to_state = ""
                     pre_conditions = None # dummy
                     post_conditions = None # dummy
-                    pre_actions = Actions("") #dummy
-                    post_actions = Actions("") #dummy
+                    pre_actions = None #dummy
+                    post_actions = None #dummy
 
                     for event_child in state_child:
 
@@ -66,10 +67,18 @@ def ReadStateMachineFile(xml_file : str):
                                 None
                         elif event_child.tag == "PreActions":
                             # State->Event->PreActions Element
+                            pre_action_elements = []
                             for preactions_child in event_child:
                                 #print(preactions_child.text)
                                 # State->Event->PreActions->Action Element
-                                None
+                                if preactions_child.tag == "Action":
+                                    expression = ""                                   
+                                    for action_child in preactions_child:
+                                        if action_child.tag == "Expression":
+                                            expression = action_child.text
+                                    pre_action_elements.append(Action(expression))
+                            pre_actions = Actions(pre_action_elements)
+
                         elif event_child.tag == "PostActions":
                             # State->Event->PostActions Element
                             for postactions_child in event_child:

src/StateMachine.py

@@ -9,25 +9,47 @@ def __init__(self, xml_file : str):
         self.current_state = ""
         self.context = {}
 
-    def __CheckCondition(self,conditions):
+    def __CheckConditions(self,conditions):
         all_conditions_satisfied = True
         if(conditions != None):
-            conditions = conditions.conditions
-            for condition in conditions:
+            _conditions = conditions.conditions
+            for condition in _conditions:
                 if condition.expression in self.context:
                     func = self.context[condition.expression]
                     result = None
-                if callable(func):
-                    result = func()
+                    if callable(func):
+                        result = func()
+                    else:
+                        result = func
+                    if str(result) != condition.result:
+                        all_conditions_satisfied = False
+                        break
                 else:
-                    result = func
-                if str(result) != condition.result:
-                    all_conditions_satisfied = False
-                    break
+                    print("No Found Condition Expression ", condition.expression ," in Context")
+                    all_conditions_satisfied = False      
         else:
-            print("No Precondition")
+            print("No Condition")
         return all_conditions_satisfied
 
+    def __ExecActions(self,actions):
+        all_action_executed = True
+        if(actions != None):
+            _actions = actions.actions
+            for action in _actions:
+                if action.expression in self.context:
+                    func = self.context[action.expression]                    
+                    if callable(func):
+                        #print("Call ",action.expression)
+                        func()
+                    else:
+                        func 
+                else:
+                    print("No Found Action Expression ", action.expression ," in Context")
+                    all_action_executed = False;                
+        else:
+            print("No Action")        
+        return all_action_executed
+
     def get_current_state(self):
         return self.current_state
 
@@ -49,14 +71,16 @@ def InjectEvent(self, event : str):
         if event in possible_events:
             handled_event = possible_events[event]
             ## Preconditions
-            all_pre_conditions_satisfied = self.__CheckCondition(handled_event.pre_conditions)
+            all_pre_conditions_satisfied = self.__CheckConditions(handled_event.pre_conditions)
             if(all_pre_conditions_satisfied):
                 ## Preactions
-                ## Transition
-                print("Transition ", self.current_state, " ------> ", handled_event.to_state)
-                self.current_state = handled_event.to_state
-                ## Postactions
-                ## Postconditions
+                all_pre_actions_executed = self.__ExecActions(handled_event.pre_actions)
+                if(all_pre_actions_executed):
+                    ## Transition
+                    print("Transition ", self.current_state, " ------> ", handled_event.to_state)
+                    self.current_state = handled_event.to_state
+                    ## Postactions
+                    ## Postconditions
             else:
                 print("Not all PreConditions satisfied")
         else:

tests/test3.py

@@ -0,0 +1,37 @@
+import sys
+sys.path.append('../src')
+
+from StateMachine import StateMachine
+
+test = 2
+
+def main():
+    
+    sm = StateMachine("../sample/sample3.xml")
+
+    sm.LoadStateMachine()
+
+    sm.addVariableToContext("test3", "everFalse")
+    sm.addVariableToContext("test3", "test")
+    sm.addVariableToContext("test3", "testPrint")
+    
+    print(sm.get_current_state())
+    sm.InjectEvent("ToExit")
+    print(sm.get_current_state())
+    sm.InjectEvent("ToExit")
+    print(sm.get_current_state())
+    sm.InjectEvent("ToNull")
+    print(sm.get_current_state())
+    sm.InjectEvent("ToExit")
+    print(sm.get_current_state())
+    sm.InjectEvent("ToNull")
+
+def everFalse():
+    return False
+
+def testPrint():
+    print("Test")
+    
+    
+if __name__ == "__main__":
+    main()