Added PreConditions functionality

Author: ZigRazor

sample/sample2.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0"?>
+<x:States xmlns:x="pystatemachine:sm">
+    <State>
+        <Name>Enter</Name>
+        <Event>
+            <Name>ToExit</Name>
+            <ToState>Exit</ToState>
+            <PreConditions>
+                <Condition>
+                    <Expression>test2.everFalse</Expression>
+                    <Result>False</Result>
+                </Condition>
+                <Condition>
+                    <Expression>test2.test</Expression>
+                    <Result>2</Result>
+                </Condition>
+            </PreConditions>
+        </Event>
+    </State>
+    <State>
+        <Name>Exit</Name>
+        <Event>
+            <Name>ToNull</Name>
+            <ToState>Null</ToState>
+            <PreConditions>
+                <Condition>
+                    <Expression>test2.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

@@ -3,7 +3,7 @@
             targetNamespace="pystatemachine:sm"
             xmlns:sm="pystatemachine:sm">
     <!-- definition of simple elements -->
-    <xs:element name="Condition" type="sm:NonEmptyString"/>
+    <!--xs:element name="Condition" 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 -->
@@ -14,9 +14,17 @@
     </xs:simpleType>
 
     <!-- definition of Complex Type-->
+    <xs:complexType name="Condition">
+        <xs:sequence>
+            <xs:element name="Expression" type="sm:NonEmptyString" minOccurs="1" maxOccurs="1"/>
+            <xs:element name="Result" type="sm:NonEmptyString" minOccurs="1" maxOccurs="1"/>
+        </xs:sequence>
+    </xs:complexType>
+
+
     <xs:complexType name="Conditions">
         <xs:sequence>
-            <xs:element ref="sm:Condition" minOccurs="1"/>
+            <xs:element name="Condition" type="sm:Condition" minOccurs="1"/>
         </xs:sequence>
     </xs:complexType>
 

src/Condition.py

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

src/Conditions.py

@@ -1,7 +1,7 @@
 class Conditions:
-    def __init__(self,condition:str):
-        self.condition = condition
-        
+    def __init__(self, conditions = [] ):
+        self.conditions = conditions
+
     def to_string(self):
         result_s = ""
         return result_s

src/Event.py

@@ -9,24 +9,6 @@ def __init__(self, name :str, to_state: str, pre_conditions: Conditions, post_co
         self.post_conditions = post_conditions
         self.pre_actions = pre_actions
         self.post_actions = post_actions
-
-    def get_name(self):
-        return self.name
-
-    def get_to_state(self):
-        return self.to_state
-    
-    def get_pre_conditions(self):
-        return self.pre_conditions
-
-    def get_post_conditions(self):
-        return self.post_conditions
-    
-    def get_pre_actions(self):
-        return self.pre_actions
-
-    def get_post_actions(self):
-        return self.post_actions
 
     def to_string(self):
         result_s = "Event: \n"

src/ReadStateMachine.py

@@ -1,3 +1,4 @@
+from Condition import Condition
 from Conditions import Conditions
 from Actions import Actions
 from Event import Event
@@ -25,8 +26,8 @@ def ReadStateMachineFile(xml_file : str):
                     # State->Event Element
                     event_name = ""
                     to_state = ""
-                    pre_conditions = Conditions("") # dummy
-                    post_conditions = Conditions("") # dummy
+                    pre_conditions = None # dummy
+                    post_conditions = None # dummy
                     pre_actions = Actions("") #dummy
                     post_actions = Actions("") #dummy
 
@@ -43,10 +44,20 @@ def ReadStateMachineFile(xml_file : str):
                             to_state = event_child.text
                         elif event_child.tag == "PreConditions":
                             # State->Event->PreConditions Element
+                            pre_condition_elements = []
                             for preconditions_child in event_child:
                                 #print(preconditions_child.text)
                                 # State->Event->PreConditions->Condition Element
-                                None
+                                if preconditions_child.tag == "Condition":
+                                    expression = ""
+                                    result = ""
+                                    for condition_child in preconditions_child:
+                                        if condition_child.tag == "Expression":
+                                            expression = condition_child.text
+                                        elif condition_child.tag == "Result":
+                                            result = condition_child.text
+                                    pre_condition_elements.append(Condition(expression,result))
+                            pre_conditions = Conditions(pre_condition_elements)
                         elif event_child.tag == "PostConditions":
                             # State->Event->PostConditions Element
                             for postconditions_child in event_child:

src/State.py

@@ -1,16 +1,8 @@
-import Event
-
 class State:
     def __init__(self, name: str, events = {}):
         self.name = name
         self.events = events
-
-    def get_name(self):
-        return self.name
-
-    def get_events(self):
-        return self.events
-        
+      
     def to_string(self):
         result_s = "State:\n"
         result_s += "  Name: " + self.name + "\n"

src/StateMachine.py

@@ -7,6 +7,7 @@ def __init__(self, xml_file : str):
         self.xml_file = xml_file
         self.states = None
         self.current_state = ""
+        self.context = {}
 
     def get_current_state(self):
         return self.current_state
@@ -17,18 +18,44 @@ def LoadStateMachine(self):
         else:    
             self.xml_file
             self.states , self.current_state = ReadStateMachineFile(self.xml_file)
+
+    def addVariableToContext(self, module : str, variable : str):
+        mod = __import__(module)
+        func = getattr(mod, variable)
+        self.context[module+"."+variable] = func
 
     def InjectEvent(self, event : str):
         my_state = self.states[self.current_state]
-        possible_events = my_state.get_events()
+        possible_events = my_state.events
         if event in possible_events:
             handled_event = possible_events[event]
             ## Preconditions
-            ## Preactions
-            print("Transition ", self.current_state, " ------> ", handled_event.get_to_state())
-            self.current_state = handled_event.get_to_state()
-            ## Postactions
-            ## Postconditions
+            all_pre_conditions_satisfied = True
+            if(handled_event.pre_conditions != None):
+                pre_conditions = handled_event.pre_conditions.conditions
+                for condition in pre_conditions:
+                    if condition.expression in self.context:
+                        func = self.context[condition.expression]
+                        result = None
+                        if callable(func):
+                            result = func()
+                        else:
+                            result = func
+                        if str(result) != condition.result:
+                           all_pre_conditions_satisfied = False
+                           break
+            else:
+                print("No Precondition")
+
+            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
+            else:
+                print("Not all PreConditions satisfied")
         else:
             print("Not a possible event")
 

tests/test2.py

@@ -0,0 +1,33 @@
+import sys
+sys.path.append('../src')
+
+from StateMachine import StateMachine
+
+test = 2
+
+def main():
+    
+    sm = StateMachine("../sample/sample2.xml")
+
+    sm.LoadStateMachine()
+
+    sm.addVariableToContext("test2", "everFalse")
+    sm.addVariableToContext("test2", "test")
+    
+    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
+    
+    
+if __name__ == "__main__":
+    main()