py-eb-model 1.0.0__py3-none-any.whl → 1.1.3__py3-none-any.whl

eb_model/parser/eb_parser.py

@@ -1,21 +1,39 @@
-#from xml.etree import cElementTree as ET
+import logging
 import xml.etree.ElementTree as ET
 import re
 
 from abc import ABCMeta
 from typing import List
 
-class EBModelParser(metaclass = ABCMeta):
+from ..models.eb_doc import EBModel, PreferenceModel
+from ..models.abstract import EcucRefType, Module
+
+class AbstractEbModelParser(metaclass = ABCMeta):
 
     def __init__(self) -> None:
-        self.ns = {}
+        self.nsmap = {}
 
-        if type(self) == "EBModelParser":
-            raise ValueError("Abstract EBModelParser cannot be initialized.")
+        self.logger = logging.getLogger()
 
+        if type(self) == "AbstractEBModelParser":
+            raise ValueError("Abstract EBModelParser cannot be initialized.")
+        
     def validate_root(self, element: ET.Element):
-        if (element.tag != "{%s}%s" % (self.ns[''], "datamodel")):
+        if (element.tag != "{%s}%s" % (self.nsmap[''], "datamodel")):
             raise ValueError("This document <%s> is not EB xdm format" % element.tag)
+        
+    def read_version(self, parent: ET.Element, module: Module):
+        ctr_tag = self.find_ctr_tag(parent, "CommonPublishedInformation")
+        if ctr_tag is not None:
+            ar_version = module.getArVersion()
+            ar_version.setMajorVersion(self.read_value(ctr_tag, "ArMajorVersion"))
+            ar_version.setMinorVersion(self.read_value(ctr_tag, "ArMinorVersion"))
+            ar_version.setPatchVersion(self.read_value(ctr_tag, "ArPatchVersion"))
+
+            sw_version = module.getSwVersion()
+            sw_version.setMajorVersion(self.read_value(ctr_tag, "SwMajorVersion"))
+            sw_version.setMinorVersion(self.read_value(ctr_tag, "SwMinorVersion"))
+            sw_version.setPatchVersion(self.read_value(ctr_tag, "SwPatchVersion"))
 
     def read_ref_raw_value(self, value):
         '''
@@ -27,66 +45,73 @@ class EBModelParser(metaclass = ABCMeta):
             return match.group(1)
         return value
 
+    def _convert_value(self, tag: ET.Element):
+        if 'type' in tag.attrib:
+            if (tag.attrib['type'] == 'INTEGER'):
+                return int(tag.attrib['value'])
+            elif (tag.attrib['type'] == "FLOAT"):
+                return float(tag.attrib['value'])
+            elif (tag.attrib['type'] == 'BOOLEAN'):
+                if (tag.attrib['value'] == 'true'):
+                    return True
+                else:
+                    return False
+        return tag.attrib['value']
+
     def read_value(self, parent: ET.Element, name: str) -> str:
-        tag = parent.find(".//d:var[@name='%s']" % name, self.ns)
+        tag = parent.find(".//d:var[@name='%s']" % name, self.nsmap)
         if tag == None:
             raise KeyError("XPath d:var[@name='%s'] is invalid" % name)
-        if (tag.attrib['type'] == 'INTEGER'):
-            return int(tag.attrib['value'])
-        elif (tag.attrib['type'] == "FLOAT"):
-            return float(tag.attrib['value'])
-        elif (tag.attrib['type'] == 'BOOLEAN'):
-            if (tag.attrib['value'] == 'true'):
-                return True
-            else:
-                return False
-        else:
-            return tag.attrib['value']
+        return self._convert_value(tag)
 
     def read_optional_value(self, parent: ET.Element, name: str, default_value = None) -> str:
-        tag = parent.find(".//d:var[@name='%s']" % name, self.ns)
+        tag = parent.find(".//d:var[@name='%s']" % name, self.nsmap)
         if tag is None:
             return default_value
         if ('value' not in tag.attrib):
             return default_value
-        return tag.attrib['value']
+        enable = self.read_attrib(tag, 'ENABLE')
+        if (enable == 'false'):
+            return default_value
+        return self._convert_value(tag)
 
     def find_choice_tag(self, parent: ET.Element, name: str) -> ET.Element:
-        return parent.find(".//d:chc[@name='%s']" % name, self.ns)
+        return parent.find(".//d:chc[@name='%s']" % name, self.nsmap)
 
     def read_choice_value(self, parent: ET.Element, name: str) -> str:
         tag = self.find_choice_tag(parent, name)
         return tag.attrib['value']
 
-    def read_ref_value(self, parent: ET.Element, name: str) -> str:
-        tag = parent.find(".//d:ref[@name='%s']" % name, self.ns)
-        return self.read_ref_raw_value(tag.attrib['value'])
+    def read_ref_value(self, parent: ET.Element, name: str) -> EcucRefType:
+        tag = parent.find(".//d:ref[@name='%s']" % name, self.nsmap)
+        if tag is None:
+             raise KeyError("XPath d:ref[@name='%s'] is invalid" % name)
+        return EcucRefType(self.read_ref_raw_value(tag.attrib['value']))
 
-    def read_optional_ref_value(self, parent: ET.Element, name: str) -> str:
-        tag = parent.find(".//d:ref[@name='%s']" % name, self.ns)
+    def read_optional_ref_value(self, parent: ET.Element, name: str) -> EcucRefType:
+        tag = parent.find(".//d:ref[@name='%s']" % name, self.nsmap)
         enable = self.read_attrib(tag, 'ENABLE')
         if (enable == 'false'):
-            return ""
-        return self.read_ref_raw_value(tag.attrib['value'])
+            return None
+        return EcucRefType(self.read_ref_raw_value(tag.attrib['value']))
 
-    def read_ref_value_list(self, parent: ET.Element, name: str) -> List[str]:
+    def read_ref_value_list(self, parent: ET.Element, name: str) -> List[EcucRefType]:
         ref_value_list = []
-        for tag in parent.findall(".//d:lst[@name='%s']/d:ref" % name, self.ns):
-            ref_value_list.append(
-                self.read_ref_raw_value(tag.attrib['value']))
+        for tag in parent.findall(".//d:lst[@name='%s']/d:ref" % name, self.nsmap):
+            ref_value_list.append(EcucRefType(self.read_ref_raw_value(tag.attrib['value'])))
         return ref_value_list
 
     def find_ctr_tag_list(self, parent: ET.Element, name: str) -> List[ET.Element]:
-        return parent.findall(".//d:lst[@name='%s']/d:ctr" % name, self.ns)
+        return parent.findall(".//d:lst[@name='%s']/d:ctr" % name, self.nsmap)
     
     def find_chc_tag_list(self, parent: ET.Element, name: str) -> List[ET.Element]:
-        return parent.findall(".//d:lst[@name='%s']/d:chc" % name, self.ns)
+        return parent.findall(".//d:lst[@name='%s']/d:chc" % name, self.nsmap)
 
     def find_ctr_tag(self, parent: ET.Element, name: str) -> ET.Element:
         '''
         Read the child ctr tag. 
         '''
-        tag = parent.find(".//d:ctr[@name='%s']" % name, self.ns)
+        tag = parent.find(".//d:ctr[@name='%s']" % name, self.nsmap)
         if tag is None:
             return None
         enable = self.read_attrib(tag, 'ENABLE')
@@ -133,15 +158,43 @@ class EBModelParser(metaclass = ABCMeta):
             ref_tag.attrib['value'] = "ASPath:%s" % ref
             lst_tag.append(ref_tag)
         return lst_tag
+    
+    def get_component_name(self, parent: ET.Element) -> str:
+        tag = parent.find(".//d:chc[@type='AR-ELEMENT'][@value='MODULE-CONFIGURATION']", self.nsmap)
+        return tag.attrib['name']
 
     def find_lst_tag(self, parent: ET.Element, name: str) -> ET.Element:
-        return parent.find(".//d:lst[@name='%s']" % name, self.ns)
+        return parent.find(".//d:lst[@name='%s']" % name, self.nsmap)
 
     def read_attrib(self, parent: ET.Element, name: str) -> str:
-        attrib_tag = parent.find(".//a:a[@name='%s']" % name, self.ns)
+        attrib_tag = parent.find(".//a:a[@name='%s']" % name, self.nsmap)
         if attrib_tag is None:
             return None
         return attrib_tag.attrib['value']
 
-    def _read_namespaces(self, xdm: str):
-        self.ns = dict([node for _, node in ET.iterparse(xdm, events=['start-ns'])])
+    def read_namespaces(self, xdm: str):
+        self.nsmap = dict([node for _, node in ET.iterparse(xdm, events=['start-ns'])])
+
+    def parse(self, element: ET.Element, doc: EBModel):
+        pass
+
+    def parse_preference(self, element: ET.Element, doc: PreferenceModel):
+        pass
+
+    def load_xdm(self, filename: str) -> ET.Element:
+        self.logger.info("Loading <%s>" % filename)
+
+        self.read_namespaces(filename)
+        tree = ET.parse(filename)
+        self.root_tag = tree.getroot()
+        self.validate_root(self.root_tag)
+
+        return self.root_tag
+
+    def parse_xdm(self, filename: str, doc: EBModel):
+        root_tag = self.load_xdm(filename)
+        self.parse(root_tag, doc)
+
+    def parse_preference_xdm(self, filename: str, doc: EBModel):
+        root_tag = self.load_xdm(filename)
+        self.parse_preference(root_tag, doc)

eb_model/parser/eb_parser_factory.py

@@ -0,0 +1,29 @@
+import logging
+import xml.etree.cElementTree as ET
+
+from .rte_xdm_parser import RteXdmParser
+from .eb_parser import AbstractEbModelParser
+from .os_xdm_parser import OsXdmParser
+
+
+class EbParserFactory:
+    
+    @classmethod
+    def get_component_name(cls, filename: str) -> str:
+        tree = ET.parse(filename)
+        ns = dict([node for _, node in ET.iterparse(filename, events=['start-ns'])])
+        tag = tree.getroot().find(".//d:chc[@type='AR-ELEMENT'][@value='MODULE-CONFIGURATION']", ns)
+        return tag.attrib['name']
+    
+    @classmethod
+    def create(self, xdm: str) -> AbstractEbModelParser:
+        logging.getLogger().info("Analyzing file <%s>" % xdm)
+
+        name = EbParserFactory.get_component_name(xdm)
+
+        if name == "Os":
+            return OsXdmParser()
+        elif name == "Rte":
+            return RteXdmParser()
+        else:
+            raise NotImplementedError("Unsupported EB xdm file <%s>" % name)

eb_model/parser/os_xdm_parser.py

@@ -1,43 +1,188 @@
-from typing import List, Dict
 import xml.etree.ElementTree as ET
-import re
-
-from ..models.abstract import EcucContainer, EcucObject
 from ..models.eb_doc import EBModel
-from ..models.os_xdm import Os, OsApplication, OsCounter, OsResource, OsTask, OsIsr
-from .eb_parser import EBModelParser
+from ..models.os_xdm import Os, OsAlarm, OsAlarmActivateTask, OsAlarmCallback, OsAlarmIncrementCounter, OsAlarmSetEvent, OsCounter, OsScheduleTable
+from ..models.os_xdm import OsTask, OsIsr, OsApplication, OsScheduleTableEventSetting, OsScheduleTableExpiryPoint, OsScheduleTableTaskActivation
+from ..models.os_xdm import OsScheduleTblAdjustableExpPoint, OsTaskAutostart
+from ..parser.eb_parser import AbstractEbModelParser
+
 
-class OsXdmParser(EBModelParser):
+class OsXdmParser(AbstractEbModelParser):
     def __init__(self, ) -> None:
         super().__init__()
 
-    def parse(self, filename: str, doc: EBModel):
-        self._read_namespaces(filename)
-        tree = ET.parse(filename)
-        self.root_tag = tree.getroot()
-        self.validate_root(self.root_tag)
+        self.os = None
+
+    def parse(self, element: ET.Element, doc: EBModel):
+        if self.get_component_name(element) != "Os":
+            raise ValueError("Invalid <%s> xdm file" % "Os")
+
+        os = doc.getOs()
+
+        self.read_version(element, os)
 
-        self.read_os_tasks(doc.getOs())
-        self.read_os_isrs(doc.getOs())
+        self.logger.info("Parse Rte ARVersion:<%s> SwVersion:<%s>" % (os.getArVersion().getVersion(), os.getSwVersion().getVersion()))
+        
+        self.os = os
 
-    def read_os_tasks(self, os: Os):
-        for ctr_tag in self.find_ctr_tag_list(self.root_tag, 'OsTask'):
-            os_task = OsTask()
-            os_task.setName(ctr_tag.attrib['name']) \
-                .setOsTaskPriority(self.read_value(ctr_tag, "OsTaskPriority")) \
+        self.read_os_tasks(element, os)
+        self.read_os_isrs(element, os)
+        self.read_os_alarms(element, os)
+        self.read_os_schedule_tables(element, os)
+        self.read_os_counters(element, os)
+        self.read_os_applications(element, os)
+
+    def read_os_task_autostart(self, element: ET.Element, os_task: OsTask):
+        ctr_tag = self.find_ctr_tag(element, "OsTaskAutostart")
+        if ctr_tag is not None:
+            autostart = OsTaskAutostart(os_task, ctr_tag.attrib["name"])
+            for app_mode_ref in self.read_ref_value_list(ctr_tag, "OsTaskAppModeRef"):
+                autostart.addOsTaskAppModeRef(app_mode_ref)
+            os_task.setOsTaskAutostart(True)
+        else:
+            os_task.setOsTaskAutostart(False)
+
+    def read_os_tasks(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsTask"):
+            os_task = OsTask(os, ctr_tag.attrib["name"])
+            os_task.setOsTaskPriority(int(self.read_value(ctr_tag, "OsTaskPriority"))) \
                 .setOsTaskActivation(self.read_value(ctr_tag, "OsTaskActivation")) \
                 .setOsTaskSchedule(self.read_value(ctr_tag, "OsTaskSchedule")) \
-                .setOsStacksize(self.read_optional_value(ctr_tag, "OsStacksize", 0))
+                .setOsTaskType(self.read_optional_value(ctr_tag, "OsTaskType")) \
+                .setOsStacksize(int(self.read_optional_value(ctr_tag, "OsStacksize", 0)))
+
+            for resource_ref in self.read_ref_value_list(ctr_tag, "OsTaskResourceRef"):
+                os_task.addOsTaskResourceRef(resource_ref)
+
+            self.read_os_task_autostart(ctr_tag, os_task)
+
+            self.logger.debug("Read OsTask <%s>" % os_task.getName())
             os.addOsTask(os_task)
-    
-    def read_os_isrs(self, os: Os):
-        for ctr_tag in self.find_ctr_tag_list(self.root_tag, 'OsIsr'):
-            os_isr = OsIsr()
-            os_isr.setName(ctr_tag.attrib['name']) \
-                .setOsIsrCategory(self.read_value(ctr_tag, "OsIsrCategory")) \
+
+    def read_os_isrs(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsIsr"):
+            os_isr = OsIsr(os, ctr_tag.attrib["name"])
+            os_isr.setOsIsrCategory(self.read_value(ctr_tag, "OsIsrCategory")) \
                 .setOsIsrPeriod(self.read_optional_value(ctr_tag, "OsIsrPeriod", 0.0)) \
-                .setOsStacksize(self.read_value(ctr_tag, "OsStacksize")) \
+                .setOsStacksize(int(self.read_value(ctr_tag, "OsStacksize"))) \
                 .setOsIsrPriority(self.read_optional_value(ctr_tag, "OsIsrPriority"))
+            
+            # patch for the infineon Aurix
+            os_isr.setOsIsrPriority(self.read_optional_value(ctr_tag, "OsTricoreIrqLevel"))
+            # patch for the ARM
+            os_isr.setOsIsrPriority(self.read_optional_value(ctr_tag, "OsARMIrqLevel"))
+            os_isr.setOsIsrVector(self.read_optional_value(ctr_tag, "OsARMVector"))
 
+            self.logger.debug("Read OsIsr <%s>" % os_isr.getName())
             os.addOsIsr(os_isr)
-    
+
+    def read_os_alarm_action(self, element: ET.Element, os_alarm: OsAlarm):
+        chc = self.read_choice_value(element, "OsAlarmAction")
+        if chc is None:
+            raise ValueError("OsAlarmAction is required.")
+        if chc == "OsAlarmActivateTask":
+            os_alarm_action = OsAlarmActivateTask(os_alarm, "OsAlarmActivateTask") \
+                .setOsAlarmActivateTaskRef(self.read_ref_value(element, "OsAlarmActivateTaskRef"))
+        elif chc == "OsAlarmIncrementCounter":
+            os_alarm_action = OsAlarmIncrementCounter(os_alarm, "OsAlarmIncrementCounter") \
+                .setOsAlarmIncrementCounterRef(self.read_ref_value(element, "OsAlarmIncrementCounterRef"))
+        elif chc == "OsAlarmSetEvent":
+            os_alarm_action = OsAlarmSetEvent(os_alarm, "OsAlarmSetEvent") \
+                .setOsAlarmSetEventRef(self.read_ref_value(element, "OsAlarmSetEventRef")) \
+                .setOsAlarmSetEventTaskRef(self.read_ref_value(element, "OsAlarmSetEventTaskRef"))
+        elif chc == "OsAlarmCallback":
+            os_alarm_action = OsAlarmCallback(os_alarm, "OsAlarmCallback") \
+                .setOsAlarmCallbackName(self.read_value(element, "OsAlarmCallbackName"))
+        else:
+            raise ValueError("Unsupported OsAlarmAction <%s>" % chc)
+        os_alarm.setOsAlarmAction(os_alarm_action)
+
+    def read_os_alarms(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsAlarm"):
+            os_alarm = OsAlarm(os, ctr_tag.attrib["name"]) \
+                .setOsAlarmCounterRef(self.read_ref_value(ctr_tag, "OsAlarmCounterRef"))
+
+            for ref in self.read_ref_value_list(ctr_tag, "OsAlarmAccessingApplication"):
+                os_alarm.addOsAlarmAccessingApplicationRef(ref)
+
+            self.read_os_alarm_action(ctr_tag, os_alarm)
+
+            self.logger.debug("Read OsAlarm <%s>" % os_alarm.getName())
+            os.addOsAlarm(os_alarm)
+
+    def read_os_schedule_table_event_settings(self, element: ET.Element, expiry_point: OsScheduleTableExpiryPoint):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsScheduleTableEventSetting"):
+            event_setting = OsScheduleTableEventSetting(expiry_point, ctr_tag.attrib["name"]) \
+                .setOsScheduleTableSetEventRef(self.read_ref_value(ctr_tag, "OsScheduleTableSetEventRef")) \
+                .setOsScheduleTableSetEventTaskRef(self.read_ref_value(ctr_tag, "OsScheduleTableSetEventTaskRef"))
+
+            expiry_point.addOsScheduleTableEventSetting(event_setting)
+
+    def read_os_schedule_table_task_activations(self, element: ET.Element, expiry_point: OsScheduleTableExpiryPoint):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsScheduleTableTaskActivation"):
+            activation = OsScheduleTableTaskActivation(expiry_point, ctr_tag.attrib["name"]) \
+                .setOsScheduleTableActivateTaskRef(self.read_ref_value(ctr_tag, "OsScheduleTableActivateTaskRef"))
+
+            expiry_point.addOsScheduleTableTaskActivation(activation)
+
+    def read_os_schedule_tbl_adjustable_exp_point(self, element: ET.Element, expiry_point: OsScheduleTableExpiryPoint):
+        ctr_tag = self.find_ctr_tag(element, "OsScheduleTblAdjustableExpPoint")
+        if ctr_tag is not None:
+            exp_point = OsScheduleTblAdjustableExpPoint(expiry_point, ctr_tag.attrib["name"]) \
+                .setOsScheduleTableMaxLengthen(self.read_ref_value(ctr_tag, "OsScheduleTableMaxLengthen")) \
+                .setOsScheduleTableMaxShorten(self.read_ref_value(ctr_tag, "OsScheduleTableMaxShorten"))
+
+            expiry_point.setOsScheduleTblAdjustableExpPoint(exp_point)
+
+    def read_os_schedule_table_expiry_points(self, element: ET.Element, os_schedule_table: OsScheduleTable):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsScheduleTableExpiryPoint"):
+            expiry_point = OsScheduleTableExpiryPoint(os_schedule_table, ctr_tag.attrib["name"]) \
+                .setOsScheduleTblExpPointOffset(self.read_value(ctr_tag, "OsScheduleTblExpPointOffset")) \
+            
+            self.read_os_schedule_table_event_settings(ctr_tag, expiry_point)
+            self.read_os_schedule_table_task_activations(ctr_tag, expiry_point)
+            self.read_os_schedule_tbl_adjustable_exp_point(ctr_tag, expiry_point)
+
+            os_schedule_table.addOsScheduleTableExpiryPoint(expiry_point)
+
+    def read_os_schedule_tables(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsScheduleTable"):
+            table = OsScheduleTable(os, ctr_tag.attrib["name"]) \
+                .setOsScheduleTableDuration(self.read_value(ctr_tag, "OsScheduleTableDuration")) \
+                .setOsScheduleTableRepeating(self.read_value(ctr_tag, "OsScheduleTableRepeating")) \
+                .setOsScheduleTableCounterRef(self.read_ref_value(ctr_tag, "OsScheduleTableCounterRef")) \
+                .setOsTimeUnit(self.read_optional_value(ctr_tag, "OsTimeUnit"))
+
+            self.read_os_schedule_table_expiry_points(ctr_tag, table)
+
+            self.logger.debug("Read OsScheduleTable <%s>" % table.getName())
+            os.addOsScheduleTable(table)
+
+    def read_os_counters(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsCounter"):
+            counter = OsCounter(os, ctr_tag.attrib["name"]) \
+                .setOsCounterMaxAllowedValue(self.read_value(ctr_tag, "OsCounterMaxAllowedValue")) \
+                .setOsCounterMinCycle(self.read_value(ctr_tag, "OsCounterMinCycle")) \
+                .setOsCounterTicksPerBase(self.read_value(ctr_tag, "OsCounterTicksPerBase")) \
+                .setOsCounterType(self.read_optional_value(ctr_tag, "OsCounterType")) \
+                .setOsSecondsPerTick(self.read_optional_value(ctr_tag, "OsSecondsPerTick")) \
+                
+
+            self.logger.debug("Read OsCounter <%s>" % counter.getName())
+            os.addOsScheduleTable(counter)
+
+    def read_os_applications(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsApplication"):
+            os_app = OsApplication(os, ctr_tag.attrib["name"]) \
+                .setOsTrusted(self.read_value(ctr_tag, "OsTrusted"))
+            
+            for ref in self.read_ref_value_list(ctr_tag, "OsAppResourceRef"):
+                os_app.addOsAppResourceRef(ref)
+
+            for ref in self.read_ref_value_list(ctr_tag, "OsAppTaskRef"):
+                os_app.addOsAppTaskRef(ref)
+
+            for ref in self.read_ref_value_list(ctr_tag, "OsAppIsrRef"):
+                os_app.addOsAppIsrRef(ref)
+
+            self.logger.debug("Read OsApplication <%s>" % os_app.getName())
+            os.addOsApplication(os_app)

eb_model/parser/pref_xdm_parser.py

@@ -0,0 +1,36 @@
+import xml.etree.ElementTree as ET
+import logging
+import os
+from ..models.eb_doc import PreferenceModel
+from ..models.importer_xdm import SystemDescriptionImporter
+from . import AbstractEbModelParser
+
+class PerfXdmParser(AbstractEbModelParser):
+    def __init__(self, ) -> None:
+        super().__init__()
+
+        self.logger = logging.getLogger()
+
+    def parse_input_files(self, element: ET.Element, importer: SystemDescriptionImporter):
+        for ctr_tag in self.find_ctr_tag_list(element, "InputFiles"):
+            file_name = self.read_value(ctr_tag, "FileName")
+            self.logger.debug("Add the file <%s>" % file_name)
+            importer.addInputFile(file_name)
+
+    def parse_preference(self, element: ET.Element, doc: PreferenceModel):
+        importer = doc.getSystemDescriptionImporter()
+
+        for ctr_tag in self.find_ctr_tag_list(element, "SystemDescriptionImporters"):
+            self.logger.info("Parse SystemDescriptionImporters: <%s>" % ctr_tag.attrib["name"])
+            self.parse_input_files(ctr_tag, importer)
+            #importer.addInputFile()
+
+    def add_ecu_extract(self, doc: PreferenceModel, params = {'base_path': None, 'wildcard': None, "project": None}):
+        importer = doc.getSystemDescriptionImporter()
+
+        #if params['base_path'] is None:
+        #    raise ValueError("Please specify the base path")
+        
+        #ecu_extract_path = os.path.join(params['base_path'], '')
+        
+        importer.addInputFile('systemmod/EcuExtract.arxml')

eb_model/parser/rte_xdm_parser.py

@@ -0,0 +1,95 @@
+import xml.etree.ElementTree as ET
+
+from ..models.rte_xdm import Rte, RteBswEventToTaskMapping, RteBswEventToTaskMappingV3, RteBswEventToTaskMappingV4, RteBswModuleInstance, RteEventToTaskMapping, RteEventToTaskMappingV3, RteEventToTaskMappingV4, RteSwComponentInstance
+from ..models.eb_doc import EBModel
+from ..parser.eb_parser import AbstractEbModelParser
+
+class RteXdmParser(AbstractEbModelParser):
+    def __init__(self, ) -> None:
+        super().__init__()
+        self.rte = None
+
+    def parse(self, element: ET.Element, doc: EBModel):
+        if self.get_component_name(element) != "Rte":
+            raise ValueError("Invalid <%s> xdm file" % "Rte")
+        
+        rte = doc.getRte()
+        self.read_version(element, rte)
+
+        self.logger.info("Parse Rte ARVersion:<%s> SwVersion:<%s>" % 
+                         (rte.getArVersion().getVersion(), rte.getSwVersion().getVersion()))
+        
+        self.rte = rte
+
+        self.read_rte_bsw_module_instances(element, rte)
+        self.read_rte_sw_component_instances(element, rte)
+
+        
+
+    def read_rte_bsw_module_instance_event_to_task_mappings(self, element: ET.Element, instance: RteBswModuleInstance):
+        for ctr_tag in self.find_ctr_tag_list(element, "RteBswEventToTaskMapping"):
+            self.logger.debug("Read RteBswEventToTaskMapping <%s>" % ctr_tag.attrib['name'])
+
+            if self.rte.getArVersion().getMajorVersion() >= 4:
+                mapping = RteBswEventToTaskMappingV4(instance, ctr_tag.attrib['name'])
+            else:
+                mapping = RteBswEventToTaskMappingV3(instance, ctr_tag.attrib['name'])
+
+            mapping.setRteBswActivationOffset(self.read_optional_value(ctr_tag, "RteBswActivationOffset")) \
+                .setRteBswEventPeriod(self.read_optional_value(ctr_tag, "RteBswPeriod")) \
+                .setRteBswPositionInTask(self.read_optional_value(ctr_tag, "RteBswPositionInTask")) \
+                .setRteBswServerQueueLength(self.read_optional_value(ctr_tag, "RteBswServerQueueLength")) 
+            
+            if isinstance(mapping, RteBswEventToTaskMappingV4):
+                for resource_ref in self.read_ref_value_list(ctr_tag, "RteBswEventRef"):
+                    mapping.addRteBswEventRef(resource_ref)
+            elif isinstance(mapping, RteBswEventToTaskMappingV3):
+                mapping.setRteBswEventRef(self.read_ref_value(ctr_tag, "RteBswEventRef"))
+
+            mapping.setRteBswMappedToTaskRef(self.read_optional_ref_value(ctr_tag, "RteBswMappedToTaskRef"))
+            instance.addRteBswEventToTaskMapping(mapping)
+        
+    def read_rte_bsw_module_instances(self, element: ET.Element, rte: Rte):
+        for ctr_tag in self.find_ctr_tag_list(element, 'RteBswModuleInstance'):
+            self.logger.debug("Read RteBswModuleInstance <%s>" % ctr_tag.attrib['name'])
+
+            instance = RteBswModuleInstance(rte, ctr_tag.attrib['name'])
+            instance.setRteBswImplementationRef(self.read_ref_value(ctr_tag, "RteBswImplementationRef")) \
+                .setRteMappedToOsApplicationRef(self.read_optional_ref_value(ctr_tag, "RteMappedToOsApplicationRef"))
+
+            self.read_rte_bsw_module_instance_event_to_task_mappings(ctr_tag, instance)
+            rte.addRteBswModuleInstance(instance)
+
+    def read_rte_sw_component_instance_event_to_task_mappings(self, element: ET.Element, instance: RteSwComponentInstance):
+        for ctr_tag in self.find_ctr_tag_list(element, "RteEventToTaskMapping"):
+            
+            if self.rte.getArVersion().getMajorVersion() >= 4:
+                mapping = RteEventToTaskMappingV4(instance, ctr_tag.attrib['name'])
+            else:
+                mapping = RteEventToTaskMappingV3(instance, ctr_tag.attrib['name'])
+
+            mapping.setRteActivationOffset(self.read_optional_value(ctr_tag, "RteActivationOffset")) \
+                .setRtePeriod(self.read_optional_value(ctr_tag, "RtePeriod")) \
+                .setRtePositionInTask(self.read_optional_value(ctr_tag, "RtePositionInTask")) \
+                .setRteServerQueueLength(self.read_optional_value(ctr_tag, "RteServerQueueLength")) 
+            
+            if isinstance(mapping, RteEventToTaskMappingV4):
+                for resource_ref in self.read_ref_value_list(ctr_tag, "RteEventRef"):
+                    mapping.addRteEventRef(resource_ref)
+            elif isinstance(mapping, RteEventToTaskMappingV3):
+                mapping.setRteEventRef(self.read_ref_value(ctr_tag, "RteEventRef"))
+
+            mapping.setRteMappedToTaskRef(self.read_optional_ref_value(ctr_tag, "RteMappedToTaskRef"))
+            
+            instance.addRteEventToTaskMapping(mapping)
+
+    def read_rte_sw_component_instances(self, element: ET.Element, rte: Rte):
+        for ctr_tag in self.find_ctr_tag_list(element, 'RteSwComponentInstance'):
+            self.logger.debug("Read RteSwComponentInstance <%s>" % ctr_tag.attrib['name'])
+
+            instance = RteSwComponentInstance(rte, ctr_tag.attrib['name'])
+            instance.setMappedToOsApplicationRef(self.read_optional_ref_value(ctr_tag, "MappedToOsApplicationRef")) \
+                .setRteSoftwareComponentInstanceRef(self.read_optional_ref_value(ctr_tag, "RteSoftwareComponentInstanceRef"))
+            
+            self.read_rte_sw_component_instance_event_to_task_mappings(ctr_tag, instance)
+            rte.addRteSwComponentInstance(instance)

eb_model/reporter/excel_reporter/abstract.py

@@ -1,42 +1,42 @@
 import logging
 from openpyxl import Workbook
+from openpyxl.cell import Cell
+from openpyxl.styles import Alignment
 from openpyxl.worksheet.worksheet import Worksheet
 
 class ExcelReporter:
     def __init__(self) -> None:
         self.wb = Workbook()
-        self._logger = logging.getLogger()
+        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: Worksheet):
         dims = {}
         for row in worksheet.rows:
             for cell in row:
                 if cell.value:
+                    alignment = cell.alignment      # type: Alignment
+                    if (alignment.wrapText == True):
+                        continue
                     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
+            #worksheet.column_dimensions[col].width = (value + 2) + 2
+            worksheet.column_dimensions[col].width = (value + 2)
 
     def write_title_row(self, sheet: Worksheet, 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) 
+    def write_cell(self, sheet, row, column, value, format = None) -> Cell:
+        cell = sheet.cell(row = row, column=column)         # type: Cell
         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']
+        return cell
 
     def save(self, name: str):
         self.wb.save(name)