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

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/PortInterface/__init__.py

@@ -5,7 +5,8 @@ from .....M2.AUTOSARTemplates.CommonStructure import TextValueSpecification
 from .....M2.AUTOSARTemplates.CommonStructure.TriggerDeclaration import Trigger
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, ArgumentDirectionEnum, PositiveInteger
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, ArgumentDirectionEnum, Boolean
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger
 from .....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype, VariableDataPrototype, AutosarDataPrototype
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean
 from .....M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclarationGroupPrototype
@@ -13,9 +14,10 @@ from .....M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpType
 from .....M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpFeature
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 
-class PortInterface(AtpType, metaclass = ABCMeta):
+
+class PortInterface(AtpType, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == PortInterface:
+        if type(self) is PortInterface:
             raise NotImplementedError("PortInterface is an abstract class.")
         super().__init__(parent, short_name)
 
@@ -36,12 +38,14 @@ class PortInterface(AtpType, metaclass = ABCMeta):
         self.serviceKind = value
         return self
 
-class DataInterface(PortInterface, metaclass = ABCMeta):
+
+class DataInterface(PortInterface, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == DataInterface:
+        if type(self) is DataInterface:
             raise NotImplementedError("DataInterface is an abstract class.")
         super().__init__(parent, short_name)
 
+
 class NvDataInterface(DataInterface):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -55,6 +59,7 @@ class NvDataInterface(DataInterface):
         self.nvDatas.append(value)
         return self
 
+
 class ParameterInterface(DataInterface):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -62,15 +67,15 @@ class ParameterInterface(DataInterface):
         self.parameters = []                        # type: List[ParameterDataPrototype]
 
     def getParameters(self):
-        return list(sorted(filter(lambda a : isinstance(a, ParameterDataPrototype), self.elements.values()), key = lambda a: a.short_name))
+        return self.parameters
+
+    def createParameterDataPrototype(self, short_name: str) -> ParameterDataPrototype:
+        prototype = ParameterDataPrototype(self, short_name)
+        self.addElement(prototype)
+        self.parameters.append(prototype)
+        return prototype
+
 
-    def createParameter(self, short_name: str) -> ParameterDataPrototype:
-        if (short_name not in self.elements):
-            parameter = ParameterDataPrototype(self, short_name)
-            self.elements[short_name] = parameter
-            self.parameters.append(parameter)
-        return self.elements[short_name]
-    
 class InvalidationPolicy(ARObject):
     def __init__(self):
         super().__init__()
@@ -91,7 +96,8 @@ class InvalidationPolicy(ARObject):
     def setHandleInvalid(self, value):
         self.handleInvalid = value
         return self
-    
+
+
 class MetaDataItem(ARObject):
     def __init__(self):
         super().__init__()
@@ -112,7 +118,8 @@ class MetaDataItem(ARObject):
     def setMetaDataItemType(self, value):
         self.metaDataItemType = value
         return self
-    
+
+
 class MetaDataItemSet(ARObject):
     def __init__(self):
         super().__init__()
@@ -134,6 +141,7 @@ class MetaDataItemSet(ARObject):
         self.metaDataItems.append(value)
         return self
 
+
 class SenderReceiverInterface(DataInterface):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -167,7 +175,7 @@ class SenderReceiverInterface(DataInterface):
     def getDataElement(self, short_name) -> VariableDataPrototype:
         if (short_name in self.elements):
             data_element = self.elements[short_name]
-            #if (not isinstance(data_element, VariableDataPrototype)):
+            # if (not isinstance(data_element, VariableDataPrototype)):
             #    raise IndexError("%s is not data element." % short_name)
             return data_element
         raise IndexError("data element <%s> can not be found." % short_name)
@@ -180,34 +188,38 @@ class SenderReceiverInterface(DataInterface):
     def getInvalidationPolicys(self) -> List[InvalidationPolicy]:
         return list(filter(lambda c: isinstance(c, InvalidationPolicy), self.invalidationPolicies))
 
+
 class ArgumentDataPrototype(AutosarDataPrototype):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
         self.direction = None                               # type: ArgumentDirectionEnum
-        # type: ServerArgumentImplPolicyEnum
-        self.serverArgumentImplPolicy = None
+        self.serverArgumentImplPolicy = None                # type: ServerArgumentImplPolicyEnum
 
     def getDirection(self):
         return self.direction
 
     def setDirection(self, value):
-        self.direction = value
+        if value is not None:
+            self.direction = value
         return self
 
     def getServerArgumentImplPolicy(self):
         return self.serverArgumentImplPolicy
 
     def setServerArgumentImplPolicy(self, value):
-        self.serverArgumentImplPolicy = value
+        if value is not None:
+            self.serverArgumentImplPolicy = value
         return self
 
+
 class ApplicationError(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
         self.error_code = None                  # type: ARNumerical
 
+
 class ClientServerOperation(AtpFeature):
     """
         An operation declared within the scope of a client/server interface.
@@ -233,27 +245,34 @@ class ClientServerOperation(AtpFeature):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._arguments = []
-        self._possible_error_refs = []  # type: List[RefType]
+        self.arguments = []                                                     # type: List[ArgumentDataPrototype]
+        self.possibleErrorRefs = []                                             # type: List[RefType]
 
-    def addArgumentDataPrototype(self, prototype: ArgumentDataPrototype):
-        self._arguments.append(prototype)
+    def getArguments(self):
+        return self.arguments
 
-    def getArgumentDataPrototypes(self) -> List[ArgumentDataPrototype]:
-        return self._arguments
+    def createArgumentDataPrototype(self, short_name):
+        if not self.IsElementExists(short_name):
+            prototype = ArgumentDataPrototype(self, short_name)
+            self.addElement(prototype)
+            self.arguments.append(prototype)
+        return self.getElement(short_name)
 
-    def addPossibleErrorRef(self, possible_error_ref: RefType):
-        self._possible_error_refs.append(possible_error_ref)
+    def getPossibleErrorRefs(self):
+        return self.possibleErrorRefs
 
-    def getPossbileErrorRefs(self) -> List[RefType]:
-        return self._possible_error_refs
+    def addPossibleErrorRef(self, value):
+        if value is not None:
+            self.possibleErrorRefs.append(value)
+        return self
 
 
 class ClientServerInterface(PortInterface):
     """
         A client/server interface declares a number of operations that can be invoked on a server by a client.
         Package: M2::AUTOSARTemplates::SWComponentTemplate::PortInterface
-        Base: ARElement, ARObject, AtpBlueprint, AtpBlueprintable, AtpClassifier , AtpType, CollectableElement, Identifiable, MultilanguageReferrable, PackageableElement, PortInterface, Referrable
+        Base: ARElement, ARObject, AtpBlueprint, AtpBlueprintable, AtpClassifier , AtpType, CollectableElement, Identifiable, MultilanguageReferrable,
+              PackageableElement, PortInterface, Referrable
 
         Methods:
         --------
@@ -283,13 +302,15 @@ class ClientServerInterface(PortInterface):
 
     def getPossibleErrors(self) -> List[ApplicationError]:
         return list(filter(lambda c: isinstance(c, ApplicationError), self.elements.values()))
-    
+
+
 class TriggerInterface(PortInterface):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
         self._triggers = []             # type: Trigger
 
+
 class ModeSwitchInterface(PortInterface):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -303,14 +324,16 @@ class ModeSwitchInterface(PortInterface):
         return self.elements[short_name]
     
     def getModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
-        return list(sorted(filter(lambda c: isinstance(c, ModeDeclarationGroupPrototype), self.elements.values()), key= lambda o: o.short_name))
+        return list(sorted(filter(lambda c: isinstance(c, ModeDeclarationGroupPrototype), self.elements.values()), key=lambda o: o.short_name))
+
 
-class PortInterfaceMapping(Identifiable, metaclass = ABCMeta):
+class PortInterfaceMapping(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == PortInterface:
+        if type(self) is PortInterfaceMapping:
             raise NotImplementedError("PortInterfaceMapping is an abstract class.")
         super().__init__(parent, short_name)
 
+
 class ClientServerApplicationErrorMapping(ARObject):
     def __init__(self):
         super().__init__()
@@ -331,11 +354,11 @@ class ClientServerApplicationErrorMapping(ARObject):
     def setSecondApplicationErrorRef(self, value):
         self.secondApplicationErrorRef = value
         return self
-    
+
+
 class ClientServerOperationMapping(ARObject):
     def __init__(self):
         super().__init__()
-
         
         self.argumentMappings = []                              # type: List[DataPrototypeMapping]
         self.firstOperationRef = None                           # type: RefType
@@ -425,7 +448,6 @@ class DataPrototypeMapping(ARObject):
         return self
 
 
-
 class ClientServerInterfaceMapping(PortInterfaceMapping):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -479,3 +501,54 @@ class PortInterfaceMappingSet(ARElement):
             self.addElement(mapping)
             self.portInterfaceMappings.append(mapping)
         return self.getElement(short_name)
+
+
+class TextTableMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.bitfieldTextTableMaskFirst = None                  # type: PositiveInteger
+        self.bitfieldTextTableMaskSecond = None                 # type: PositiveInteger
+        self.identicalMapping = None                            # type: Boolean
+        self.mappingDirection = None                            # type: MappingDirectionEnum
+        self.valuePairs = []                                    # type: List[TextTableValuePair]
+
+    def getBitfieldTextTableMaskFirst(self):
+        return self.bitfieldTextTableMaskFirst
+
+    def setBitfieldTextTableMaskFirst(self, value):
+        if value is not None:
+            self.bitfieldTextTableMaskFirst = value
+        return self
+
+    def getBitfieldTextTableMaskSecond(self):
+        return self.bitfieldTextTableMaskSecond
+
+    def setBitfieldTextTableMaskSecond(self, value):
+        if value is not None:
+            self.bitfieldTextTableMaskSecond = value
+        return self
+
+    def getIdenticalMapping(self):
+        return self.identicalMapping
+
+    def setIdenticalMapping(self, value):
+        if value is not None:
+            self.identicalMapping = value
+        return self
+
+    def getMappingDirection(self):
+        return self.mappingDirection
+
+    def setMappingDirection(self, value):
+        if value is not None:
+            self.mappingDirection = value
+        return self
+
+    def getValuePairs(self):
+        return self.valuePairs
+
+    def setValuePairs(self, value):
+        if value is not None:
+            self.valuePairs = value
+        return self

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/AccessCount.py

@@ -10,4 +10,12 @@ class AbstractAccessPoint(Identifiable, metaclass = ABCMeta):
         
         super().__init__(parent, short_name)
 
-        self.return_value_provision = None  
+        self.returnValueProvision = None                                    # type: RteApiReturnValueProvisionEnum
+
+    def getReturnValueProvision(self):
+        return self.returnValueProvision
+
+    def setReturnValueProvision(self, value):
+        if value is not None:
+            self.returnValueProvision = value
+        return self

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/ModeDeclarationGroup.py

@@ -1,5 +1,6 @@
-from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType
 from typing import List
+
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, Identifier, RefType
 from .....M2.AUTOSARTemplates.SWComponentTemplate.RPTScenario import ModeAccessPointIdent
 from .....M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AccessCount import AbstractAccessPoint
@@ -30,7 +31,7 @@ class ModeSwitchPoint(AbstractAccessPoint):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.modeGroupIRef = None           # type: PModeGroupInAtomicSwcInstanceRef
+        self.modeGroupIRef = None                                   # type: PModeGroupInAtomicSwcInstanceRef
 
     def getModeGroupIRef(self):
         return self.modeGroupIRef
@@ -44,8 +45,8 @@ class IncludedModeDeclarationGroupSet(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.mode_declaration_group_refs = []           # type: List[RefType]
-        self.prefix = None                              # type: ARLiteral
+        self.mode_declaration_group_refs = []                       # type: List[RefType]
+        self.prefix = None                                          # type: Identifier
 
     def addModeDeclarationGroupRef(self, ref: RefType):
         self.mode_declaration_group_refs.append(ref)

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/__init__.py

@@ -11,7 +11,7 @@ from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMap
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, Boolean, RefType, ARBoolean
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElements import ParameterAccess, VariableAccess
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
-from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import ModeAccessPoint, ModeSwitchPoint
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet, ModeAccessPoint, ModeSwitchPoint
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.Trigger import InternalTriggeringPoint
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
@@ -290,6 +290,14 @@ class SwcInternalBehavior(InternalBehavior):
 
     def getIncludedDataTypeSets(self) -> List[IncludedDataTypeSet]:
         return self.includedDataTypeSets
+    
+    def getIncludedModeDeclarationGroupSets(self):
+        return self.includedModeDeclarationGroupSets
+
+    def addIncludedModeDeclarationGroupSet(self, value):
+        if value is not None:
+            self.includedModeDeclarationGroupSets.append(value)
+        return self
 
     def createOperationInvokedEvent(self, short_name: str) -> OperationInvokedEvent:
         if (short_name not in self.elements):

armodel/models/M2/AUTOSARTemplates/SystemTemplate/DataMapping.py

@@ -1,12 +1,15 @@
 from abc import ABCMeta
+from typing import List
 
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+from ....M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import TextTableMapping
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Integer, RefType
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import CommunicationDirectionType
 
-class DataMapping(ARObject, metaclass = ABCMeta):
+
+class DataMapping(ARObject, metaclass=ABCMeta):
     def __init__(self):
-        if type(self) == ARObject:
+        if type(self) is DataMapping:
             raise NotImplementedError("DataMapping is an abstract class.")
         
         super().__init__()
@@ -20,6 +23,7 @@ class DataMapping(ARObject, metaclass = ABCMeta):
         self.introduction = value
         return self
 
+
 class SenderReceiverToSignalMapping(DataMapping):
     def __init__(self):
         super().__init__()
@@ -65,13 +69,172 @@ class SenderReceiverToSignalMapping(DataMapping):
         self.systemSignalRef = value
         return self
 
+
+class SenderRecCompositeTypeMapping(ARObject, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) is SenderRecCompositeTypeMapping:
+            raise NotImplementedError("SenderRecCompositeTypeMapping is an abstract class.")
+        
+        super().__init__()
+
+
+class SenderRecRecordElementMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.applicationRecordElementRef = None                     # type: RefType
+        self.complexTypeMapping = None                              # type: SenderRecCompositeTypeMapping
+        self.implementationRecordElementRef = None                  # type: RefType
+        self.senderToSignalTextTableMapping = None                  # type: TextTableMapping
+        self.signalToReceiverTextTableMapping = None                # type: TextTableMapping
+        self.systemSignalRef = None                                 # type: RefType
+
+    def getApplicationRecordElementRef(self):
+        return self.applicationRecordElementRef
+
+    def setApplicationRecordElementRef(self, value):
+        if value is not None:
+            self.applicationRecordElementRef = value
+        return self
+
+    def getComplexTypeMapping(self):
+        return self.complexTypeMapping
+
+    def setComplexTypeMapping(self, value):
+        if value is not None:
+            self.complexTypeMapping = value
+        return self
+
+    def getImplementationRecordElementRef(self):
+        return self.implementationRecordElementRef
+
+    def setImplementationRecordElementRef(self, value):
+        if value is not None:
+            self.implementationRecordElementRef = value
+        return self
+
+    def getSenderToSignalTextTableMapping(self):
+        return self.senderToSignalTextTableMapping
+
+    def setSenderToSignalTextTableMapping(self, value):
+        if value is not None:
+            self.senderToSignalTextTableMapping = value
+        return self
+
+    def getSignalToReceiverTextTableMapping(self):
+        return self.signalToReceiverTextTableMapping
+
+    def setSignalToReceiverTextTableMapping(self, value):
+        if value is not None:
+            self.signalToReceiverTextTableMapping = value
+        return self
+
+    def getSystemSignalRef(self):
+        return self.systemSignalRef
+
+    def setSystemSignalRef(self, value):
+        if value is not None:
+            self.systemSignalRef = value
+        return self
+
+
+class SenderRecRecordTypeMapping(SenderRecCompositeTypeMapping):
+    def __init__(self):
+        super().__init__()
+
+        self.recordElementMappings = []                     # type: List[SenderRecRecordElementMapping]
+
+    def getRecordElementMappings(self):
+        return self.recordElementMappings
+
+    def addRecordElementMapping(self, value):
+        if value is not None:
+            self.recordElementMappings.append(value)
+        return self
+
+
+class IndexedArrayElement(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.applicationArrayElementRef = None              # type: RefType
+        self.implementationArrayElementRef = None           # type: RefType
+        self.index = None                                   # type: Integer
+        
+
+class SenderRecArrayElementMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.complexTypeMapping = None                      # type: SenderRecCompositeTypeMapping
+        self.indexedArrayElement = None                     # type: IndexedArrayElement
+        self.systemSignalRef = None                         # type: RefType
+
+    def getComplexTypeMapping(self):
+        return self.complexTypeMapping
+
+    def setComplexTypeMapping(self, value):
+        if value is not None:
+            self.complexTypeMapping = value
+        return self
+
+    def getIndexedArrayElement(self):
+        return self.indexedArrayElement
+
+    def setIndexedArrayElement(self, value):
+        if value is not None:
+            self.indexedArrayElement = value
+        return self
+
+    def getSystemSignalRef(self):
+        return self.systemSignalRef
+
+    def setSystemSignalRef(self, value):
+        if value is not None:
+            self.systemSignalRef = value
+        return self
+
+
+class SenderRecArrayTypeMapping(SenderRecCompositeTypeMapping):
+    def __init__(self):
+        super().__init__()
+
+        self.arrayElementMappings = []                      # type: List[SenderRecArrayElementMapping]
+        self.senderToSignal = None                          # type: TextTableMapping
+        self.signalToReceiverTextTableMapping = None        # type: TextTableMapping
+
+    def getArrayElementMappings(self):
+        return self.arrayElementMappings
+
+    def setArrayElementMappings(self, value):
+        if value is not None:
+            self.arrayElementMappings = value
+        return self
+
+    def getSenderToSignal(self):
+        return self.senderToSignal
+
+    def setSenderToSignal(self, value):
+        if value is not None:
+            self.senderToSignal = value
+        return self
+
+    def getSignalToReceiverTextTableMapping(self):
+        return self.signalToReceiverTextTableMapping
+
+    def setSignalToReceiverTextTableMapping(self, value):
+        if value is not None:
+            self.signalToReceiverTextTableMapping = value
+        return self
+
+
 class SenderReceiverToSignalGroupMapping(DataMapping):
     def __init__(self):
         super().__init__()
 
         self.dataElementIRef = None                         # type: RefType
         self.signalGroupRef = None                          # type: RefType
-        self.typeMapping = None
+        self.typeMapping = None                             # type: SenderRecCompositeTypeMapping
 
     def getDataElementIRef(self):
         return self.dataElementIRef
@@ -93,4 +256,3 @@ class SenderReceiverToSignalGroupMapping(DataMapping):
     def setTypeMapping(self, value):
         self.typeMapping = value
         return self
-

armodel/models/M2/AUTOSARTemplates/SystemTemplate/{ECUResourceMapping.py → EcuResourceMapping.py}

@@ -1,6 +1,7 @@
 from typing import List
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+
 
 class ECUMapping(Identifiable):
     def __init__(self, parent, short_name):
@@ -9,7 +10,7 @@ class ECUMapping(Identifiable):
         self.commControllerMappings = []                                # type: List[CommunicationControllerMapping]
         self.ecuRef = None                                              # type: RefType
         self.ecuInstanceRef = None                                      # type: RefType
-        self.hwPortMappings =[]                                         # type: List[HwPortMapping]
+        self.hwPortMappings = []                                        # type: List[HwPortMapping]
 
     def getCommControllerMappings(self):
         return self.commControllerMappings