Merge branch 'main' of https://github.com/ZigRazor/PyStateMachine

Author: ZigRazor

src/Action.py

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

src/Actions.py

@@ -1,9 +1,10 @@
 class Actions:
-    def __init__(self, actions = None):
+    def __init__(self, actions=None):
         if actions is None:
             actions = []
         self.actions_list = actions
+
     @staticmethod
     def to_string():
         result_s = ""
-        return result_s
+        return result_s

src/Condition.py

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

src/Conditions.py

@@ -1,10 +1,10 @@
 class Conditions:
-    def __init__(self, conditions = None ):
+    def __init__(self, conditions=None):
         if conditions is None:
             conditions = []
         self.conditions_list = conditions
 
     @staticmethod
     def to_string():
         result_s = ""
-        return result_s
+        return result_s

src/Event.py

@@ -1,21 +1,22 @@
 import Actions
 import Conditions
 
+
 class Event:
-    def __init__(self, name :str, to_state: str, pre_conditions: Conditions, post_conditions: Conditions, pre_actions: Actions, post_actions: Actions):
+    def __init__(self, name: str, to_state: str, pre_conditions: Conditions, post_conditions: Conditions, pre_actions: Actions, post_actions: Actions):
         self.name = name
         self.to_state = to_state
         self.pre_conditions = pre_conditions
         self.post_conditions = post_conditions
         self.pre_actions = pre_actions
         self.post_actions = post_actions
-        
+
     def to_string(self):
         result_s = "Event: \n"
         result_s += "\tName: " + self.name + "\n"
         result_s += "\tToState: " + self.to_state + "\n"
         result_s += "\tPreConditions: " + self.pre_conditions.to_string() + "\n"
         result_s += "\tPostConditions: " + self.post_conditions.to_string() + "\n"
         result_s += "\tPreActions: " + self.pre_actions.to_string() + "\n"
-        result_s += "\tPostActions: " +  self.post_actions.to_string() + "\n"
-        return result_s
+        result_s += "\tPostActions: " + self.post_actions.to_string() + "\n"
+        return result_s

src/ReadStateMachine.py

@@ -7,15 +7,15 @@
 import defusedxml.ElementTree as ET
 
 
-def ReadStateMachineFile(xml_file : str):
+def ReadStateMachineFile(xml_file: str):
     states = {}
     initial_state = ""
     tree = ET.parse(xml_file)
     root = tree.getroot()
     for states_child in root:
         #print(states_child.tag, states_child.attrib)
         # States Element
-        if states_child.tag == "State" :
+        if states_child.tag == "State":
             #print("State element")
             # State Element
             state_name = ""
@@ -27,13 +27,13 @@ def ReadStateMachineFile(xml_file : str):
                     # State->Event Element
                     event_name = ""
                     to_state = ""
-                    pre_conditions = None # dummy
-                    post_conditions = None # dummy
-                    pre_actions = None #dummy
-                    post_actions = None #dummy
-                    
+                    pre_conditions = None  # dummy
+                    post_conditions = None  # dummy
+                    pre_actions = None  # dummy
+                    post_actions = None  # dummy
+
                     for event_child in state_child:
-                                                
+
                         #print(event_child.tag, event_child.attrib)
                         if event_child.tag == "Name":
                             #print("Name element = ", event_child.text)
@@ -47,7 +47,7 @@ def ReadStateMachineFile(xml_file : str):
                             # State->Event->PreConditions Element
                             pre_condition_elements = []
                             for preconditions_child in event_child:
-                                #print(preconditions_child.text)
+                                # print(preconditions_child.text)
                                 # State->Event->PreConditions->Condition Element
                                 if preconditions_child.tag == "Condition":
                                     expression = ""
@@ -57,13 +57,14 @@ def ReadStateMachineFile(xml_file : str):
                                             expression = condition_child.text
                                         elif condition_child.tag == "Result":
                                             result = condition_child.text
-                                    pre_condition_elements.append(Condition(expression,result))
+                                    pre_condition_elements.append(
+                                        Condition(expression, result))
                             pre_conditions = Conditions(pre_condition_elements)
                         elif event_child.tag == "PostConditions":
                             # State->Event->PostConditions Element
                             post_condition_elements = []
                             for postconditions_child in event_child:
-                                #print(postconditions_child.text)
+                                # print(postconditions_child.text)
                                 # State->Event->PostConditions->Condition Element
                                 if postconditions_child.tag == "Condition":
                                     expression = ""
@@ -73,48 +74,53 @@ def ReadStateMachineFile(xml_file : str):
                                             expression = condition_child.text
                                         elif condition_child.tag == "Result":
                                             result = condition_child.text
-                                    post_condition_elements.append(Condition(expression,result))
-                            post_conditions = Conditions(post_condition_elements)
+                                    post_condition_elements.append(
+                                        Condition(expression, result))
+                            post_conditions = Conditions(
+                                post_condition_elements)
                         elif event_child.tag == "PreActions":
                             # State->Event->PreActions Element
                             pre_action_elements = []
                             for preactions_child in event_child:
-                                #print(preactions_child.text)
+                                # print(preactions_child.text)
                                 # State->Event->PreActions->Action Element
                                 if preactions_child.tag == "Action":
-                                    expression = ""                                   
+                                    expression = ""
                                     for action_child in preactions_child:
                                         if action_child.tag == "Expression":
                                             expression = action_child.text
-                                    pre_action_elements.append(Action(expression))
+                                    pre_action_elements.append(
+                                        Action(expression))
                             pre_actions = Actions(pre_action_elements)
 
                         elif event_child.tag == "PostActions":
                             # State->Event->PostActions Element
                             post_action_elements = []
                             for postactions_child in event_child:
-                                #print(postactions_child.text)
+                                # print(postactions_child.text)
                                 # State->Event->PostActions->Action Element
                                 if postactions_child.tag == "Action":
-                                    expression = ""                                   
+                                    expression = ""
                                     for action_child in postactions_child:
                                         if action_child.tag == "Expression":
                                             expression = action_child.text
-                                    post_action_elements.append(Action(expression))
+                                    post_action_elements.append(
+                                        Action(expression))
                             post_actions = Actions(post_action_elements)
-                            
-                    events[event_name] = Event(event_name,to_state,pre_conditions,post_conditions,pre_actions,post_actions)
-                    #print(event.to_string())
+
+                    events[event_name] = Event(
+                        event_name, to_state, pre_conditions, post_conditions, pre_actions, post_actions)
+                    # print(event.to_string())
                 elif state_child.tag == "Name":
                     #print("Name element = ", state_child.text)
                     # State->Name Element
                     state_name = state_child.text
-                    
+
             states[state_name] = State(state_name, events)
-        
-        elif states_child.tag == "Initial_State" :
+
+        elif states_child.tag == "Initial_State":
             #print ("Initial_State element = ", states_child.text)
             # Initial_State Element
-            initial_state = states_child.text    
-    
-    return states, initial_state
+            initial_state = states_child.text
+
+    return states, initial_state

src/State.py

@@ -1,14 +1,14 @@
 class State:
-    def __init__(self, name: str, events = None):
+    def __init__(self, name: str, events=None):
         if events is None:
             events = {}
         self.name = name
         self.events = events
-      
+
     def to_string(self):
         result_s = "State:\n"
         result_s += "  Name: " + self.name + "\n"
         result_s += "  Events: \n"
         for event in self.events.items():
             result_s += "    " + event[1].to_string() + "\n"
-        return result_s
+        return result_s