armodel 1.7.8__py3-none-any.whl → 1.8.0__py3-none-any.whl

armodel/cli/arxml_format_cli.py

@@ -69,6 +69,7 @@ def main():
     ap = argparse.ArgumentParser()
     ap.description = "arxml-format ver: %s" % version
     ap.add_argument("-v", "--verbose", required=False, help="Print debug information", action="store_true")
+    ap.add_argument("--log", required=False, help="Log all information to file")
     ap.add_argument("-w", "--warning", required=False, help="Skip the error and report it as warning message", action="store_true")
     ap.add_argument("--remove-admin-data", required=False, help="Remove all the AdminData", action="store_true")
     ap.add_argument("INPUT", help="The path of AUTOSAR ARXML file")

armodel/models/M2/AUTOSARTemplates/AutosarTopLevelStructure.py

@@ -1,19 +1,24 @@
 from typing import Dict, List
 
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 
+from ...utils.uuid_mgr import UUIDMgr
 from ...M2.MSR.AsamHdo.SpecialData import Sdg
 from ...M2.MSR.AsamHdo import AdminData
 from ...M2.MSR.AsamHdo.BaseTypes import SwBaseType
 from ...M2.MSR.Documentation.TextModel.BlockElements import DocumentationBlock
+
 from ...M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBehavior
 from ...M2.AUTOSARTemplates.CommonStructure.Implementation import Implementation
 from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import CollectableElement, Referrable
 from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage
 from ...M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationDataType, DataTypeMap
-from ...M2.AUTOSARTemplates.SWComponentTemplate.Components import CompositionSwComponentType
+from ...M2.AUTOSARTemplates.SWComponentTemplate.Components import AtomicSwComponentType, CompositionSwComponentType, PortPrototype
+from ...M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import VariableDataPrototype
 from ...M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
 from ...M2.AUTOSARTemplates.SystemTemplate import RootSwCompositionPrototype, System
+from ...M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import SystemSignal, SystemSignalGroup
 
 
 class FileInfoComment(ARObject):
@@ -34,6 +39,21 @@ class AbstractAUTOSAR(CollectableElement):
     def __init__(self):
         super().__init__()
 
+        self.release_xsd_mappings = {
+            "4.0.3": "AUTOSAR_4-0-3.xsd",
+            "4.1.0": "AUTOSAR_4-1-0.xsd",
+            "4.2.1": "AUTOSAR_4-2-1.xsd",
+            "4.3.0": "AUTOSAR_00043.xsd",
+            "4.3.1": "AUTOSAR_00045.xsd",
+            "4.4.0": "AUTOSAR_00047.xsd",
+            "R19-11": "AUTOSAR_00048.xsd",
+            "R20-11": "AUTOSAR_00049.xsd",
+            "R21-11": "AUTOSAR_00050.xsd",
+            "R22-11": "AUTOSAR_00051.xsd",
+            "R23-11": "AUTOSAR_00052.xsd",
+            "R24-11": "AUTOSAR_00053.xsd",
+        }
+
         self.clear()
 
     def getAdminData(self):
@@ -78,7 +98,7 @@ class AbstractAUTOSAR(CollectableElement):
         self._behavior_impl_maps = {}                       # type: Dict[str, str]
         self._impl_behavior_maps = {}                       # type: Dict[str, str]
 
-        self.uuid_objects = {}                              # type: Dict[str, ARObject]
+        self.uuid_mgr = UUIDMgr()
 
         self.systems = {}                                   # type: Dict[str, System]
         self.compositionSwComponentTypes = {}               # type: Dict[str, CompositionSwComponentType]
@@ -105,7 +125,14 @@ class AbstractAUTOSAR(CollectableElement):
             self.arPackages[short_name] = ar_package
         return self.arPackages[short_name]
 
-    def find(self, referred_name: str) -> Referrable:
+    def find(self, referred) -> Referrable:
+        if isinstance(referred, RefType):
+            referred_name = referred.getValue()
+            referred_type = referred.getDest()
+        else:
+            referred_name = referred
+            referred_type = None
+
         short_name_list = referred_name.split("/")
         element = AUTOSAR.getInstance()
         for short_name in short_name_list:
@@ -114,17 +141,46 @@ class AbstractAUTOSAR(CollectableElement):
             element = element.getElement(short_name)
             if (element is None):
                 return element
-            #    raise ValueError("The %s of reference <%s> does not exist." % (short_name, referred_name))
+        
+        # validate the dest
+        if referred_type is not None and referred_type != "":
+            base_type = self.getDestType(element)
+            if base_type != referred_type:
+                raise ValueError("The type does not matched of <%s> (Dest: %s, Actual: %s)" % (referred_name, referred_type, base_type))
+        
         return element
     
+    def getDestType(self, type) -> str:
+        if isinstance(type, ImplementationDataType):
+            return "IMPLEMENTATION-DATA-TYPE"
+        return ""
+    
+    def findAtomicSwComponentType(self, referred) -> AtomicSwComponentType:
+        return self.find(referred)
+    
+    def findSystemSignal(self, referred) -> SystemSignal:
+        return self.find(referred)
+    
+    def findSystemSignalGroup(self, referred) -> SystemSignalGroup:
+        return self.find(referred)
+    
+    def findPort(self, referred: str) -> PortPrototype:
+        return self.find(referred)
+    
+    def findVariableDataPrototype(self, referred) -> VariableDataPrototype:
+        return self.find(referred)
+    
+    def findImplementationDataType(self, referred) -> ImplementationDataType:
+        return self.find(referred)
+    
     def getDataType(self, data_type: ImplementationDataType) -> ImplementationDataType:
         if (isinstance(data_type, ImplementationDataType) or isinstance(data_type, SwBaseType)):
             if (data_type.category == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
                 referred_type = self.find(data_type.swDataDefProps.implementationDataTypeRef.value)
                 return self.getDataType(referred_type)
             if (data_type.category == ImplementationDataType.CATEGORY_DATA_REFERENCE):
-                if (data_type.swDataDefProps.swPointerTargetProps.target_category == "VALUE"):
-                    referred_type = self.find(data_type.swDataDefProps.swPointerTargetProps.sw_data_def_props.baseTypeRef.value)
+                if (data_type.swDataDefProps.swPointerTargetProps.getTargetCategory() == "VALUE"):
+                    referred_type = self.find(data_type.swDataDefProps.swPointerTargetProps.getSwDataDefProps().getBaseTypeRef())
                     return self.getDataType(referred_type)
             return data_type
         else:
@@ -191,14 +247,18 @@ class AbstractAUTOSAR(CollectableElement):
                 self.compositionSwComponentTypes[short_name] = sw_component_type
         return self
     
-    def getARObjectByUUID(self, uuid: str):
-        if uuid in self.uuid_objects:
-            return self.uuid_objects[uuid]
-        return None
+    def getARObjectByUUID(self, uuid: str) -> List[ARObject]:
+        return self.uuid_mgr.getObjects()
 
     def addARObject(self, value: ARObject):
         if value is not None:
-            self.uuid_objects[value.uuid] = value
+            self.uuid_mgr.addObject(value)
+        return self
+    
+    def setARRelease(self, release: str):
+        if release not in self.release_xsd_mappings:
+            raise "invalid AUTOSAR Release <%s>" % release
+        self.schema_location = self.release_xsd_mappings[release]
         return self
 
 

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswBehavior.py

@@ -1,6 +1,7 @@
 from abc import ABCMeta
 from typing import List
 
+from ....M2.MSR.DataDictionary.DataDefProperties import SwImplPolicyEnum
 from ....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
 from ....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBehavior
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
@@ -28,6 +29,76 @@ class BswModuleCallPoint(Referrable):
         return self
 
 
+class BswAsynchronousServerCallPoint(BswModuleCallPoint):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.calledEntryRef = None                                          # type: RefType
+
+    def getCalledEntryRef(self):
+        return self.calledEntryRef
+
+    def setCalledEntryRef(self, value):
+        if value is not None:
+            self.calledEntryRef = value
+        return self
+
+
+class BswDirectCallPoint(BswModuleCallPoint):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.calledEntryRef = None                                          # type: RefType
+        self.calledFromWithinExclusiveAreaRef = None                        # type: RefType
+
+    def getCalledEntryRef(self):
+        return self.calledEntryRef
+
+    def setCalledEntryRef(self, value):
+        if value is not None:
+            self.calledEntryRef = value
+        return self
+
+    def getCalledFromWithinExclusiveAreaRef(self):
+        return self.calledFromWithinExclusiveAreaRef
+
+    def setCalledFromWithinExclusiveAreaRef(self, value):
+        if value is not None:
+            self.calledFromWithinExclusiveAreaRef = value
+        return self
+    
+
+class BswSynchronousServerCallPoint(BswModuleCallPoint):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.calledEntryRef = None                                          # type: RefType
+        self.calledFromWithinExclusiveAreaRef = None                        # type: RefType
+
+    def getCalledEntryRef(self):
+        return self.calledEntryRef
+
+    def setCalledEntryRef(self, value):
+        if value is not None:
+            self.calledEntryRef = value
+        return self
+
+    def getCalledFromWithinExclusiveAreaRef(self):
+        return self.calledFromWithinExclusiveAreaRef
+
+    def setCalledFromWithinExclusiveAreaRef(self, value):
+        if value is not None:
+            self.calledFromWithinExclusiveAreaRef = value
+        return self
+
+
+class BswAsynchronousServerCallResultPoint(BswModuleCallPoint):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.asynchronousServerCallPointRef = None                          # type: RefType
+
+
 class BswVariableAccess(Referrable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -69,26 +140,28 @@ class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
     def getAccessedModeGroupRefs(self):
         return self.accessedModeGroupRefs
 
-    def setAccessedModeGroupRefs(self, value):
+    def addAccessedModeGroupRef(self, value):
         if value is not None:
-            self.accessedModeGroupRefs = value
+            self.accessedModeGroupRefs.append(value)
         return self
 
     def getActivationPointRefs(self):
         return self.activationPointRefs
 
-    def setActivationPointRefs(self, value):
+    def addActivationPointRef(self, value):
         if value is not None:
-            self.activationPointRefs = value
+            self.activationPointRefs.append(value)
         return self
 
     def getCallPoints(self):
         return self.callPoints
 
-    def setCallPoints(self, value):
-        if value is not None:
-            self.callPoints = value
-        return self
+    def createBswAsynchronousServerCallPoint(self, short_name):
+        if (not self.IsElementExists(short_name)):
+            access = BswAsynchronousServerCallPoint(self, short_name)
+            self.addElement(access)
+            self.callPoints.append(access)
+        return self.getElement(short_name)
 
     def getDataReceivePoints(self):
         return self.dataReceivePoints
@@ -406,6 +479,21 @@ class BswQueuedDataReceptionPolicy(BswDataReceptionPolicy):
         return self
 
 
+class BswInternalTriggeringPoint(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.swImplPolicy = None                                                # type: SwImplPolicyEnum
+
+    def getSwImplPolicy(self):
+        return self.swImplPolicy
+
+    def setSwImplPolicy(self, value):
+        if value is not None:
+            self.swImplPolicy = value
+        return self
+
+
 class BswInternalBehavior(InternalBehavior):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -476,10 +564,12 @@ class BswInternalBehavior(InternalBehavior):
     def getInternalTriggeringPoints(self):
         return self.internalTriggeringPoints
 
-    def setInternalTriggeringPoints(self, value):
-        if value is not None:
-            self.internalTriggeringPoints = value
-        return self
+    def createBswInternalTriggeringPoint(self, short_name: str) -> BswInternalTriggeringPoint:
+        if not self.IsElementExists(short_name):
+            entity = BswInternalTriggeringPoint(self, short_name)
+            self.addElement(entity)
+            self.internalTriggeringPoints.append(entity)
+        return self.getElement(short_name)
 
     def getInternalTriggeringPointPolicies(self):
         return self.internalTriggeringPointPolicies

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswInterfaces.py

@@ -1,9 +1,45 @@
 from typing import List
 
 from ....M2.MSR.DataDictionary.ServiceProcessTask import SwServiceArg
+from ....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import ServiceNeeds
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, Boolean, Identifier, NameToken
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable, Referrable
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, Boolean, Identifier, NameToken, RefType
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger
+
+
+class BswModuleDependency(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.serviceItems = []                      # type: List[ServiceNeeds]
+        self.targetModuleId = None                  # type: PositiveInteger
+        self.targetModuleRef = None                 # type: RefType
+
+    def getServiceItems(self):
+        return self.serviceItems
+
+    def setServiceItems(self, value):
+        if value is not None:
+            self.serviceItems = value
+        return self
+
+    def getTargetModuleId(self):
+        return self.targetModuleId
+
+    def setTargetModuleId(self, value):
+        if value is not None:
+            self.targetModuleId = value
+        return self
+
+    def getTargetModuleRef(self):
+        return self.targetModuleRef
+
+    def setTargetModuleRef(self, value):
+        if value is not None:
+            self.targetModuleRef = value
+        return self
+
 
 class BswModuleEntry(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
@@ -109,18 +145,53 @@ class BswModuleEntry(ARElement):
         result = []
 
         result.append("short_name             : %s" % self.short_name)
-        if self.serviceId != None:
+        if self.serviceId is not None:
             result.append("service_id             : %d" % self.serviceId)
-        if self.isReentrant != None:
+        if self.isReentrant is not None:
             result.append("is_reentrant           : %s" % self.isReentrant)
-        if self.isSynchronous != None:
+        if self.isSynchronous is not None:
             result.append("is_synchronous         : %s" % self.isSynchronous)
-        if self.callType != None:
+        if self.callType is not None:
             result.append("call_type              : %s" % self.callType)
-        if self.execution_context != None:
+        if self.executionContext is not None:
             result.append("execution_context      : %s" % self.executionContext)
-        if self.sw_service_impl_policy != None:
+        if self.swServiceImplPolicy is not None:
             result.append("sw_service_impl_policy : %s" % self.swServiceImplPolicy)
 
         return "\n".join(result)
-    
+
+
+class BswModuleClientServerEntry(Referrable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.encapsulatedEntryRef = None                        # type: RefType
+        self.isReentrant = None                                 # type: Boolean
+        self.isSynchronous = None                               # type: Boolean
+
+    def getEncapsulatedEntryRef(self):
+        return self.encapsulatedEntryRef
+
+    def setEncapsulatedEntryRef(self, value):
+        if value is not None:
+            self.encapsulatedEntryRef = value
+        return self
+
+    def getIsReentrant(self):
+        return self.isReentrant
+
+    def setIsReentrant(self, value):
+        if value is not None:
+            self.isReentrant = value
+        return self
+
+    def getIsSynchronous(self):
+        return self.isSynchronous
+
+    def setIsSynchronous(self, value):
+        if value is not None:
+            self.isSynchronous = value
+        return self
+
+
+    

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswOverview.py

@@ -1,12 +1,15 @@
-from ....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import VariableDataPrototype
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.SoftwareComponentDocumentation import SwComponentDocumentation
+from ....M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleClientServerEntry, BswModuleDependency
 from ....M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalBehavior
 from ....M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclarationGroupPrototype
 from ....M2.AUTOSARTemplates.CommonStructure.TriggerDeclaration import Trigger
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger, RefType
+from ....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import VariableDataPrototype
 from typing import List
 
+
 class BswModuleDescription(ARElement):
     '''
         Root element for the description of a single BSW module or BSW cluster. In case it
@@ -28,7 +31,7 @@ class BswModuleDescription(ARElement):
         self.moduleId = None                                    # type: PositiveInteger
         self.providedClientServerEntries = []                   # type: List[BswModuleClientServerEntry]
         self.providedDatas = []                                 # type: List[VariableDataPrototype]
-        self.providedModeGroups   = []                          # type: List[ModeDeclarationGroupPrototype]
+        self.providedModeGroups = []                            # type: List[ModeDeclarationGroupPrototype]
         self.releasedTriggers = []                              # type: List[Trigger]
         self.requiredClientServerEntries = []                   # type: List[BswModuleClientServerEntry]
         self.requiredDatas = []                                 # type: List[VariableDataPrototype]
@@ -96,10 +99,12 @@ class BswModuleDescription(ARElement):
     def getProvidedClientServerEntries(self):
         return self.providedClientServerEntries
 
-    def setProvidedClientServerEntries(self, value):
-        if value is not None:
-            self.providedClientServerEntries = value
-        return self
+    def createProvidedClientServerEntry(self, short_name: str) -> BswModuleClientServerEntry:
+        if (not self.IsElementExists(short_name)):
+            entry = BswModuleClientServerEntry(self, short_name)
+            self.addElement(entry)
+            self.providedClientServerEntries.append(entry)
+        return self.getElement(short_name)
 
     def getProvidedDatas(self):
         return self.providedDatas
@@ -134,10 +139,12 @@ class BswModuleDescription(ARElement):
     def getRequiredClientServerEntries(self):
         return self.requiredClientServerEntries
 
-    def setRequiredClientServerEntries(self, value):
-        if value is not None:
-            self.requiredClientServerEntries = value
-        return self
+    def createRequiredClientServerEntry(self, short_name: str) -> BswModuleClientServerEntry:
+        if (not self.IsElementExists(short_name)):
+            entry = BswModuleClientServerEntry(self, short_name)
+            self.addElement(entry)
+            self.requiredClientServerEntries.append(entry)
+        return self.getElement(short_name)
 
     def getRequiredDatas(self):
         return self.requiredDatas

armodel/models/M2/AUTOSARTemplates/CommonStructure/Implementation.py

@@ -7,9 +7,9 @@ from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTy
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 
 
-class ImplementationProps(Referrable, metaclass = ABCMeta):
+class ImplementationProps(Referrable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == ImplementationProps:
+        if type(self) is ImplementationProps:
             raise NotImplementedError("ImplementationProps is an abstract class.")
         
         super().__init__(parent, short_name)
@@ -35,12 +35,13 @@ class Code(Identifiable):
         self.artifactDescriptors.append(desc)
         return self
 
-    def getArtifactDescriptors(self, category:str = "") -> List[AutosarEngineeringObject]:
+    def getArtifactDescriptors(self, category: str = "") -> List[AutosarEngineeringObject]:
         if (category == ""):
             return self.artifactDescriptors
         else:
             return list(filter(lambda a: a.getCategory().getText() == category, self.artifactDescriptors))
 
+
 class Compiler(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -77,7 +78,8 @@ class Compiler(Identifiable):
     def setVersion(self, value):
         self.version = value
         return self
-    
+
+
 class DependencyOnArtifact(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -101,9 +103,9 @@ class DependencyOnArtifact(Identifiable):
         return self
 
 
-class Implementation(PackageableElement, metaclass = ABCMeta):
+class Implementation(PackageableElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == Implementation:
+        if type(self) is Implementation:
             raise NotImplementedError("Implementation is an abstract class.")
 
         super().__init__(parent, short_name)
@@ -131,8 +133,8 @@ class Implementation(PackageableElement, metaclass = ABCMeta):
         self.buildActionManifestRef = value
         return self
 
-    def getCodeDescriptors(self)-> List[Code]:
-        return list(filter(lambda a : isinstance(a, Code), self.elements.values()))
+    def getCodeDescriptors(self) -> List[Code]:
+        return list(filter(lambda a: isinstance(a, Code), self.elements.values()))
 
     def createCodeDescriptor(self, short_name: str) -> Code:
         if (short_name not in self.elements):