armodel 1.8.2__py3-none-any.whl → 1.8.3__py3-none-any.whl

armodel/cli/format_xml_cli.py

@@ -0,0 +1,62 @@
+import argparse
+import sys
+import pkg_resources
+import xml.etree.ElementTree as ET
+from xml.dom import minidom
+import logging
+import re
+
+
+def patch_xml(xml: str) -> str:
+    xml = re.sub(r"\<([\w-]+)\/\>", r"<\1></\1>", xml)
+    # xml = re.sub(r"<([\w-]+)\s+(\w+)=(\"[\w-]+\")\/>", r"<\1 \2=\3></\1>", xml)
+    # xml = re.sub(r"&quot;", '"', xml)
+    return xml
+
+
+def perform_format(args):
+    try:
+        # Load XML file 
+        logging.info("Loading XML file: %s" % args.INPUT)
+        tree = ET.parse(args.INPUT)
+        ET.register_namespace("", "http://autosar.org/schema/r4.0")
+        root = tree.getroot()
+
+        # Save the XML file
+        xml = ET.tostring(root, encoding="UTF-8", xml_declaration=True, short_empty_elements=False)
+        
+        dom = minidom.parse(args.INPUT)
+        xml = dom.toprettyxml(indent="  ", encoding="UTF-8")
+
+        xml = patch_xml(xml.decode())
+
+        lines = xml.splitlines()
+
+        logging.info("Saving XML file: %s" % args.OUTPUT)
+
+        with open(args.OUTPUT, "w", encoding="utf-8") as f_out:
+            for line in lines:
+                if line.strip() == "":
+                    continue
+                f_out.write(line + "\n")
+        
+    except Exception as e:
+        logging.error(e)
+        sys.exit(1)
+        
+
+def main():
+    version = pkg_resources.require("armodel")[0].version
+
+    ap = argparse.ArgumentParser()
+    ap.description = "arxml-format ver: %s" % version
+    ap.add_argument("INPUT", help="The path of XML file")
+    ap.add_argument("OUTPUT", help="The path of XML file")
+
+    args = ap.parse_args()
+
+    perform_format(args)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -21,33 +21,34 @@ class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
     def __init__(self, parent, short_name: str):
         super().__init__(parent, short_name)
 
-        self.arrayImplPolicy = None             # type: ARLiteral
-        self.arraySize = None                   # type: ARNumerical
-        self.arraySizeHandling = None           # type: ARLiteral
-        self.arraySizeSemantics = None          # type: ARLiteral
-        self.isOptional = None                  # type: ARBoolean
-        self.swDataDefProps = None              # type: SwDataDefProps
-
-    def getArrayImplPolicy(self):
+        self.arrayImplPolicy: ARLiteral = None
+        self.arraySize: ARNumerical = None
+        self.arraySizeHandling: ARLiteral = None
+        self.arraySizeSemantics: ARLiteral = None
+        self.isOptional: ARBoolean = None
+        self.subElements: List[ImplementationDataTypeElement] = []
+        self.swDataDefProps: SwDataDefProps = None
+
+    def getArrayImplPolicy(self) -> ARLiteral:
         return self.arrayImplPolicy
 
-    def setArrayImplPolicy(self, value):
+    def setArrayImplPolicy(self, value: ARLiteral):
         if value is not None:
             self.arrayImplPolicy = value
         return self
 
-    def getArraySize(self):
+    def getArraySize(self) -> ARNumerical:
         return self.arraySize
 
-    def setArraySize(self, value):
+    def setArraySize(self, value: ARNumerical):
         if value is not None:
             self.arraySize = value
         return self
 
-    def getArraySizeHandling(self):
+    def getArraySizeHandling(self) -> ARLiteral:
         return self.arraySizeHandling
 
-    def setArraySizeHandling(self, value):
+    def setArraySizeHandling(self, value: ARLiteral):
         if value is not None:
             self.arraySizeHandling = value
         return self
@@ -80,10 +81,11 @@ class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
         if (not self.IsElementExists(short_name)):
             type_element = ImplementationDataTypeElement(self, short_name)
             self.addElement(type_element)
+            self.subElements.append(type_element)
         return self.getElement(short_name, ImplementationDataTypeElement)
     
-    def getImplementationDataTypeElements(self) -> List["ImplementationDataTypeElement"]:
-        return list(filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements))
+    def getSubElements(self) -> List["ImplementationDataTypeElement"]:
+        return self.subElements
 
 
 class AbstractImplementationDataType(AutosarDataType, metaclass=ABCMeta):

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

@@ -8,7 +8,7 @@ class Trigger(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.swImplPolicy = None                                # type: SwImplPolicyEnum
+        self.swImplPolicy: SwImplPolicyEnum = None
         self.triggerPeriod = None                               # type: MultidimensionalTime
 
     def getSwImplPolicy(self):

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

@@ -1,23 +1,26 @@
 from abc import ABCMeta
 from typing import List
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, RefType
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral
 
-class ValueSpecification(ARObject, metaclass = ABCMeta):
+
+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, 
+                  ConstantReference, NotAvailableValueSpecification, NumericalValueSpecification, ReferenceValueSpecification,
                   TextValueSpecification
     '''
+
     def __init__(self):
-        if type(self) == ValueSpecification:
-            raise NotImplementedError("ValueSpecification is an abstract class.")
-        
+        if type(self) is ValueSpecification:
+            raise NotImplementedError(
+                "ValueSpecification is an abstract class.")
+
         super().__init__()
 
         self.shortLabel = None
@@ -28,21 +31,25 @@ class ValueSpecification(ARObject, metaclass = ABCMeta):
     def setShortLabel(self, value):
         self.shortLabel = value
         return self
-    
-class CompositeValueSpecification(ValueSpecification, metaclass = ABCMeta):
+
+
+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__()    
+        if type(self) is CompositeValueSpecification:
+            raise NotImplementedError(
+                "CompositeValueSpecification is an abstract class.")
+
+        super().__init__()
+
 
-class CompositeRuleBasedValueArgument(ARObject, metaclass = ABCMeta):
+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.
@@ -50,12 +57,15 @@ class CompositeRuleBasedValueArgument(ARObject, metaclass = ABCMeta):
     Base        : ARObject
     Subclasses  : ApplicationRuleBasedValueSpecification, ApplicationValueSpecification
     '''
+
     def __init__(self):
-        if type(self) == CompositeRuleBasedValueArgument:
-            raise NotImplementedError("CompositeRuleBasedValueArgument is an abstract class.")
-        
+        if type(self) is 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
@@ -63,10 +73,11 @@ class ApplicationValueSpecification(CompositeRuleBasedValueArgument, ValueSpecif
     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    
+    Base ARObject, CompositeRuleBasedValueArgument, ValueSpecification
     '''
+
     def __init__(self):
-        
+
         CompositeRuleBasedValueArgument.__init__(self)
         ValueSpecification.__init__(self)
 
@@ -99,9 +110,10 @@ class ApplicationValueSpecification(CompositeRuleBasedValueArgument, ValueSpecif
 class RecordValueSpecification(CompositeValueSpecification):
     '''
     Specifies the values for a record.
-    
+
     Base : ARObject, CompositeValueSpecification, ValueSpecification
     '''
+
     def __init__(self):
         super().__init__()
 
@@ -112,7 +124,8 @@ class RecordValueSpecification(CompositeValueSpecification):
 
     def getFields(self) -> List[ValueSpecification]:
         return self.fields
-    
+
+
 class TextValueSpecification(ValueSpecification):
     def __init__(self):
         super().__init__()
@@ -131,13 +144,14 @@ class NumericalValueSpecification(ValueSpecification):
     def __init__(self):
         super().__init__()
 
-        self.value = None               # type: ARNumerical  
+        self.value: ARNumerical = None
 
-    def getValue(self):
+    def getValue(self) -> ARNumerical:
         return self.value
 
-    def setValue(self, value):
-        self.value = value
+    def setValue(self, value: ARNumerical):
+        if value is not None:
+            self.value = value
         return self
 
 
@@ -145,7 +159,8 @@ class ArrayValueSpecification(ValueSpecification):
     def __init__(self):
         super().__init__()
 
-        self.element = []                                   # type: List[ValueSpecification]
+        # type: List[ValueSpecification]
+        self.element = []
         self.intendedPartialInitializationCount = None
 
     def getIntendedPartialInitializationCount(self):
@@ -161,6 +176,7 @@ class ArrayValueSpecification(ValueSpecification):
     def getElements(self) -> List[ValueSpecification]:
         return self.element
 
+
 class ConstantSpecification(ARElement):
     def __init__(self, parent, short_name):
         super().__init__(parent, short_name)
@@ -179,7 +195,7 @@ class ConstantReference(ValueSpecification):
     def __init__(self):
         super().__init__()
 
-        self.constantRef = None                 # type: RefType
+        self.constantRef: RefType = None
 
     def getConstantRef(self):
         return self.constantRef

armodel/models/M2/AUTOSARTemplates/GenericStructure/GeneralTemplateClasses/Identifiable.py

@@ -122,11 +122,11 @@ class Identifiable(MultilanguageReferrable, CollectableElement, metaclass=ABCMet
         MultilanguageReferrable.__init__(self, parent, short_name)
         CollectableElement.__init__(self)
 
-        self.annotations = []                       # type: List[Annotation]
-        self.adminData = None                       # type: AdminData
-        self.category = None                        # type: CategoryString
-        self.introduction = None                    # type: DocumentationBlock
-        self.desc = None                            # type: MultiLanguageOverviewParagraph
+        self.annotations: List[Annotation] = []
+        self.adminData: AdminData = None
+        self.category: CategoryString = None
+        self.introduction: DocumentationBlock = None
+        self.desc: MultiLanguageOverviewParagraph = None
 
     def getAdminData(self):
         return self.adminData

armodel/models/M2/AUTOSARTemplates/GenericStructure/GeneralTemplateClasses/PrimitiveTypes.py

@@ -34,7 +34,8 @@ class ARNumerical(ARType):
     def __init__(self) -> None:
         super().__init__()
 
-        self._text = None                       # type: str
+        self.shortLabel: str = None
+        self._text: str = None
 
     def _convertStringToNumberValue(self, value: str) -> int:
         try:
@@ -75,7 +76,18 @@ class ARNumerical(ARType):
             return self._text
         else:
             return str(self._value)
+        
+    def getValue(self):
+        return self.value
 
+    def setShortLabel(self, val: str):
+        if val is not None:
+            self.shortLabel = val
+        return self
+    
+    def getShortLabel(self) -> str:
+        return self.shortLabel
+    
 
 class ARFloat(ARNumerical):
     def __init__(self) -> None: