Merge branch 'toFpp' into main

Author: watney

autocoder/CameoParser.py

@@ -6,21 +6,26 @@
 # -----------------------------------------------------------------------
 # mypy: ignore-errors
 
-from lxml import etree
-from anytree import Node, RenderTree
-import anytree
-import sys
+from anytree import Node
 from copy import deepcopy
 import xmiModelApi
-import xmiToQm
+from typing import Tuple, Dict
+
+
+from lxml.etree import _ElementTree
+ElementTreeType = _ElementTree 
+from xmiModelApi import XmiModel
+
+
 
 # -------------------------------------------------------------------------
 # createEventSignalMap
 #
 # Create a mapping of event id's to signal names and return the map
 #
 # --------------------------------------------------------------------------
-def createEventSignalMap(xmlFileNodeModel, xmlFileNodeStateMachine):
+def createEventSignalMap(xmlFileNodeModel: ElementTreeType, 
+                         xmlFileNodeStateMachine: ElementTreeType):
     global XMI_ID
 
     eventToSignalMap = {}
@@ -51,7 +56,9 @@ def createEventSignalMap(xmlFileNodeModel, xmlFileNodeStateMachine):
 #
 # Recursively parse the xmi file root and populate the xmiModel
 # --------------------------------------------------------------------------
-def parseStateTree(xmlFileNode, xmiModelNode):
+def parseStateTree(xmlFileNode: ElementTreeType, 
+                   xmiModelNode: Node):
+    
     global XMI_TYPE
     global XMI_ID
     global eventToNameMap
@@ -130,83 +137,80 @@ def parseStateTree(xmlFileNode, xmiModelNode):
 #
 # Recursively parse the input xml File nodes root and populate the xmiModel
 # --------------------------------------------------------------------------
-def populateXmiModel(xmlFileNode, xmiModel):
+def populateXmiModel(xmlRoot: ElementTreeType, xmiModel: XmiModel):
+
     global XMI_TYPE
     global XMI_ID
     global eventToNameMap
 
-    stateMachine = getXmlStateMachine(xmlFileNode)
+    smRoot: ElementTreeType = getXmlStateMachine(xmlRoot)
 
-    eventToNameMap = createEventSignalMap(xmlFileNode, stateMachine)
+    eventToNameMap = createEventSignalMap(xmlRoot, smRoot)
 
-    parseStateTree(stateMachine, xmiModel.getRoot())
+    parseStateTree(smRoot, xmiModel.getRoot())
 
 
 #-----------------------------------------------------------------------
 # getXmlFileNode
 #
 # Return the namespace and model element from the input xml file
 # -----------------------------------------------------------------------
-def getXmlFileNode(xmlfile):
-    tree = etree.parse(xmlfile)
-    root = tree.getroot()
+def getXmlFileNode(cameoRoot: ElementTreeType) -> Tuple[Dict[str, str], ElementTreeType]:
+
+    root = cameoRoot.getroot()
     nsmap = root.nsmap
     doc = root.find('xmi:Documentation', nsmap)
     version = doc.find('xmi:exporterVersion', nsmap)
     print("MagicDraw version = {0}".format(version.text))
 
     # Get the Model
-    model = root.find('uml:Model', nsmap)
+    xmlRoot = root.find('uml:Model', nsmap)
 
     XMI_TYPE = "{"+nsmap['xmi']+"}type"
 
-    return(nsmap, model)
+    return(nsmap, xmlRoot)
 
 # -----------------------------------------------------------------------------
 # getXmlStateMachine
 #
 # Given the xml File element, find and return the uml:StateMachine xml element
 # ------------------------------------------------------------------------------
-def getXmlStateMachine(xmlFileNode):
+def getXmlStateMachine(xmlRoot: ElementTreeType) -> ElementTreeType:
+
     # Get the StateMachine node from the xml File.
-    pe = xmlFileNode.findall("packagedElement")
+    pe = xmlRoot.findall("packagedElement")
     for e in pe:
         if e.get(XMI_TYPE) == "uml:StateMachine":
             return e 
 
 # -----------------------------------------------------------------------
-# processCameo
+# getXmiModel
 #
-# Process the input CAMEO xmi xml file and return a qm file
+# Process the input CAMEO xmi and return an xmiModel
 # -----------------------------------------------------------------------
-def processCameo(xmlfile, debug):
+def getXmiModel(cameoRoot: ElementTreeType) -> XmiModel:
+    
     global XMI_ID, XMI_TYPE, xmiModel
-    print("Hello, welcome to the CAMEO xml parser")
-        
-    (nsmap, xmlFileNode) = getXmlFileNode(xmlfile)
+
+    (nsmap, xmlRoot) = getXmlFileNode(cameoRoot)
 
     XMI_ID = "{"+nsmap['xmi']+"}id"
     XMI_TYPE = "{"+nsmap['xmi']+"}type"
 
     #
     # Instantiate the xmi model
     #
-    packageName = xmlFileNode.get('name')
-    stateMachine = getXmlStateMachine(xmlFileNode)
-    xmiModel = xmiModelApi.xmiModel(packageName, stateMachine.get('name'))
+    packageName = xmlRoot.get('name')
+    smRoot = getXmlStateMachine(xmlRoot)
+    xmiModel = xmiModelApi.XmiModel(packageName, smRoot.get('name'))
 
     # 
     # Populate the xmi model
     # 
-    populateXmiModel(xmlFileNode, xmiModel)
+    populateXmiModel(xmlRoot, xmiModel)
 
-    if debug:
-        xmiModel.print()
+    return xmiModel
 
-    #
-    # Convert the xmi model to the qm model
-    #
-    return xmiToQm.translateXmiModelToQmFile(xmiModel, debug)
 
 
 

autocoder/QmParser.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+# -----------------------------------------------------------------------
+# QmParser.py
+#
+# 
+# -----------------------------------------------------------------------
+# mypy: ignore-errors
+
+from copy import deepcopy
+import xmiModelApi
+import flattenstatemachine as flatt
+import qmlib
+from anytree import Node
+from xmiModelApi import XmiModel
+
+from lxml.etree import _ElementTree
+ElementTreeType = _ElementTree 
+
+
+class UniqueNumberGenerator:
+    def __init__(self):
+        self.generator = self.unique_number_generator()  # Create a generator instance
+
+    def unique_number_generator(self):
+        counter = 0
+        while True:
+            yield counter
+            counter += 1
+
+    def get_unique_number(self):
+        return next(self.generator)  # Return the next unique number
+
+# -------------------------------------------------------------------------
+# parseTrans
+#
+# Recursively parse a qm transition and populate the xmiModel
+# --------------------------------------------------------------------------
+def parseTrans(qmTrans: ElementTreeType, 
+               xmiModel: XmiModel, 
+               xmiNode: Node, 
+               number_gen: UniqueNumberGenerator):
+    
+    source = xmiNode.id
+    target = int(qmTrans.get('target')) if qmTrans.get('target') else None
+    kind = qmTrans.get('kind')  
+    guard = qmlib.pick_guard(qmTrans)
+    action = flatt.pick_action(qmTrans)
+    event = qmTrans.get('trig')
+
+    if target is None:
+        choices = qmTrans.findall("choice")
+        if len(choices) == 2:
+            psId = number_gen.get_unique_number()
+            psNode = xmiModel.addPsuedostate(psId)
+            xmiModel.addTransition(source, psId, event, guard, action, kind)
+            for choice in choices:
+                parseTrans(choice, xmiModel, psNode, number_gen)
+        else:
+            xmiModel.addTransition(source, target, event, guard, action, kind)
+    else:
+        xmiModel.addTransition(source, target, event, guard, action, kind, xmiNode.parent)
+
+# -------------------------------------------------------------------------
+# parseStateTree
+#
+# Recursively parse the qm model and populate the xmiModel
+# --------------------------------------------------------------------------
+def parseStateTree(qmRoot: ElementTreeType, 
+                   xmiModel: XmiModel, 
+                   xmiNode: Node, 
+                   number_gen: UniqueNumberGenerator):
+
+    for init in qmRoot.findall("initial"):
+        psNode = xmiModel.addPsuedostate(number_gen.get_unique_number(), xmiNode)
+        parseTrans(init, xmiModel, psNode, number_gen)
+
+    for tran in qmRoot.findall("tran"):
+        parseTrans(tran, xmiModel, xmiNode, number_gen)
+
+    for state in qmRoot.findall("state"):
+        stateName = state.get('name')
+        entry = flatt.pick_entry(state)
+        exit = flatt.pick_exit(state)
+        state_id = int(state.get('id'))
+        thisNode = xmiModel.addState(stateName, xmiNode, entry, exit, state_id)
+        parseStateTree(state, xmiModel, thisNode, number_gen)
+    
+# -------------------------------------------------------------------------
+# populateXmiModel
+#
+# Recursively parse the qm model and populate the xmiModel
+# --------------------------------------------------------------------------
+def populateXmiModel(qmRoot: ElementTreeType, 
+                     smname: str) -> XmiModel:
+
+    qmFix = fixQMThing(qmRoot)
+    number_gen = UniqueNumberGenerator()
+    
+    xmiModel = xmiModelApi.XmiModel(smname + "Package", smname)
+
+    # Add a unique ID to every state
+    states = qmFix.iter("state")
+    for state in states:
+        state.set("id", str(number_gen.get_unique_number()))
+
+    # Replace the relative target attributes with ID's
+    for node in qmFix.iter():
+        target = node.get("target")
+        if target is not None:
+            targetId = flatt.state_from_target(node).get("id")
+            node.set("target", str(targetId))
+
+    # Search for internal transitions.  Internal transitions do not have a 
+    # target and do not have an option child.  Mark the transition as internal
+    for tran in qmFix.iter("tran"):
+        if tran.get('target') is None:
+            # Look for choice nodes
+            choices = list(tran.iter("choice"))
+            if len(choices) == 0:
+                tran.set("kind", "internal")
+
+    parseStateTree(qmFix, xmiModel, xmiModel.tree, number_gen)
+    
+    return xmiModel
+        
+# -----------------------------------------------------------------------
+# fixQMThing
+#
+# The QM modeling tool does not support guards on transitions.
+# These are specified in the xml file as a transition to a single
+# choice.
+#
+# This routine makes a fix where it looks for transitions with a single
+# choice and then adds the children directly under the transition,
+# essentilly moving everything up.
+# -----------------------------------------------------------------------
+def fixQMThing(qmRoot: ElementTreeType) -> ElementTreeType:
+
+    qmFix = deepcopy(qmRoot)
+    for tran in qmFix.iter("tran"):
+        choices = tran.findall("choice")
+        if len(choices) == 1:
+
+            choice_children = list(choices[0])
+
+            for child in choice_children:
+                tran.append(child)
+
+            # Remove the <choice> node after moving its children 
+            # But first check if the choice had a target attribute
+            target = choices[0].get('target')
+            if target is not None:
+                tran.set('target', target)
+            tran.remove(choices[0])
+
+            # Look for all the targets and move them up as well.
+            for child in list(tran.iter()):
+                target = child.get('target')
+                if target is not None:
+                    child.set('target', target[3:])
+
+    return qmFix
+
+
+# -----------------------------------------------------------------------
+# getXmiModel
+#
+# Process the input qmRoot and return an xmiModel
+# -----------------------------------------------------------------------
+def getXmiModel(qmRoot: ElementTreeType) -> XmiModel:
+
+    smRoot, smname = qmlib.get_state_machine(qmRoot)
+
+    xmiModel = populateXmiModel(smRoot, smname)
+
+    return xmiModel
+
+
+
+
+
+            
+        
+