armodel 1.6.2__py3-none-any.whl → 1.6.4__py3-none-any.whl

armodel/models/fibex/fibex_core.py

@@ -1,341 +0,0 @@
-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_topology.py

@@ -1,7 +0,0 @@
-
-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/implementation.py

@@ -1,135 +0,0 @@
-from abc import ABCMeta
-from typing import List
-from .ar_object import ARLiteral, ARNumerical, ARObject
-from .general_structure import PackageableElement, Identifiable
-from .common_structure import ResourceConsumption
-from .ar_ref import RefType
-
-class EngineeringObject(ARObject, metaclass=ABCMeta):
-    def __init__(self):
-        if type(self) == EngineeringObject:
-            raise NotImplementedError("EngineeringObject is an abstract class.")
-
-        super().__init__()
-
-        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):
-        super().__init__()
-
-class Code(Identifiable):
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
-
-        self._artifactDescriptors = []          # type: List[AutosarEngineeringObject]
-        self.callbackHeaderRefs = []            # type: List[RefType]
-
-    def addArtifactDescriptor(self, desc: AutosarEngineeringObject):
-        self._artifactDescriptors.append(desc)
-
-    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 Implementation(PackageableElement, metaclass=ABCMeta):
-    def __init__(self, parent: ARObject, short_name: str) -> None:
-        if type(self) == Implementation:
-            raise NotImplementedError("Implementation is an abstract class.")
-
-        super().__init__(parent, short_name)
-
-        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):
-            sw_component = Code(self, short_name)
-            self.elements[short_name] = sw_component
-        return self.elements[short_name]
-
-    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 = 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 = ""
-        

armodel/models/internal_behavior.py

@@ -1,63 +0,0 @@
-from abc import ABCMeta
-from typing import List
-
-from .ar_object import ARLiteral, ARObject
-from .ar_ref import RefType
-from .common_structure import ExclusiveArea
-from .m2.autosar_templates.sw_component_template.data_type.data_prototypes import ParameterDataPrototype
-from .general_structure import Identifiable
-
-class IncludedDataTypeSet(ARObject):
-    def __init__(self):
-        super().__init__()
-
-        self.data_type_refs = []            # type: List[RefType]
-        self.literal_prefix = None          # type: ARLiteral
-
-    def addDataTypeRef(self, ref_type: RefType):
-        self.data_type_refs.append(ref_type)
-
-    def getDataTypeRefs(self) -> List[RefType]:
-        return self.data_type_refs
-    
-    @property
-    def literalPrefix(self) -> ARLiteral:
-        return self.literal_prefix
-    
-    @literalPrefix.setter
-    def literalPrefix(self, value: ARLiteral):
-        self.literal_prefix = value
-
-class InternalBehavior(Identifiable, metaclass=ABCMeta):
-    def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == InternalBehavior:
-            raise NotImplementedError("InternalBehavior is an abstract class.")
-        super().__init__(parent, short_name)
-
-        self.data_type_mapping_refs = []        # type: List[RefType]                       
-        self.constant_memories = []             # type: List[ParameterDataPrototype]
-
-    def addDataTypeMappingRef(self, ref: RefType):
-        self.data_type_mapping_refs.append(ref)
-
-    def getDataTypeMappingRefs(self) -> List[RefType]:
-        return self.data_type_mapping_refs
-    
-    def createExclusiveArea(self, short_name: str) -> ExclusiveArea:
-        if (short_name not in self.elements):
-            event = ExclusiveArea(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
-
-    def getExclusiveAreas(self) -> List[ExclusiveArea]:
-        return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements.values()))
-    
-    def createConstantMemory(self, short_name: str) -> ParameterDataPrototype:
-        if (short_name not in self.elements):
-            prototype = ParameterDataPrototype(self, short_name)
-            self.elements[short_name] = prototype
-            self.constant_memories.append(prototype)
-        return self.elements[short_name]
-
-    def getConstantMemorys(self) -> List[ParameterDataPrototype]:
-        return self.constant_memories

armodel/models/m2/autosar_templates/common_structure/implementation.py

@@ -1,21 +0,0 @@
-from abc import ABCMeta
-
-from ....ar_object import ARLiteral, ARObject
-from ....general_structure import Referrable
-
-
-class ImplementationProps(Referrable, metaclass = ABCMeta):
-    def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == ImplementationProps:
-            raise NotImplementedError("ImplementationProps is an abstract class.")
-        
-        super().__init__(parent, short_name)
-
-        self.symbol = None                          # type: ARLiteral
-
-    def getSymbol(self):
-        return self.symbol
-
-    def setSymbol(self, value):
-        self.symbol = value
-        return self