armodel 1.8.2__py3-none-any.whl → 1.8.4__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/cli/uuid_checker_cli.py

@@ -0,0 +1,94 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Referrable
+from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
+from ..parser.arxml_parser import ARXMLParser
+from ..lib.cli_args_parser import InputFileParser
+
+
+def perform_uuid_duplicate_check(args):
+    logger = logging.getLogger()
+    
+    formatter = logging.Formatter('[%(levelname)s] : %(message)s')
+
+    stdout_handler = logging.StreamHandler(sys.stderr)
+    stdout_handler.setFormatter(formatter)
+
+    base_path = os.path.dirname(args.OUTPUT)
+    log_file = os.path.join(base_path, 'uuid_check.log')
+
+    if os.path.exists(log_file):
+        os.remove(log_file)
+
+    if args.verbose:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        file_handler.setLevel(logging.DEBUG)
+
+    logger.setLevel(logging.DEBUG)
+
+    if args.verbose:
+        stdout_handler.setLevel(logging.DEBUG)
+    else:
+        stdout_handler.setLevel(logging.INFO)
+
+    if args.verbose:
+        logger.addHandler(file_handler)
+    logger.addHandler(stdout_handler)
+
+    try:
+        options = {}
+        if args.warning:
+            options['warning'] = True
+            
+        inputs = []
+        inputs.append(args.INPUT)
+        parser = InputFileParser(inputs)
+        filenames = parser.parse()
+
+        document = AUTOSAR().getInstance()
+        parser = ARXMLParser(options)
+
+        for filename in filenames:
+            parser.load(filename, document)
+
+        with open(args.OUTPUT, 'w') as f_out:
+            for uuid in document.getDuplicateUUIDs():
+                ar_objects = document.getARObjectByUUID(uuid)
+                if len(ar_objects) > 1:
+                    f_out.write("Duplicate UUID found: %s \n" % uuid)
+                    for ar_object in ar_objects:
+                        if isinstance(ar_object, Referrable):
+                            f_out.write("  - %s (%s)\n" % (ar_object.getFullName(), type(ar_object).__name__))
+                        else:
+                            raise NotImplementedError("Unsupported type <%s>" % type(ar_object))
+        
+    except Exception as e:
+        logger.error(e)
+        if args.verbose:
+            raise e
+
+
+def main():
+    version = pkg_resources.require("armodel")[0].version
+
+    ap = argparse.ArgumentParser()
+    ap.description = "arxml-format ver: %s" % version
+    ap.add_argument("-v", "--verbose", required=False, help="Print debug information", action="store_true")
+    ap.add_argument("--log", required=False, help="Log all information to file")
+    ap.add_argument("-w", "--warning", required=False, help="Skip the error and report it as warning message", action="store_true")
+    
+    ap.add_argument("INPUT", help="The path of AUTOSAR ARXML file")
+    ap.add_argument("OUTPUT", help="The path of output ARXML file")
+
+    args = ap.parse_args()
+
+    perform_uuid_duplicate_check(args)
+
+
+if __name__ == "__main__":
+    main()

armodel/models/M2/AUTOSARTemplates/AutosarTopLevelStructure.py

@@ -247,13 +247,16 @@ class AbstractAUTOSAR(CollectableElement):
         return self
     
     def getARObjectByUUID(self, uuid: str) -> List[ARObject]:
-        return self.uuid_mgr.getObjects()
+        return self.uuid_mgr.getObjects(uuid)
 
     def addARObject(self, value: ARObject):
         if value is not None:
             self.uuid_mgr.addObject(value)
         return self
     
+    def getDuplicateUUIDs(self) -> List[str]:
+        return self.uuid_mgr.getDuplicateUUIDs()
+    
     def setARRelease(self, release: str):
         if release not in self.release_xsd_mappings:
             raise "invalid AUTOSAR Release <%s>" % release

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswBehavior.py

@@ -162,6 +162,13 @@ class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
             self.addElement(access)
             self.callPoints.append(access)
         return self.getElement(short_name)
+    
+    def createBswSynchronousServerCallPoint(self, short_name):
+        if (not self.IsElementExists(short_name)):
+            access = BswSynchronousServerCallPoint(self, short_name)
+            self.addElement(access)
+            self.callPoints.append(access)
+        return self.getElement(short_name)
 
     def getDataReceivePoints(self):
         return self.dataReceivePoints

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswInterfaces.py

@@ -45,7 +45,7 @@ class BswModuleEntry(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.arguments = []                         # type: List[SwServiceArg]
+        self.arguments = []                         # type
         self.bswEntryKind = None                    # type: BswEntryKindEnum
         self.callType = None                        # type: BswCallType
         self.executionContext = None                # type: BswExecutionContext
@@ -114,9 +114,12 @@ class BswModuleEntry(ARElement):
     def getReturnType(self):
         return self.returnType
 
-    def setReturnType(self, value):
-        self.returnType = value
-        return self
+    def createReturnType(self, short_name: str) -> SwServiceArg:
+        if (short_name not in self.elements):
+            arg = SwServiceArg(self, short_name)
+            self.addElement(arg)
+            self.returnType = arg
+        return self.getElement(short_name)
 
     def getRole(self):
         return self.role

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:
@@ -236,8 +248,8 @@ class ARBoolean(ARType):
             self._value = self._convertNumberToBoolean(val)
             self._text = str(val)
         elif isinstance(val, str):
-            self._text = val
-            self._value = self._convertStringToBoolean(val)
+            self._value = self._convertStringToBoolean(val.strip())
+            self._text = val.strip()
         else:
             raise ValueError("Unsupported Type <%s>", type(val))