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

armodel/models/fibex/fibex_core/core_topology.py

@@ -0,0 +1,180 @@
+from abc import ABCMeta
+from typing import List
+
+from ...fibex.lin_communication import LinFrameTriggering
+from ...fibex.can_communication import CanFrameTriggering
+from ...ar_ref import RefType
+from ...general_structure import Identifiable
+from ...ar_object import ARFloat, ARLiteral, ARObject
+from ...fibex.fibex_core.core_communication import FibexElement, FrameTriggering, ISignalTriggering, PduTriggering
+
+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)
+
+        self.commConnectorRefs = []                     # type: List[RefType]
+        self.managedPhysicalChannelRefs = []            # type: List[RefType]
+
+    def getCommConnectorRefs(self):
+        return self.commConnectorRefs
+
+    def addCommConnectorRef(self, value):
+        self.commConnectorRefs.append(value)
+        return self
+
+    def getFrameTriggerings(self) -> List[FrameTriggering]:
+        return list(sorted(filter(lambda a: isinstance(a, FrameTriggering), self.elements.values()), key= lambda o:o.short_name))
+
+    def createCanFrameTriggering(self, short_name: str):
+        if (short_name not in self.elements):
+            channel = CanFrameTriggering(self, short_name)
+            self.elements[short_name] = channel
+        return self.elements[short_name]
+    
+    def createLinFrameTriggering(self, short_name: str):
+        if (short_name not in self.elements):
+            channel = LinFrameTriggering(self, short_name)
+            self.elements[short_name] = channel
+        return self.elements[short_name]
+
+    def getISignalTriggerings(self) -> List[ISignalTriggering]:
+        return list(sorted(filter(lambda a: isinstance(a, ISignalTriggering), self.elements.values()), key= lambda o:o.short_name))
+
+    def createISignalTriggering(self, short_name: str):
+        if (short_name not in self.elements):
+            channel = ISignalTriggering(self, short_name)
+            self.elements[short_name] = channel
+        return self.elements[short_name]
+    
+
+    def getManagedPhysicalChannelRefs(self):
+        return self.managedPhysicalChannelRefs
+
+    def addManagedPhysicalChannelRef(self, value):
+        self.managedPhysicalChannelRefs.append(value)
+        return self
+    
+    def getPduTriggerings(self) -> List[PduTriggering]:
+        return list(sorted(filter(lambda a: isinstance(a, PduTriggering), self.elements.values()), key= lambda o:o.short_name))
+
+    def createPduTriggering(self, short_name: str):
+        if (short_name not in self.elements):
+            channel = PduTriggering(self, short_name)
+            self.elements[short_name] = channel
+        return self.elements[short_name]
+
+class AbstractCanPhysicalChannel(PhysicalChannel, metaclass = ABCMeta):
+    def __init__(self, parent, short_name):
+        if type(self) == ARObject:
+            raise NotImplementedError("AbstractCanPhysicalChannel is an abstract class.")
+         
+        super().__init__(parent, short_name)
+
+class CanPhysicalChannel(AbstractCanPhysicalChannel):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name) 
+
+class LinPhysicalChannel(PhysicalChannel):
+    def __init__(self, parent: ARObject, short_name: str):
+        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.protocolName = None            # type: ARLiteral
+        self.protocolVersion = None         # type: ARLiteral
+
+    def getBaudrate(self):
+        return self.baudrate
+
+    def setBaudrate(self, value):
+        self.baudrate = value
+        return self
+
+    def getPhysicalChannels(self) -> List[PhysicalChannel]:
+        return list(sorted(filter(lambda a: isinstance(a, PhysicalChannel), self.elements.values()), key= lambda o:o.short_name))
+    
+    def getCanPhysicalChannels(self) -> List[CanPhysicalChannel]:
+        return list(sorted(filter(lambda a: isinstance(a, CanPhysicalChannel), self.elements.values()), key= lambda o:o.short_name))
+    
+    def getLinPhysicalChannels(self) -> List[LinPhysicalChannel]:
+        return list(sorted(filter(lambda a: isinstance(a, LinPhysicalChannel), self.elements.values()), key= lambda o:o.short_name))
+    
+    def createCanPhysicalChannel(self, short_name: str):
+        if (short_name not in self.elements):
+            channel = CanPhysicalChannel(self, short_name)
+            self.elements[short_name] = channel
+        return self.elements[short_name]
+    
+    def createLinPhysicalChannel(self, short_name: str):
+        if (short_name not in self.elements):
+            channel = LinPhysicalChannel(self, short_name)
+            self.elements[short_name] = channel
+        return self.elements[short_name]
+
+    def getProtocolName(self):
+        return self.protocolName
+
+    def setProtocolName(self, value):
+        self.protocolName = value
+        return self
+
+    def getProtocolVersion(self):
+        return self.protocolVersion
+
+    def setProtocolVersion(self, value):
+        self.protocolVersion = value
+        return self      
+    
+class AbstractCanCluster(CommunicationCluster, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AbstractCanCluster:
+            raise NotImplementedError("AbstractCanCluster is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        self.busOffRecovery = None
+        self.canFdBaudrate = None
+        self.canXlBaudrate = None
+
+    def getBusOffRecovery(self):
+        return self.busOffRecovery
+
+    def setBusOffRecovery(self, value):
+        self.busOffRecovery = value
+        return self
+
+    def getCanFdBaudrate(self):
+        return self.canFdBaudrate
+
+    def setCanFdBaudrate(self, value):
+        self.canFdBaudrate = value
+        return self
+
+    def getCanXlBaudrate(self):
+        return self.canXlBaudrate
+
+    def setCanXlBaudrate(self, value):
+        self.canXlBaudrate = value
+        return self
+
+
+class CanCluster(AbstractCanCluster):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)         
+
+class LinCluster(CommunicationCluster):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)                 
+
+class EcuInstance(FibexElement):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)    

armodel/models/fibex/lin_communication.py

@@ -1,7 +1,7 @@
 
 from abc import ABCMeta
-from ..ar_object import ARObject
-from .fibex_core import Frame
+from ..ar_object import ARLiteral, ARNumerical, ARObject
+from .fibex_core.core_communication import Frame, FrameTriggering
 
 class LinFrame(Frame):
     __metaclass__ = ABCMeta
@@ -14,4 +14,25 @@ class LinFrame(Frame):
 
 class LinUnconditionalFrame(LinFrame):
     def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
+        super().__init__(parent, short_name)
+
+class LinFrameTriggering(FrameTriggering):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.identifier = None                          # type: ARNumerical
+        self.linChecksum = None                         # type: ARLiteral
+
+    def getIdentifier(self):
+        return self.identifier
+
+    def setIdentifier(self, value):
+        self.identifier = value
+        return self
+
+    def getLinChecksum(self):
+        return self.linChecksum
+
+    def setLinChecksum(self, value):
+        self.linChecksum = value
+        return self

armodel/models/general_structure.py

@@ -1,9 +1,10 @@
 from abc import ABCMeta
 from typing import List
 
+from .annotation import Annotation
 from .ar_ref import RefType
 from .multilanguage_data import MultiLanguageOverviewParagraph, MultilanguageLongName
-from .ar_object import ARObject
+from .ar_object import ARObject, ARLiteral
 
 class Sd(ARObject):
     def __init__(self):
@@ -12,21 +13,55 @@ class Sd(ARObject):
         self.gid = ""
         self.value = ""
 
+    def getGID(self):
+        return self.gid
+
+    def setGID(self, value):
+        self.gid = value
+        return self
+
+    def getValue(self):
+        return self.value
+
+    def setValue(self, value):
+        self.value = value
+        return self
 class Sdg(ARObject):
     def __init__(self):
         super().__init__()
 
         self.gid = ""
         self.sd = []                        # type: List[Sd]
-        self.sdg_caption = None
-        self.sdg_contents_type = None
+        self.sdgCaption = None
+        self.sdgContentsTypes = []          # type: List[Sdg]
+
+    def getGID(self):
+        return self.gid
+
+    def setGID(self, value):
+        self.gid = value
+        return self
 
     def addSd(self, sd: Sd):
         self.sd.append(sd)
+        return self
 
     def getSds(self) -> List[Sd]:
         return self.sd
     
+    def getSdgCaption(self):
+        return self.sdgCaption
+
+    def setSdgCaption(self, value):
+        self.sdgCaption = value
+        return self
+    
+    def addSdgContentsType(self, sdg):
+        self.sdgContentsTypes.append(sdg)
+
+    def getSdgContentsTypes(self):
+        return self.sdgContentsTypes
+    
 class AdminData(ARObject):
     def __init__(self):
         super().__init__()
@@ -67,21 +102,33 @@ class Referrable(ARObject, metaclass=ABCMeta):
     def shortName(self, value):
         self.short_name = value
 
+    def getShortName(self) -> str:
+        return self.short_name
+
     @property
     def full_name(self) -> str:
         return self._parent.full_name + "/" + self.short_name
-
-class MultilanguageReferrable(Referrable, metaclass=ABCMeta):
+    
+    def getFullName(self) -> str:
+        return self.full_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            # type: MultilanguageLongName
+        #self._parent = parent
+        self.longName = None            # type: MultilanguageLongName
+
+    def getLongName(self) -> MultilanguageLongName:
+        return self.longName
 
-class CollectableElement(ARObject, metaclass=ABCMeta):
+    def setLongName(self, value: MultilanguageLongName):
+        self.longName = value
+        return self
+class CollectableElement(ARObject, metaclass = ABCMeta):
     def __init__(self):
         if type(self) == CollectableElement:
             raise NotImplementedError("CollectableElement is an abstract class.")
@@ -98,6 +145,9 @@ class CollectableElement(ARObject, metaclass=ABCMeta):
 
     def getElements(self):
         return self.elements.values()
+    
+    def addElement(self, element: Referrable):
+        self.elements[element.getShortName()] = element
 
     def getElement(self, short_name: str) -> Referrable:
         if (short_name not in self.elements):
@@ -111,16 +161,65 @@ class Identifiable(MultilanguageReferrable, CollectableElement, metaclass=ABCMet
         MultilanguageReferrable.__init__(self, parent, short_name)
         CollectableElement.__init__(self)
 
-        self.admin_data = None      # type: AdminData
-        self._category = None
+        self.annotations = []       # type: List[Annotation]
+        self.adminData = None       # type: AdminData
+        self.category = None        # type: ARLiteral
         self.desc = None            # type: MultiLanguageOverviewParagraph
 
+    def getAdminData(self):
+        return self.adminData
+
+    def setAdminData(self, value):
+        self.adminData = value
+        return self
+    
+    def getDesc(self):
+        return self.desc
+
+    def setDesc(self, value):
+        self.desc = value
+        return self
+
+    def getCategory(self):
+        return self.category
+
+    def setCategory(self, value):
+        self.category = value
+        return self
+    
+    def addAnnotation(self, annotation: Annotation):
+        self.annotations.append(annotation)
+        return self
+    
+    def getAnnotations(self) -> List[Annotation]:
+        return self.annotations
+    
+class Describable(ARObject, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == Describable:
+            raise NotImplementedError("Describable is an abstract class.")
+        
+        super().__init__()
+
+        self._desc = None
+        self._category = None
+        self._adminData = None
+        self._introduction = None
+
+    @property
+    def desc(self):
+        return self._desc
+
+    @desc.setter
+    def desc(self, value):
+        self._desc = value
+
     @property
     def category(self):
         return self._category
 
     @category.setter
-    def category(self, value):
+    def category(self, value: ARLiteral):
         self._category = value
 
 class AtpFeature(Identifiable, metaclass=ABCMeta):

armodel/models/internal_behavior.py

@@ -4,7 +4,7 @@ from typing import List
 from .ar_object import ARLiteral, ARObject
 from .ar_ref import RefType
 from .common_structure import ExclusiveArea
-from .data_prototype import ParameterDataPrototype
+from .m2.autosar_templates.sw_component_template.data_type.data_prototypes import ParameterDataPrototype
 from .general_structure import Identifiable
 
 class IncludedDataTypeSet(ARObject):

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

@@ -0,0 +1,188 @@
+from abc import ABCMeta
+from typing import List
+
+from armodel.models.general_structure import ARElement
+from ....ar_object import ARLiteral, ARNumerical, ARObject
+
+class ValueSpecification(ARObject, metaclass = ABCMeta):
+    '''
+    Base class for expressions leading to a value which can be used to initialize a data object.
+    
+    Base        : ARObject
+    Subclasses  : AbstractRuleBasedValueSpecification, ApplicationValueSpecification, CompositeValueSpecification,
+                  ConstantReference, NotAvailableValueSpecification, NumericalValueSpecification, ReferenceValueSpecification, 
+                  TextValueSpecification
+    '''
+    def __init__(self):
+        if type(self) == ValueSpecification:
+            raise NotImplementedError("ValueSpecification is an abstract class.")
+        
+        super().__init__()
+
+        self.shortLabel = None
+
+    def getShortLabel(self):
+        return self.shortLabel
+
+    def setShortLabel(self, value):
+        self.shortLabel = value
+        return self
+    
+class CompositeValueSpecification(ValueSpecification, metaclass = ABCMeta):
+    '''
+    This abstract meta-class acts a base class for ValueSpecifications that have a composite form.
+
+    Base        : ARObject, ValueSpecification
+    Subclasses  : ArrayValueSpecification, RecordValueSpecification
+    '''            
+    def __init__(self):
+        if type(self) == CompositeValueSpecification:
+            raise NotImplementedError("CompositeValueSpecification is an abstract class.")
+        
+        super().__init__()    
+
+class CompositeRuleBasedValueArgument(ARObject, metaclass = ABCMeta):
+    '''
+    This meta-class has the ability to serve as the abstract base class for ValueSpecifications that can be
+    used for compound primitive data types.
+
+    Base        : ARObject
+    Subclasses  : ApplicationRuleBasedValueSpecification, ApplicationValueSpecification
+    '''
+    def __init__(self):
+        if type(self) == CompositeRuleBasedValueArgument:
+            raise NotImplementedError("CompositeRuleBasedValueArgument is an abstract class.")
+        
+        super().__init__()
+
+class ApplicationValueSpecification(CompositeRuleBasedValueArgument, ValueSpecification):
+    '''
+    This meta-class represents values for DataPrototypes typed by ApplicationDataTypes (this includes in
+    particular compound primitives).
+    For further details refer to ASAM CDF 2.0. This meta-class corresponds to some extent with
+    SW-INSTANCE in ASAM CDF 2.0.
+
+    Base ARObject, CompositeRuleBasedValueArgument, ValueSpecification    
+    '''
+    def __init__(self):
+        
+        CompositeRuleBasedValueArgument.__init__(self)
+        ValueSpecification.__init__(self)
+
+        self.category = None
+        self.swAxisCont = []
+        self.swValueCont = None
+
+    def getCategory(self):
+        return self.category
+
+    def setCategory(self, value):
+        self.category = value
+        return self
+
+    def getSwAxisCont(self):
+        return self.swAxisCont
+
+    def setSwAxisCont(self, value):
+        self.swAxisCont = value
+        return self
+
+    def getSwValueCont(self):
+        return self.swValueCont
+
+    def setSwValueCont(self, value):
+        self.swValueCont = value
+        return self
+
+
+class RecordValueSpecification(CompositeValueSpecification):
+    '''
+    Specifies the values for a record.
+    
+    Base : ARObject, CompositeValueSpecification, ValueSpecification
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.fields = []
+
+    def addField(self, field: ValueSpecification):
+        self.fields.append(field)
+
+    def getFields(self) -> List[ValueSpecification]:
+        return self.fields
+    
+class TextValueSpecification(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self.value = None               # type: ARLiteral
+
+    def getValue(self):
+        return self.value
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
+
+class NumericalValueSpecification(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self.value = None               # type: ARNumerical  
+
+    def getValue(self):
+        return self.value
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
+
+class ArrayValueSpecification(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self.element = []                                   # type: List[ValueSpecification]
+        self.intendedPartialInitializationCount = None
+
+    def getIntendedPartialInitializationCount(self):
+        return self.intendedPartialInitializationCount
+
+    def setIntendedPartialInitializationCount(self, value):
+        self.intendedPartialInitializationCount = value
+        return self
+
+    def addElement(self, element: ValueSpecification):
+        self.element.append(element)
+
+    def getElements(self) -> List[ValueSpecification]:
+        return self.element
+
+class ConstantSpecification(ARElement):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.valueSpec = None                  # type: ValueSpecification
+
+    def getValueSpec(self):
+        return self.valueSpec
+
+    def setValueSpec(self, value):
+        self.valueSpec = value
+        return self
+
+
+class ConstantReference(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self.constantRef = None                 # type: RefType
+
+    def getConstantRef(self):
+        return self.constantRef
+
+    def setConstantRef(self, value):
+        self.constantRef = value
+        return self

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

@@ -0,0 +1,21 @@
+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