armodel 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

armodel/models/fibex/fibex_core.py

@@ -0,0 +1,341 @@
+from abc import ABCMeta
+from typing import List
+
+from armodel.models.ar_ref import RefType
+
+from ..ar_object import ARFloat, ARLiteral, ARNumerical, ARObject, ARPositiveInteger
+from ..general_structure import Identifiable
+
+
+class FibexElement(Identifiable):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == FibexElement:
+            raise NotImplementedError("FibexElement is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+class PhysicalChannel (Identifiable):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == PhysicalChannel:
+            raise NotImplementedError("PhysicalChannel is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+
+class CommunicationCluster(FibexElement):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == CommunicationCluster:
+            raise NotImplementedError("CommunicationCluster is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        self.baudrate = None                # type: ARFloat
+        self.physical_channels = []         # type: List[PhysicalChannel]
+        self.protocol_name = None           # type: ARLiteral
+        self.protocol_version = None        # type: ARLiteral
+
+    def addPhysicalChannel(self, channel: PhysicalChannel):
+        self.physical_channels.append(channel)
+
+    def getPhysicalChannels(self) -> List[PhysicalChannel]:
+        return self.physical_channels
+    
+    @property
+    def protocolName(self) -> ARLiteral:
+        return self.protocol_name
+    
+    @protocolName.setter
+    def protocolName(self, value: ARLiteral):
+        self.protocol_name = value
+
+    @property
+    def protocolVersion(self) -> ARLiteral:
+        return self.protocol_version
+
+    @protocolVersion.setter
+    def protocolVersion(self, value: ARLiteral):
+        self.protocol_version = value
+
+class Pdu(FibexElement):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == Pdu:
+            raise NotImplementedError("Pdu is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        self.length = None     # type: ARNumerical
+
+class PduToFrameMapping(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.packing_byte_order = None      # type: ARLiteral
+        self.pdu_ref = None                 # type: RefType
+        self.start_position = None          # type: ARNumerical
+
+    @property
+    def packingByteOrder(self) -> ARLiteral:
+        return self.packing_byte_order
+
+    @packingByteOrder.setter
+    def packingByteOrder(self, value: ARLiteral):
+        self.packing_byte_order = value
+
+    @property
+    def pduRef(self) -> RefType:
+        return self.pdu_ref
+
+    @pduRef.setter
+    def pduRef(self, value: RefType):
+        self.pdu_ref = value
+
+    @property
+    def startPosition(self) -> ARNumerical:
+        return self.start_position
+
+    @startPosition.setter
+    def startPosition(self, value: ARNumerical):
+        self.start_position = value
+
+class Frame(Identifiable):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == Frame:
+            raise NotImplementedError("Frame is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        self.frame_length = None
+        self.pdu_to_frame_mappings = []        # type: List[PduToFrameMapping]
+
+    @property
+    def frameLength(self) -> ARNumerical:
+        return self.frame_length
+
+    @frameLength.setter
+    def frameLength(self, value: ARNumerical):
+        self.frame_length = value
+
+    def createPduToFrameMapping(self, short_name: str) -> PduToFrameMapping:
+        if (short_name not in self.elements):
+            mapping = PduToFrameMapping(self, short_name)
+            self.elements[short_name] = mapping
+            self.pdu_to_frame_mappings.append(mapping)
+        return self.elements[short_name]
+
+    def getPduToFrameMappings(self) -> List[PduToFrameMapping]:
+        return list(sorted(filter(lambda a: isinstance(a, PduToFrameMapping), self.elements.values()), key= lambda o:o.short_name))
+    
+class ContainedIPduProps(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._collection_semantics = None                # type: ARLiteral
+        self._header_id_long_header = None               # type: ARPositiveInteger
+        self._header_id_short_header = None              # type: ARPositiveInteger
+        self._offset = None                              # type: ARNumerical
+        self._timeout = None                             # type: ARNumerical
+        self._trigger = None                             # type: ARLiteral
+        self._update_indication_bit_position = None      # type: ARNumerical
+ 
+    @property
+    def headerIdLongHeader(self) -> ARPositiveInteger:
+        return self._header_id_long_header
+
+    @headerIdLongHeader.setter
+    def headerIdLongHeader(self, value: ARPositiveInteger):
+        self._header_id_long_header = value
+
+    @property
+    def headerIdShortHeader(self) -> ARPositiveInteger:
+        return self._header_id_short_header
+
+    @headerIdShortHeader.setter
+    def headerIdShortHeader(self, value: ARPositiveInteger):
+        self._header_id_short_header = value
+
+    @property
+    def offset(self) -> ARNumerical:
+        return self._offset
+
+    @offset.setter
+    def offset(self, value: ARNumerical):
+        self._offset = value
+
+    @property
+    def timeout(self):
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, value):
+        self._timeout = value
+        
+    @property
+    def collectionSemantics(self) -> ARLiteral:
+        return self._collection_semantics
+
+    @collectionSemantics.setter
+    def collectionSemantics(self, value: ARLiteral):
+        self._collection_semantics = value
+    
+    @property
+    def trigger(self) -> ARLiteral:
+        return self._trigger
+
+    @trigger.setter
+    def trigger(self, value: ARLiteral):
+        self._trigger = value
+       
+    @property
+    def updateIndicationBitPosition(self) -> ARNumerical:
+        return self._update_indication_bit_position
+
+    @updateIndicationBitPosition.setter
+    def updateIndicationBitPosition(self, value: ARNumerical):
+        self._update_indication_bit_position = value
+
+class IPdu(Pdu):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == IPdu:
+            raise NotImplementedError("IPdu is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        self._contained_ipdu_props = None       # type: ContainedIPduProps
+
+    @property
+    def containedIPduProps(self) -> ContainedIPduProps:
+        return self._contained_ipdu_props
+
+    @containedIPduProps.setter
+    def containedIPduProps(self, value: ContainedIPduProps):
+        self._contained_ipdu_props = value
+
+
+class NmPdu(Pdu):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+    
+
+class NPdu(IPdu):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+class DcmIPdu(IPdu):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+class FrameTriggering(Identifiable):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == FrameTriggering:
+            raise NotImplementedError("FrameTriggering is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+class ISignal(FibexElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._data_transformation_ref = None
+        self._data_type_policy = None
+        self._i_signal_props = None
+        self._i_signal_type = None
+        self._init_value = None
+        self._length = None
+        self._network_representation_props = None
+        self._system_signal_ref = None                  # type: RefType
+        self._timeout_substitution_value = None
+        self._transformation_i_signal_props = []
+
+    @property
+    def dataTransformationRef(self):
+        return self._data_transformation_ref
+
+    @dataTransformationRef.setter
+    def dataTransformationRef(self, value):
+        self._data_transformation_ref = value
+
+    @property
+    def dataTypePolicy(self):
+        return self._data_type_policy
+
+    @dataTypePolicy.setter
+    def dataTypePolicy(self, value):
+        self._data_type_policy = value
+
+    @property
+    def iSignalProps(self):
+        return self._i_signal_props
+
+    @iSignalProps.setter
+    def iSignalProps(self, value):
+        self._i_signal_props = value
+
+    @property
+    def iSignalType(self):
+        return self._i_signal_type
+
+    @iSignalType.setter
+    def iSignalType(self, value):
+        self._i_signal_type = value
+
+    @property
+    def initValue(self):
+        return self._init_value
+
+    @initValue.setter
+    def initValue(self, value):
+        self._init_value = value
+
+    @property
+    def length(self):
+        return self._length
+
+    @length.setter
+    def length(self, value):
+        self._length = value
+
+    @property
+    def networkRepresentationProps(self):
+        return self._network_representation_props
+
+    @networkRepresentationProps.setter
+    def networkRepresentationProps(self, value):
+        self._network_representation_props = value
+
+    @property
+    def systemSignalRef(self):
+        return self._system_signal_ref
+
+    @systemSignalRef.setter
+    def systemSignalRef(self, value):
+        self._system_signal_ref = value
+
+    @property
+    def timeoutSubstitutionValue(self):
+        return self._timeout_substitution_value
+
+    @timeoutSubstitutionValue.setter
+    def timeoutSubstitutionValue(self, value):
+        self._timeout_substitution_value = value
+
+    @property
+    def transformationISignalProps(self):
+        return self._transformation_i_signal_props
+
+    @transformationISignalProps.setter
+    def transformationISignalProps(self, value):
+        self._transformation_i_signal_props = value

armodel/models/fibex/lin_communication.py

@@ -0,0 +1,17 @@
+
+from abc import ABCMeta
+from ..ar_object import ARObject
+from .fibex_core import Frame
+
+class LinFrame(Frame):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == LinFrame:
+            raise NotImplementedError("LinFrame is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+class LinUnconditionalFrame(LinFrame):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)

armodel/models/fibex/lin_topology.py

@@ -0,0 +1,7 @@
+
+from ..ar_object import ARObject
+from .fibex_core import CommunicationCluster
+
+class LinCluster(CommunicationCluster):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)

armodel/models/general_structure.py

@@ -1,9 +1,10 @@
 from abc import ABCMeta
 from typing import List
 
+from .ar_ref import RefType
+from .multilanguage_data import MultiLanguageOverviewParagraph, MultilanguageLongName
 from .ar_object import ARObject
 
-
 class Sd(ARObject):
     def __init__(self):
         super().__init__()
@@ -47,20 +48,38 @@ class Referrable(ARObject, metaclass=ABCMeta):
             raise NotImplementedError("Referrable is an abstract class.")
         ARObject.__init__(self)
 
-        self.parent = parent
+        self._parent = parent
         self.short_name = short_name
 
+    @property
+    def parent(self):
+        return self._parent
+
+    @parent.setter
+    def parent(self, value):
+        self._parent = value
+
+    @property
+    def shortName(self):
+        return self.short_name
+
+    @shortName.setter
+    def shortName(self, value):
+        self.short_name = value
+
     @property
     def full_name(self) -> str:
-        return self.parent.full_name + "/" + self.short_name
+        return self._parent.full_name + "/" + self.short_name
 
 class MultilanguageReferrable(Referrable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == MultilanguageReferrable:
             raise NotImplementedError("MultilanguageReferrable is an abstract class.")
+        
         super().__init__(parent, short_name)
-        self.parent = parent
-        self.long_name = None
+
+        self._parent = parent
+        self.long_name = None            # type: MultilanguageLongName
 
 class CollectableElement(ARObject, metaclass=ABCMeta):
     def __init__(self):
@@ -71,6 +90,11 @@ class CollectableElement(ARObject, metaclass=ABCMeta):
     def getTotalElement(self) -> int:
         #return len(list(filter(lambda a: not isinstance(a, ARPackage) , self.elements.values())))
         return len(self.elements.values())
+    
+    def removeElement(self, key):
+        if key not in self.elements:
+            raise KeyError("Invalid key <%s> for removing element" % key)
+        self.elements.pop(key)
 
     def getElements(self):
         return self.elements.values()
@@ -89,7 +113,7 @@ class Identifiable(MultilanguageReferrable, CollectableElement, metaclass=ABCMet
 
         self.admin_data = None      # type: AdminData
         self._category = None
-        self.desc = None
+        self.desc = None            # type: MultiLanguageOverviewParagraph
 
     @property
     def category(self):
@@ -122,24 +146,24 @@ class SwcBswRunnableMapping(ARObject):
         '''
         super().__init__()
 
-        self.bsw_entity_ref   = None        # type: RefType
-        self.swc_runnable_ref = None        # type: RefType
+        self.bswEntityRef   = None        # type: RefType
+        self.swcRunnableRef = None        # type: RefType
 
 class SwcBswMapping(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.bsw_behavior_ref = None            # type: RefType
-        self.runnable_mappings = []
-        self.swc_behavior_ref = None            # type: RefType
-        self.synchronized_mode_groups = []       
-        self.synchronized_triggers = []
+        self.bswBehaviorRef = None              # type: RefType
+        self._runnableMappings = []
+        self.swcBehaviorRef = None              # type: RefType
+        self.synchronizedModeGroups = []       
+        self.synchronizedTriggers = []
 
     def addRunnableMapping(self, mapping: SwcBswRunnableMapping):
-        self.runnable_mappings.append(mapping)
+        self._runnableMappings.append(mapping)
 
     def getRunnableMappings(self) -> List[SwcBswRunnableMapping]:
-        return self.runnable_mappings
+        return self._runnableMappings
 
 class ARElement(PackageableElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -154,7 +178,9 @@ class AtpStructureElement(AtpFeature, metaclass=ABCMeta):
             raise NotImplementedError("AtpStructureElement is an abstract class.")
         super().__init__(parent, short_name)
 
-class Limit:
+class Limit(ARObject):
     def __init__(self):
-        self.interval_type = None
-        self.value = None
+        super().__init__()
+
+        self.intervalType = None       # type: str
+        self.value = None               # type: str

armodel/models/global_constraints.py

@@ -1,5 +1,5 @@
 from .ar_ref import RefType
-from .ar_object import ARObject
+from .ar_object import ARNumerical, ARObject
 from .general_structure import Identifiable, Limit
 
 from typing import List
@@ -23,9 +23,9 @@ class DataConstrRule(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.constr_level = None        # type: int
-        self.internal_constrs = None    # type: InternalConstrs    
-        self.phys_constrs = None        # type: PhysConstrs
+        self.constrLevel = None         # type: ARNumerical
+        self.internalConstrs = None     # type: InternalConstrs    
+        self.physConstrs = None         # type: PhysConstrs
 
 class DataConstr(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):

armodel/models/implementation.py

@@ -1,6 +1,6 @@
 from abc import ABCMeta
 from typing import List
-from .ar_object import ARObject
+from .ar_object import ARLiteral, ARNumerical, ARObject
 from .general_structure import PackageableElement, Identifiable
 from .common_structure import ResourceConsumption
 from .ar_ref import RefType
@@ -12,10 +12,42 @@ class EngineeringObject(ARObject, metaclass=ABCMeta):
 
         super().__init__()
 
-        self.category = ""
-        self.domain = None                  # type: str
-        self.revision_label = None          # type: str
-        self.short_label = ""               # type: str
+        self.category = None                # type: ARLiteral
+        self.domain = None                  # type: ARLiteral
+        self.revision_label = None           # type: ARLiteral
+        self.short_label = None              # type: ARLiteral
+
+    def setCategory(self, category: any):
+        if isinstance(category, ARLiteral):
+            self.category = category
+        else:
+            self.category = ARLiteral()
+            self.category.setValue(str(category))
+        return self
+    
+    def getCategory(self) -> ARLiteral:
+        return self.category
+    
+    def setDomain(self, domain: ARLiteral):
+        self.domain = domain
+        return self
+    
+    def getDomain(self) -> ARLiteral:
+        return self.domain
+    
+    def setRevisionLabel(self, revision_label: ARLiteral):
+        self.revision_label = revision_label
+        return self
+    
+    def getRevisionLabel(self) -> ARLiteral:
+        return self.revision_label
+    
+    def setShortLabel(self, label: ARLiteral):
+        self.short_label = label
+        return self
+    
+    def getShortLabel(self) -> ARLiteral:
+        return self.short_label
 
 class AutosarEngineeringObject(EngineeringObject):
     def __init__(self):
@@ -25,17 +57,17 @@ class Code(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.artifact_descriptors = []          # type: List[AutosarEngineeringObject]
-        self.callback_header_refs = []          # type: List[RefType]
+        self._artifactDescriptors = []          # type: List[AutosarEngineeringObject]
+        self.callbackHeaderRefs = []            # type: List[RefType]
 
     def addArtifactDescriptor(self, desc: AutosarEngineeringObject):
-        self.artifact_descriptors.append(desc)
+        self._artifactDescriptors.append(desc)
 
     def getArtifactDescriptors(self, category:str = "") -> List[AutosarEngineeringObject]:
         if (category == ""):
-            return self.artifact_descriptors
+            return self._artifactDescriptors
         else:
-            return list(filter(lambda a: a.category == category, self.artifact_descriptors))
+            return list(filter(lambda a: a.getCategory().getText() == category, self._artifactDescriptors))
 
 class Implementation(PackageableElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str) -> None:
@@ -43,20 +75,21 @@ class Implementation(PackageableElement, metaclass=ABCMeta):
             raise NotImplementedError("Implementation is an abstract class.")
 
         super().__init__(parent, short_name)
-        self.build_action_manifest = None       # 0..1   
-        self.compiler = None                    # *
-        self.generated_artifact = None          # *
-        self.hw_element = None                  # *
-        self.linker = None                      # *
-        self.mc_support = None                   # 0..1
-        self.programming_language = ""          # 1
-        self.required_artifact = None           # *
-        self.required_generator_tool = None     # *
-        self.resource_consumption = None        # type: ResourceConsumption
-        self.sw_version = ""                    # 1
-        self.swc_bsw_mapping_ref = None         # type: RefType
-        self.used_code_generator = ""           # 0..1
-        self.vendor_id = 0                      # 1
+
+        self.build_action_manifest_ref = None               # type: RefType
+        self.compilers = None                           
+        self.generated_artifacts = None          
+        self.hw_element_refs = []                           # type: List[RefType]
+        self.linker = []                      
+        self.mc_support = None                           
+        self.programming_language = None                    # type: ARLiteral
+        self.required_artifacts = []           
+        self.required_generator_tools = []
+        self.resource_consumption = None                    # type: ResourceConsumption
+        self.sw_version = ""                                # type: ARLiteral
+        self.swc_bsw_mapping_ref = None                     # type: RefType
+        self.used_code_generator = None                     # type: ARLiteral
+        self.vendor_id = 0                                  # type: ARNumerical
 
     def createCodeDescriptor(self, short_name: str) -> Code:
         if (short_name not in self.elements):
@@ -67,22 +100,36 @@ class Implementation(PackageableElement, metaclass=ABCMeta):
     def getCodeDescriptors(self)-> List[Code]:
         return list(filter(lambda a : isinstance(a, Code), self.elements.values()))
 
+    def setResourceConsumption(self, consumption: ResourceConsumption):
+        self.elements[consumption.short_name] = consumption
+        self.resource_consumption = consumption
+        return self
+    
+    def getResourceConsumption(self) -> ResourceConsumption:
+        return self.resource_consumption
+
 class BswImplementation(Implementation):
     def __init__(self, parent: ARObject, short_name: str) -> None:
         super().__init__(parent, short_name)
 
-        self.ar_release_version = ""
-        self.revision_label_string = ""                 # 1
-        self.behavior_ref = None                        # type: RefType
-        self.preconfigured_configuration_ref = None     # *
-        self.recommended_configuration_ref = None       # *
-        self.vendor_api_infix = ""                      # 0..1
-        self.vendor_specific_module_def_ref = None      # *
+        self.ar_release_version = None                      # type: ARLiteral
+        self.behavior_ref = None                            # type: RefType
+        self.preconfiguredConfigurationRef = []             # type: List[RefType]
+        self.recommendedConfigurationRef = []               # type: List[RefType]
+        self.vendorApiInfix = None                          # type: str
+        self._vendorSpecificModuleDefRef = []               # type: List[RefType]
+
+    def addVendorSpecificModuleDefRef(self, ref: RefType):
+        self._vendorSpecificModuleDefRef.append(ref)
 
+    def getVendorSpecificModuleDefRefs(self):
+        return self._vendorSpecificModuleDefRef
+    
 class SwcImplementation(Implementation):
     def __init__(self, parent: ARObject, short_name: str) -> None:
         super().__init__(parent, short_name)
 
         self.behavior_ref = None                        # type: RefType
         self.per_instance_memory_size = None
-        self.required_rte_vendor = ""
+        self.required_rte_vendor = ""
+