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

armodel/parser/connector_xlsx_parser.py

@@ -0,0 +1,190 @@
+from typing import Dict, List
+from openpyxl import Workbook
+from openpyxl.worksheet.worksheet import Worksheet
+
+import openpyxl
+import re
+
+from ..parser.excel_parser import AbstractExcelParser
+from ..data_models.sw_connector import AssemblySwConnectorData, DelegationSwConnectorData, SwConnectorData
+from ..models.ar_ref import PPortInCompositionInstanceRef, RPortInCompositionInstanceRef, RefType
+from ..models.sw_component import CompositionSwComponentType
+from ..models.ar_package import AUTOSAR, ARPackage
+
+class ConnectorXls:
+
+    COL_SHORT_NAME      = 'Short Name'
+    COL_INNER_SW_C      = 'Inner SW-C'
+    COL_INNER_PPORT     = 'Inner PPort'
+    COL_OUTER_PPORT     = 'Outer PPort'
+    COL_INNER_RPORT     = 'Inner RPort'
+    COL_OUTER_RPORT     = 'Outer RPort'
+
+    COL_PROVIDER_SW_C    = "Provide SW-C"
+    COL_PPORT           = "PPort"
+    COL_REQUESTER_SW_C    = "Request SW-C"
+    COL_RPORT           = "RPort"
+
+class ConnectorXlsReader(AbstractExcelParser):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.column_delegation_sw_connectors = {
+            ConnectorXls.COL_SHORT_NAME: -1,
+            ConnectorXls.COL_INNER_SW_C: -1,
+            ConnectorXls.COL_INNER_PPORT: -1,
+            ConnectorXls.COL_OUTER_PPORT: -1,
+            ConnectorXls.COL_INNER_RPORT: -1,
+            ConnectorXls.COL_OUTER_RPORT: -1,
+        }
+
+        self.column_assembly_sw_connectors = {
+            ConnectorXls.COL_SHORT_NAME: -1,
+            ConnectorXls.COL_PROVIDER_SW_C: -1,
+            ConnectorXls.COL_PPORT: -1,
+            ConnectorXls.COL_REQUESTER_SW_C: -1,
+            ConnectorXls.COL_RPORT: -1,
+        }
+
+        self.sw_connectors = {}    # type: Dict[str, List[DelegationSwConnectorData]]
+        
+
+    def getCompositionSwComponentList(self) -> List[str]:
+        return self.sw_connectors.keys()
+            
+    def getSwConnectorList(self, swc: str) -> List[SwConnectorData]:
+        if swc not in self.sw_connectors:
+            self.sw_connectors[swc] = []
+        return self.sw_connectors[swc]
+        #return sorted(self.sw_connectors[swc], key = lambda o: o.short_name)
+            
+    def readDelegationSwConnectors(self, sheet: Worksheet, swc: str, start_row: int, column_list: Dict[str, int]):
+        connectors = self.getSwConnectorList(swc)
+        for row in sheet.iter_rows(min_row = start_row, values_only= True):
+            connector = DelegationSwConnectorData()
+            connector.short_name = row[column_list[ConnectorXls.COL_SHORT_NAME]]
+            connector.inner_swc = row[column_list[ConnectorXls.COL_INNER_SW_C]]
+            connector.inner_pport = row[column_list[ConnectorXls.COL_INNER_PPORT]]
+            connector.inner_rport = row[column_list[ConnectorXls.COL_INNER_RPORT]]
+            connector.outer_pport = row[column_list[ConnectorXls.COL_OUTER_PPORT]]
+            connector.outer_rport = row[column_list[ConnectorXls.COL_OUTER_RPORT]]
+            connectors.append(connector)
+            self._logger.debug("ShortName: %s" % connector.short_name)
+
+    def readAssemblySwConnectors(self, sheet: Worksheet, swc: str, start_row: int, column_list: Dict[str, int]):
+        connectors = self.getSwConnectorList(swc)
+        for row in sheet.iter_rows(min_row = start_row, values_only= True):
+            connector = AssemblySwConnectorData()
+            connector.short_name = row[column_list[ConnectorXls.COL_SHORT_NAME]]
+            connector.provider_swc = row[column_list[ConnectorXls.COL_PROVIDER_SW_C]]
+            connector.pport = row[column_list[ConnectorXls.COL_PPORT]]
+            connector.requester_swc = row[column_list[ConnectorXls.COL_REQUESTER_SW_C]]
+            connector.rport = row[column_list[ConnectorXls.COL_RPORT]]
+            connectors.append(connector)
+            self._logger.debug("ShortName: %s" % connector.short_name)
+
+    def parseDelegationSWConnectors(self, sheet: Worksheet, swc: str):
+        self._logger.debug("Parse all DelegationSwConnector of %s" % swc)
+
+        self.getColumnTitles(sheet, 1, self.column_delegation_sw_connectors)
+        self.checkColumnTitles(self.column_delegation_sw_connectors, "Invalid DelegationSwConnectors Excel and column <%s> cannot be located.")
+        self.readDelegationSwConnectors(sheet, swc, 2, self.column_delegation_sw_connectors)
+
+    def parseAssemblySWConnectors(self, sheet: Worksheet, swc: str):
+        self._logger.debug("Parse all AssemblySwConnector of %s" % swc)
+
+        self.getColumnTitles(sheet, 1, self.column_assembly_sw_connectors)
+        self.checkColumnTitles(self.column_assembly_sw_connectors, "Invalid AssemblySwConnectors Excel and column <%s> cannot be located.")
+        self.readAssemblySwConnectors(sheet, swc, 2, self.column_assembly_sw_connectors)
+        
+    def read(self, excel_file: str):
+        self._logger.info("Parse excel file <%s>" % excel_file) 
+
+        wb = openpyxl.load_workbook(excel_file, data_only=True)
+
+        for name in wb.sheetnames:
+            m = re.match(r'(\w+)\s+-\s+(AC|DC)', name)
+            if m:
+                if m.group(2) == "DC":
+                    self.parseDelegationSWConnectors(wb[name], m.group(1))
+                elif m.group(2) == "AC":
+                    self.parseAssemblySWConnectors(wb[name], m.group(1))
+                else:
+                    raise ValueError("Invalid sheet")
+                
+    def _addAssemblySwConnector(self, swc: CompositionSwComponentType, connector: AssemblySwConnectorData):
+        sw_connector = swc.createAssemblySwConnector(connector.short_name)
+
+        sw_connector.provider_iref = PPortInCompositionInstanceRef()
+        sw_connector.provider_iref.context_component_ref = RefType()
+        sw_connector.provider_iref.target_p_port_ref = RefType()
+        sw_connector.provider_iref.context_component_ref.dest = "SW-COMPONENT-PROTOTYPE"
+        sw_connector.provider_iref.context_component_ref.value = connector.provider_swc
+        sw_connector.provider_iref.target_p_port_ref.dest = "P-PORT-PROTOTYPE"
+        sw_connector.provider_iref.target_p_port_ref.value = connector.pport
+
+        sw_connector.requester_iref = RPortInCompositionInstanceRef()
+        sw_connector.requester_iref.context_component_ref = RefType()
+        sw_connector.requester_iref.target_r_port_ref = RefType()
+        sw_connector.requester_iref.context_component_ref.dest = "SW-COMPONENT-PROTOTYPE"
+        sw_connector.requester_iref.context_component_ref.value = connector.requester_swc
+        sw_connector.requester_iref.target_r_port_ref.dest = "R-PORT-PROTOTYPE"
+        sw_connector.requester_iref.target_r_port_ref.value = connector.rport
+
+    def _addDelegationSwConnector(self, swc: CompositionSwComponentType, connector: DelegationSwConnectorData):
+        sw_connector = swc.createDelegationSwConnector(connector.short_name)
+        if connector.inner_pport is not None and connector.outer_pport is not None:
+            sw_connector.inner_port_iref = PPortInCompositionInstanceRef()
+            sw_connector.inner_port_iref.context_component_ref = RefType()
+            sw_connector.inner_port_iref.target_p_port_ref = RefType()
+            sw_connector.outer_port_ref = RefType()
+            sw_connector.inner_port_iref.context_component_ref.dest = "SW-COMPONENT-PROTOTYPE"
+            sw_connector.inner_port_iref.context_component_ref.value = connector.inner_swc
+            sw_connector.inner_port_iref.target_p_port_ref.dest = "P-PORT-PROTOTYPE"
+            sw_connector.inner_port_iref.target_p_port_ref.value = connector.inner_pport
+            sw_connector.outer_port_ref.dest = "P-PORT-PROTOTYPE"
+            sw_connector.outer_port_ref.value = connector.outer_pport
+        elif connector.inner_rport is not None and connector.outer_rport is not None:
+            sw_connector.inner_port_iref = RPortInCompositionInstanceRef()
+            sw_connector.inner_port_iref.context_component_ref = RefType()
+            sw_connector.inner_port_iref.target_r_port_ref = RefType()
+            sw_connector.outer_port_ref = RefType()
+            sw_connector.inner_port_iref.context_component_ref.dest = "SW-COMPONENT-PROTOTYPE"
+            sw_connector.inner_port_iref.context_component_ref.value = connector.inner_swc
+            sw_connector.inner_port_iref.target_r_port_ref.dest = "R-PORT-PROTOTYPE"
+            sw_connector.inner_port_iref.target_r_port_ref.value = connector.inner_rport
+            sw_connector.outer_port_ref.dest = "R-PORT-PROTOTYPE"
+            sw_connector.outer_port_ref.value = connector.outer_rport
+        else:
+            raise ValueError("Invalid DelegationSwConnector Configuration")
+
+                
+    def _updateCompositionSwComponent(self, swc: CompositionSwComponentType):
+        # remove all the sw connector first
+        swc.removeAllAssemblySwConnector()
+        swc.removeAllDelegationSwConnector()
+
+        connectors = self.getSwConnectorList(swc.short_name)
+
+        for connector in connectors:
+            #self._logger.info("Update %s" % connector.short_name)
+            if isinstance(connector, AssemblySwConnectorData):
+                self._addAssemblySwConnector(swc, connector)
+            elif isinstance(connector, DelegationSwConnectorData):
+                self._addDelegationSwConnector(swc, connector)
+            else:
+                raise ValueError("Invalid connector information")
+                
+    def _locateCompositionSwComponent(self, swc_name: str, parent: ARPackage):
+        for swc in parent.getSwComponentTypes():
+            if swc.short_name == swc_name:
+                self._updateCompositionSwComponent(swc)
+        for pkg in parent.getARPackages():
+            self._locateCompositionSwComponent(swc_name, pkg)
+
+    def update(self, document: AUTOSAR):
+        for name in self.getCompositionSwComponentList():
+            for pkg in document.getARPackages():
+                self._locateCompositionSwComponent(name, pkg)
+
+    

armodel/parser/excel_parser.py

@@ -0,0 +1,18 @@
+from typing import Dict
+from openpyxl.worksheet.worksheet import Worksheet
+
+import logging
+class AbstractExcelParser:
+    def __init__(self) -> None:
+        self._logger = logging.getLogger()
+
+    def getColumnTitles(self, sheet: Worksheet, title_row:int, column_list: Dict[str, int]):
+        for column in range(1, sheet.max_column + 1):
+            value = sheet.cell(title_row, column).value
+            if value in column_list:
+                column_list[value] = column - 1
+
+    def checkColumnTitles(self, column_list: Dict[str, int], message: str):
+        for key, value in column_list.items():
+            if value == -1:
+                raise ValueError(message % key)

armodel/tests/test_armodel/models/test_ar_object.py

@@ -0,0 +1,152 @@
+
+from ....models.ar_object import ARBoolean, ARFloat, ARLiteral, ARNumerical
+
+
+class TestARObject:
+    
+    def test_ARNumerical(self):
+        numerical = ARNumerical()
+        numerical.value = 123
+        assert(numerical.value == 123)
+        assert(numerical.getValue() == 123)
+        assert(str(numerical) == "123")
+        assert(numerical.getText() == "123")
+
+        numerical = ARNumerical()
+        numerical.setValue(123)
+        assert(numerical.value == 123)
+        assert(numerical.getValue() == 123)
+        assert(str(numerical) == "123")
+        assert(numerical.getText() == "123")
+
+        numerical = ARNumerical()
+        numerical.value = "1234"
+        assert(numerical.value == 1234)
+        assert(numerical.getValue() == 1234)
+        assert(str(numerical) == "1234")
+        assert(numerical.getText() == "1234")
+
+        numerical = ARNumerical()
+        numerical.setValue("0xFF")
+        assert(numerical.value == 255)
+        assert(numerical.getValue() == 255)
+        assert(str(numerical) == "0xFF")
+        assert(numerical.getText() == "0xFF")
+
+    def test_ARLiteral(self):
+        literal = ARLiteral()
+        assert(literal.value == "")
+        assert(str(literal) == "")
+        assert(literal.getValue() == "")
+        assert(literal.getText() == "")
+
+        literal = ARLiteral()
+        literal.value = "Literal"
+        assert(literal.value == "Literal")
+        assert(str(literal) == "Literal")
+        assert(literal.getValue() == "Literal")
+        assert(literal.getText() == "Literal")
+
+        literal = ARLiteral()
+        literal.setValue("Literal1")
+        assert(literal.value == "Literal1")
+        assert(str(literal) == "Literal1")
+        assert(literal.getValue() == "Literal1")
+        assert(literal.getText() == "Literal1")
+    
+        literal = ARLiteral()
+        literal.setValue(1234)
+        assert(literal.value == "1234")
+        assert(str(literal) == "1234")
+        assert(literal.getValue() == "1234")
+        assert(literal.getText() == "1234")
+
+
+    def test_ARFloat(self):
+        numerical = ARFloat()
+        numerical.value = 123
+        assert(numerical.value == 123.0)
+        assert(numerical.getValue() == 123.0)
+        assert(str(numerical) == "123.0")
+        assert(numerical.getText() == "123.0")
+
+        numerical = ARFloat()
+        numerical.setValue(123)
+        assert(numerical.value == 123)
+        assert(numerical.getValue() == 123)
+        assert(str(numerical) == "123.0")
+        assert(numerical.getText() == "123.0")
+
+        numerical = ARFloat()
+        numerical.value = 1234.12
+        assert(numerical.value == 1234.12)
+        assert(numerical.getValue() == 1234.12)
+        assert(str(numerical) == "1234.12")
+        assert(numerical.getText() == "1234.12")
+
+        numerical = ARFloat()
+        numerical.value = "1234.12"
+        assert(numerical.value == 1234.12)
+        assert(numerical.getValue() == 1234.12)
+        assert(str(numerical) == "1234.12")
+        assert(numerical.getText() == "1234.12")
+
+        numerical = ARFloat()
+        numerical.value = "1234.0"
+        assert(numerical.value == 1234)
+        assert(numerical.getValue() == 1234)
+        assert(str(numerical) == "1234.0")
+        assert(numerical.getText() == "1234.0")
+
+        numerical = ARFloat()
+        numerical.value = "1234.000000"
+        assert(numerical.value == 1234)
+        assert(numerical.getValue() == 1234)
+        assert(str(numerical) == "1234.000000")
+        assert(numerical.getText() == "1234.000000")
+
+    def test_ARBoolean(self):
+        flag = ARBoolean()
+        flag.value = False
+        assert(flag.value == False)
+        assert(flag.getValue() == False)
+        assert(str(flag) == "false")
+        assert(flag.getText() == "false")
+
+        flag = ARBoolean()
+        flag.value = 0
+        assert(flag.value == False)
+        assert(flag.getValue() == False)
+        assert(str(flag) == "0")
+        assert(flag.getText() == "0")
+
+        flag = ARBoolean()
+        flag.value = "0"
+        assert(flag.value == False)
+        assert(flag.getValue() == False)
+        assert(str(flag) == "0")
+        assert(flag.getText() == "0")
+
+        flag = ARBoolean()
+        flag.value = True
+        assert(flag.value == True)
+        assert(flag.getValue() == True)
+        assert(str(flag) == "true")
+        assert(flag.getText() == "true")
+
+        flag = ARBoolean()
+        flag.value = 1
+        assert(flag.value == True)
+        assert(flag.getValue() == True)
+        assert(str(flag) == "1")
+        assert(flag.getText() == "1")
+
+        flag = ARBoolean()
+        flag.value = "100"
+        assert(flag.value == True)
+        assert(flag.getValue() == True)
+        assert(str(flag) == "100")
+        assert(flag.getText() == "100")
+
+        
+    

armodel/tests/test_armodel/models/test_ar_package.py

@@ -29,7 +29,7 @@ class TestAUTOSAR:
         assert (isinstance(document, CollectableElement))
         assert (isinstance(document, AUTOSAR))
         assert (len(document.getARPackages()) == 0)
-        assert (document.version == "4.3.0")
+        assert (document.schema_location == "")
         assert (document.full_name == "")
 
     def test_create_autosar_package(self):

armodel/tests/test_armodel/models/test_common_structure.py

@@ -51,8 +51,8 @@ class Test_M2_AUTOSARTemplates_CommonStructure_ImplementationDataTypes:
         data_type = ImplementationDataTypeElement(ar_root, "implementation_data_type")
 
         assert(data_type.short_name == "implementation_data_type")
-        assert(data_type.array_size == None)
-        assert(data_type.is_optional == None)
+        assert(data_type.arraySize == None)
+        assert(data_type.isOptional == None)
 
         assert(isinstance(data_type, ARObject))
         assert(isinstance(data_type, AbstractImplementationDataTypeElement))

armodel/tests/test_armodel/models/test_data_dictionary.py

@@ -10,12 +10,12 @@ class Test_M2_MSR_DataDictionary_DataDefProperties:
         assert(isinstance(props, ARObject))
         assert(isinstance(props, SwDataDefProps))
 
-        assert(props.base_type_ref == None)
-        assert(props.compu_method_ref == None)
-        assert(props.data_constr_ref == None)                 
-        assert(props.implementation_data_type_ref == None)
-        assert(props.sw_impl_policy == "")
-        assert(props.sw_calibration_access == "")
+        assert(props.baseTypeRef == None)
+        assert(props.compuMethodRef == None)
+        assert(props.dataConstrRef == None)                 
+        assert(props.implementationDataTypeRef == None)
+        assert(props.swImplPolicy == None)
+        assert(props.swCalibrationAccess == None)
         assert(props.sw_pointer_target_props == None)
 
     def test_SwPointerTargetProps(self):
@@ -26,4 +26,4 @@ class Test_M2_MSR_DataDictionary_DataDefProperties:
 
         assert(props.function_pointer_signature == None)
         assert(props.sw_data_def_props == None)
-        assert(props.target_category == "")
+        assert(props.target_category == None)

armodel/tests/test_armodel/models/test_data_prototype.py

@@ -44,7 +44,7 @@ class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_DataPrototypes:
 
         assert(prototype.parent == ar_root)
         assert(prototype.short_name == "prototype")
-        assert(isinstance(prototype.type_tref, RefType))
+        assert(prototype.type_tref is None)
 
     def test_ApplicationCompositeElementDataPrototype(self):
         with pytest.raises(NotImplementedError) as err:
@@ -83,4 +83,4 @@ class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_DataPrototypes:
         assert(isinstance(prototype, Referrable))
         assert(isinstance(prototype, ApplicationRecordElement))
 
-        assert(prototype.is_optional == None)
+        assert(prototype.isOptional == None)

armodel/tests/test_armodel/models/test_datatype.py

@@ -54,7 +54,7 @@ class Test_M2_MSR_AsamHdo_BaseTypes:
 
         assert(base_type.parent == ar_root)
         assert(base_type.short_name == "SwBaseType")
-        assert(isinstance(base_type.base_type_definition, BaseTypeDirectDefinition))
+        assert(isinstance(base_type.baseTypeDefinition, BaseTypeDirectDefinition))
 
 class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_Datatypes:
     def test_AtpType(self):
@@ -130,7 +130,7 @@ class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_Datatypes:
 
         assert(data_type.parent == ar_root)
         assert(data_type.short_name == "ApplicationArrayDataType")
-        assert(data_type.dynamic_array_size_profile == "")
+        assert(data_type.dynamic_array_size_profile == None)
         assert(data_type.element == None)
 
     def test_ApplicationRecordDataType(self):
@@ -187,7 +187,7 @@ class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_Datatypes:
 
         assert(data_type_mapping_set.parent == ar_root)
         assert(data_type_mapping_set.short_name == "DataTypeMappingSet")
-        assert(len(data_type_mapping_set.data_type_maps) == 0)
+        assert(len(data_type_mapping_set._dataTypeMaps) == 0)
 
         data_type_map = DataTypeMap()
         data_type_mapping_set.addDataTypeMap(data_type_map)
@@ -228,7 +228,7 @@ class Test_M2_AUTOSARTemplates_CommonStructure_ImplementationDataTypes:
         assert(data_type.short_name == "ImplementationDataType")
         assert(data_type.sub_elements == [])
         assert(data_type.symbol_props == None)
-        assert(data_type.type_emitter == None)
+        assert(data_type._type_emitter == None)
 
         element = data_type.createImplementationDataTypeElement("ImplementationDataTypeElement")
         assert(isinstance(element, ImplementationDataTypeElement))

armodel/tests/test_armodel/models/test_general_structure.py

@@ -47,4 +47,4 @@ class TestGeneralStructure:
     def test_limit(self):
         limit = Limit()
         assert(limit.value == None)
-        assert(limit.interval_type == None)
+        assert(limit.intervalType == None)

armodel/tests/test_armodel/models/test_implementation.py

@@ -0,0 +1,26 @@
+
+from ....models.implementation import AutosarEngineeringObject, Code
+from ....models.ar_package import AUTOSAR
+
+
+class TestImplementation:
+    def test_code(self):
+        document = AUTOSAR.getInstance()
+        ar_root = document.createARPackage("AUTOSAR")
+        code = Code(ar_root, "code")
+        assert(code.short_name == "code")
+
+        data = [
+            ["Autosar::include::BswM.h", "SWHDR"],
+            ["Autosar::src::BswM.c", "SWSRC"]
+        ]
+
+        for item in data:
+            engineering_obj = AutosarEngineeringObject()
+            engineering_obj.setShortLabel(item[0])\
+                           .setCategory(item[1])
+            code.addArtifactDescriptor(engineering_obj)
+
+        assert(len(code.getArtifactDescriptors()) == 2)
+        assert(len(code.getArtifactDescriptors("SWHDR")) == 1)
+        assert(len(code.getArtifactDescriptors("SWSRC")) == 1)

armodel/tests/test_armodel/models/test_m2_msr.py

@@ -57,10 +57,10 @@ class Test_M2_MSR_AsamHdo_ComputationMethod:
         assert(isinstance(compu_scale, CompuScale))
 
         assert(compu_scale.compu_content == None)
-        assert(compu_scale.lower_limit == None)
-        assert(compu_scale.upper_limit == None)
-        assert(compu_scale.compu_inverse_value == None)
-        assert(compu_scale.compu_scale_contents == None)
+        assert(compu_scale.lowerLimit == None)
+        assert(compu_scale.upperLimit == None)
+        assert(compu_scale.compuInverseValue == None)
+        assert(compu_scale.compuScaleContents == None)
 
     def test_CompuScales(self):
         compu_scales = CompuScales()

armodel/tests/test_armodel/parser/test_arxml_parser.py

@@ -0,0 +1,15 @@
+
+from ....parser.arxml_parser import ARXMLParser
+
+
+class TestARXMLParser:
+    def test_convert_find_key(self):
+        parser = ARXMLParser()
+        assert(parser.convert_find_key("ELEMENTS") == "xmlns:ELEMENTS")
+        assert(parser.convert_find_key("ELEMENTS/*") == "xmlns:ELEMENTS/*")
+        assert(parser.convert_find_key("./ELEMENTS") == "./xmlns:ELEMENTS")
+        assert(parser.convert_find_key("./ELEMENTS/*") == "./xmlns:ELEMENTS/*")
+        assert(parser.convert_find_key("A/B") == "xmlns:A/xmlns:B")
+        assert(parser.convert_find_key("A/B/*") == "xmlns:A/xmlns:B/*")
+        assert(parser.convert_find_key("./A/B") == "./xmlns:A/xmlns:B")
+        assert(parser.convert_find_key("./A/B/*") == "./xmlns:A/xmlns:B/*")