armodel 1.3.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/report/__init__.py

@@ -0,0 +1 @@
+from .connector_xls_report import ConnectorXlsReport

armodel/report/connector_xls_report.py

@@ -0,0 +1,76 @@
+from .excel_report import ExcelReporter
+from ..models import AUTOSAR, ARPackage, CompositionSwComponentType
+from ..models import PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
+from typing import List
+
+class ConnectorXlsReport(ExcelReporter):
+    def __init__(self) -> None:
+        super().__init__()
+        self.swcs = []              # type: List[CompositionSwComponentType]
+
+    def _parse_pkg(self, parent: ARPackage):
+        for pkg in parent.getARPackages():
+            self._parse_pkg(pkg)
+        for swc in parent.getSwComponentTypes():
+            self.swcs.append(swc)
+
+    def import_data(self, document: AUTOSAR):
+        for pkg in document.getARPackages():
+            self._parse_pkg(pkg)
+
+    def _write_assembly_sw_connection(self, swc: CompositionSwComponentType, index = 0):
+        sheet = self.wb.create_sheet("%s - AC" % swc.short_name, index)
+        title_row = ["Short Name", "Provide SW-C", "PPort", "Request SW-C", "RPort"]
+        self.write_title_row(sheet, title_row)
+
+        row = 2
+        for connector in swc.getAssemblySwConnectors():
+            self._logger.debug("Write AssemblySwConnection %s" % connector.short_name)
+            self.write_cell(sheet, row, 1, connector.short_name)
+            self.write_cell(sheet, row, 2, connector.provider_iref.context_component_ref.value)
+            self.write_cell(sheet, row, 3, connector.provider_iref.target_p_port_ref.value)
+            self.write_cell(sheet, row, 4, connector.requester_iref.context_component_ref.value)
+            self.write_cell(sheet, row, 5, connector.requester_iref.target_r_port_ref.value)
+            row += 1
+
+        self.auto_width(sheet)
+
+    def _write_delegation_sw_connection(self, swc: CompositionSwComponentType, index = 0):
+        sheet = self.wb.create_sheet("%s - DC" % swc.short_name, index)
+        title_row = ["Short Name", "Inner SW-C", "Inner PPort", "Outer PPort", "Inner RPort", "Outer RPort"]
+        self.write_title_row(sheet, title_row)
+
+        row = 2
+        for connector in swc.getDelegationSwConnectors():
+            self._logger.debug("Write DelegationSwConnection %s" % connector.short_name)
+            self.write_cell(sheet, row, 1, connector.short_name)
+
+            if connector.inner_port_iref:
+                if isinstance(connector.inner_port_iref, PPortInCompositionInstanceRef):
+                    self.write_cell(sheet, row, 2, connector.inner_port_iref.context_component_ref.value)
+                    self.write_cell(sheet, row, 3, connector.inner_port_iref.target_p_port_ref.value)
+                elif isinstance(connector.inner_port_iref, RPortInCompositionInstanceRef):
+                    self.write_cell(sheet, row, 2, connector.inner_port_iref.context_component_ref.value)
+                    self.write_cell(sheet, row, 5, connector.inner_port_iref.target_r_port_ref.value)
+
+            if connector.outer_port_ref.dest == "P-PORT-PROTOTYPE":
+                self.write_cell(sheet, row, 4, connector.outer_port_ref.value)
+            elif connector.outer_port_ref.dest == "R-PORT-PROTOTYPE":
+                self.write_cell(sheet, row, 6, connector.outer_port_ref.value)
+            else:
+                raise ValueError("Invalid OUTER-PORT-REF of SwConnector <%s>" % connector.short_name)
+            row += 1
+
+        self.auto_width(sheet)
+
+    def write(self, filename: str):
+        swc_list = filter(lambda o: isinstance(o, CompositionSwComponentType), self.swcs)
+        
+        idx = 1
+        for swc in sorted(swc_list, key = lambda o: o.short_name):
+            self._logger.info("CompositionSwComponentType %s" % swc.short_name)
+            self._write_assembly_sw_connection(swc, idx)
+            self._write_delegation_sw_connection(swc, idx + 1)
+            idx += 2
+
+        self.wb.save(filename)

armodel/report/excel_report.py

@@ -0,0 +1,42 @@
+from openpyxl import Workbook
+
+import logging
+
+class ExcelReporter:
+    def __init__(self) -> None:
+        self.wb = Workbook()
+        self._logger = logging.getLogger()
+    
+    def write_revision(self):
+        sheet = self.wb['Sheet']
+        sheet.title = "History"
+
+        title_rows = ["When", "Who", "Version", "History"]
+        self.write_title_row(sheet, title_rows)
+
+    def auto_width(self, worksheet):
+        dims = {}
+        for row in worksheet.rows:
+            for cell in row:
+                if cell.value:
+                    dims[cell.column_letter] = max((dims.get(cell.column_letter, 0), len(str(cell.value))))
+
+        for col, value in dims.items():
+            worksheet.column_dimensions[col].width = (value + 2) + 2
+
+    def write_title_row(self, sheet, title_row):
+        for idx in range(0, len(title_row)):
+            cell = sheet.cell(row=1, column=idx + 1)
+            cell.value = title_row[idx]
+
+    def write_cell(self, sheet, row, column, value, format = None):
+        cell = sheet.cell(row = row, column=column) 
+        cell.value = value
+        if (format != None):
+            if ('alignment' in format):
+                cell.alignment = format['alignment']
+            if ('number_format' in format):
+                cell.number_format = format['number_format']
+
+    def save(self, name: str):
+        self.wb.save(name)

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")
+
+        
+