py-eb-model 1.1.5__py3-none-any.whl → 1.1.7__py3-none-any.whl

eb_model/parser/eb_parser.py

@@ -8,14 +8,15 @@ from typing import List
 from ..models.eb_doc import EBModel, PreferenceModel
 from ..models.abstract import EcucRefType, Module
 
-class AbstractEbModelParser(metaclass = ABCMeta):
+
+class AbstractEbModelParser(metaclass=ABCMeta):
 
     def __init__(self) -> None:
         self.nsmap = {}
 
         self.logger = logging.getLogger()
 
-        if type(self) == "AbstractEBModelParser":
+        if type(self) is AbstractEbModelParser:
             raise ValueError("Abstract EBModelParser cannot be initialized.")
         
     def validate_root(self, element: ET.Element):
@@ -39,7 +40,6 @@ class AbstractEbModelParser(metaclass = ABCMeta):
         '''
             Internal function and please call _read_ref_value instead of it
         '''
-        #match = re.match(r'ASPath.*\/(.*)', value)
         match = re.match(r'ASPath:(.*)', value)
         if (match):
             return match.group(1)
@@ -60,18 +60,20 @@ class AbstractEbModelParser(metaclass = ABCMeta):
 
     def read_value(self, parent: ET.Element, name: str) -> str:
         tag = parent.find(".//d:var[@name='%s']" % name, self.nsmap)
-        if tag == None:
+        if tag is None:
             raise KeyError("XPath d:var[@name='%s'] is invalid" % name)
         return self._convert_value(tag)
 
-    def read_optional_value(self, parent: ET.Element, name: str, default_value = None) -> str:
+    def read_optional_value(self, parent: ET.Element, name: str, default_value=None) -> str:
         tag = parent.find(".//d:var[@name='%s']" % name, self.nsmap)
         if tag is None:
             return default_value
-        if ('value' not in tag.attrib):
+        if 'value' not in tag.attrib:
             return default_value
         enable = self.read_attrib(tag, 'ENABLE')
-        if (enable == 'false'):
+        if enable is None:
+            return default_value
+        if enable.upper() == "FALSE":
             return default_value
         return self._convert_value(tag)
 
@@ -85,14 +87,19 @@ class AbstractEbModelParser(metaclass = ABCMeta):
     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']))
+            raise KeyError("XPath d:ref[@name='%s'] is invalid" % name)
+        if 'value' in tag.attrib:
+            return EcucRefType(self.read_ref_raw_value(tag.attrib['value']))
+        return None
 
     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'):
+        if enable is None:
+            return None
+        if enable.upper() == "FALSE":
             return None
+        
         return EcucRefType(self.read_ref_raw_value(tag.attrib['value']))
 
     def read_ref_value_list(self, parent: ET.Element, name: str) -> List[EcucRefType]:
@@ -100,7 +107,7 @@ class AbstractEbModelParser(metaclass = ABCMeta):
         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.nsmap)
     
@@ -109,26 +116,26 @@ class AbstractEbModelParser(metaclass = ABCMeta):
 
     def find_ctr_tag(self, parent: ET.Element, name: str) -> ET.Element:
         '''
-        Read the child ctr tag. 
+        Read the child ctr tag.
         '''
         tag = parent.find(".//d:ctr[@name='%s']" % name, self.nsmap)
         if tag is None:
             return None
         enable = self.read_attrib(tag, 'ENABLE')
-        # ctr has the value if 
+        # ctr has the value if
         #   1. enable attribute do not exist
         #   2. enable attribute is not false
-        if enable is not None and enable == "false":    
+        if enable is not None and enable.upper() == "FALSE":
             return None
         return tag
 
-    def create_ctr_tag(self, name: str, type: str)-> ET.Element:
+    def create_ctr_tag(self, name: str, type: str) -> ET.Element:
         ctr_tag = ET.Element("d:ctr")
         ctr_tag.attrib['name'] = name
         ctr_tag.attrib['type'] = type
         return ctr_tag
 
-    def create_ref_tag(self, name:str, type: str, value = "")-> ET.Element:
+    def create_ref_tag(self, name: str, type: str, value: str = "") -> ET.Element:
         ref_tag = ET.Element("d:ref")
         ref_tag.attrib['name'] = name
         ref_tag.attrib['type'] = type
@@ -136,20 +143,20 @@ class AbstractEbModelParser(metaclass = ABCMeta):
             ref_tag.attrib['value'] = "ASPath:%s" % value
         return ref_tag
 
-    def create_choice_tag(self, name:str, type:str, value: str)-> ET.Element:
+    def create_choice_tag(self, name: str, type: str, value: str) -> ET.Element:
         choice_tag = ET.Element("d:chc")
         choice_tag.attrib['name'] = name
         choice_tag.attrib['type'] = type
         choice_tag.attrib['value'] = value
         return choice_tag
 
-    def create_attrib_tag(self, name:str, value: str) -> ET.Element:
+    def create_attrib_tag(self, name: str, value: str) -> ET.Element:
         attrib_tag = ET.Element("a:a")
         attrib_tag.attrib['name'] = name
         attrib_tag.attrib['value'] = value
         return attrib_tag
 
-    def create_ref_lst_tag(self, name:str, type:str = "", ref_list: List[str] = []) -> ET.Element:
+    def create_ref_lst_tag(self, name: str, type: str = "", ref_list: List[str] = []) -> ET.Element:
         lst_tag = ET.Element("d:lst")
         lst_tag.attrib['name'] = name
         for ref in ref_list:
@@ -167,7 +174,7 @@ class AbstractEbModelParser(metaclass = ABCMeta):
         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.nsmap)
+        attrib_tag = parent.find("a:a[@name='%s']" % name, self.nsmap)
         if attrib_tag is None:
             return None
         return attrib_tag.attrib['value']
@@ -175,6 +182,9 @@ class AbstractEbModelParser(metaclass = ABCMeta):
     def read_namespaces(self, xdm: str):
         self.nsmap = dict([node for _, node in ET.iterparse(xdm, events=['start-ns'])])
 
+    # def set_namespace(self, key: str, value: str):
+    #    self.nsmap[key] = value
+
     def parse(self, element: ET.Element, doc: EBModel):
         pass
 
@@ -197,4 +207,4 @@ class AbstractEbModelParser(metaclass = ABCMeta):
 
     def parse_preference_xdm(self, filename: str, doc: EBModel):
         root_tag = self.load_xdm(filename)
-        self.parse_preference(root_tag, doc)
+        self.parse_preference(root_tag, doc)

eb_model/parser/nvm_xdm_parser.py

@@ -0,0 +1,44 @@
+import xml.etree.ElementTree as ET
+
+from ..models.nvm_xdm import NvM, NvMBlockDescriptor
+from ..models.eb_doc import EBModel
+from ..parser.eb_parser import AbstractEbModelParser
+
+
+class NvMXdmParser(AbstractEbModelParser):
+    def __init__(self, ) -> None:
+        super().__init__()
+
+        self.nvm = None
+
+    def parse(self, element: ET.Element, doc: EBModel):
+        if self.get_component_name(element) != "NvM":
+            raise ValueError("Invalid <%s> xdm file" % "NvM")
+
+        nvm = doc.getNvM()
+
+        self.read_version(element, nvm)
+
+        self.logger.info("Parse NvM ARVersion:<%s> SwVersion:<%s>" % (nvm.getArVersion().getVersion(), nvm.getSwVersion().getVersion()))
+
+        self.nvm = nvm
+
+        self.read_nvm_block_descriptors(element, nvm)
+
+    def read_nvm_block_descriptors(self, element: ET.Element, nvm: NvM):
+        for ctr_tag in self.find_ctr_tag_list(element, "NvMBlockDescriptor"):
+            nvm_block = NvMBlockDescriptor(nvm, ctr_tag.attrib["name"])
+            nvm_block.setNvMBlockCrcType(self.read_optional_value(ctr_tag, "NvMBlockCrcType")) \
+                     .setNvMBlockEcucPartitionRef(self.read_ref_value(ctr_tag, "NvMBlockEcucPartitionRef")) \
+                     .setNvMNvramBlockIdentifier(self.read_value(ctr_tag, "NvMNvramBlockIdentifier")) \
+                     .setNvMRamBlockDataAddress(self.read_optional_value(ctr_tag, "NvMRamBlockDataAddress")) \
+                     .setNvMRomBlockDataAddress(self.read_optional_value(ctr_tag, "NvMRomBlockDataAddress")) \
+                     .setNvMRomBlockNum(self.read_value(ctr_tag, "NvMRomBlockNum")) \
+                     .setNvMBlockManagementType(self.read_value(ctr_tag, "NvMBlockManagementType")) \
+                     .setNvMNvBlockLength(self.read_value(ctr_tag, "NvMNvBlockLength")) \
+                     .setNvMNvBlockNum(self.read_value(ctr_tag, "NvMNvBlockNum")) \
+                     .setNvMSelectBlockForReadAll(self.read_value(ctr_tag, "NvMSelectBlockForReadAll")) \
+                     .setNvMSelectBlockForWriteAll(self.read_value(ctr_tag, "NvMSelectBlockForWriteAll")) 
+
+            nvm.addNvMBlockDescriptor(nvm_block)
+                     

eb_model/parser/os_xdm_parser.py

@@ -1,8 +1,9 @@
 import xml.etree.ElementTree as ET
 from ..models.eb_doc import EBModel
-from ..models.os_xdm import Os, OsAlarm, OsAlarmActivateTask, OsAlarmCallback, OsAlarmIncrementCounter, OsAlarmSetEvent, OsCounter, OsScheduleTable
+from ..models.os_xdm import Os, OsAlarm, OsAlarmActivateTask, OsAlarmCallback, OsAlarmIncrementCounter, OsAlarmSetEvent, OsCounter, OsResource
+from ..models.os_xdm import OsScheduleTable
 from ..models.os_xdm import OsTask, OsIsr, OsApplication, OsScheduleTableEventSetting, OsScheduleTableExpiryPoint, OsScheduleTableTaskActivation
-from ..models.os_xdm import OsScheduleTblAdjustableExpPoint, OsTaskAutostart
+from ..models.os_xdm import OsScheduleTblAdjustableExpPoint, OsTaskAutostart, OsMicrokernel, MkMemoryProtection, MkMemoryRegion
 from ..parser.eb_parser import AbstractEbModelParser
 
 
@@ -20,7 +21,7 @@ class OsXdmParser(AbstractEbModelParser):
 
         self.read_version(element, os)
 
-        self.logger.info("Parse Rte ARVersion:<%s> SwVersion:<%s>" % (os.getArVersion().getVersion(), os.getSwVersion().getVersion()))
+        self.logger.info("Parse Os ARVersion:<%s> SwVersion:<%s>" % (os.getArVersion().getVersion(), os.getSwVersion().getVersion()))
 
         self.os = os
 
@@ -30,6 +31,8 @@ class OsXdmParser(AbstractEbModelParser):
         self.read_os_schedule_tables(element, os)
         self.read_os_counters(element, os)
         self.read_os_applications(element, os)
+        self.read_os_resources(element, os)
+        self.read_os_microkernel(element, os)
 
     def read_os_task_autostart(self, element: ET.Element, os_task: OsTask):
         ctr_tag = self.find_ctr_tag(element, "OsTaskAutostart")
@@ -64,11 +67,21 @@ class OsXdmParser(AbstractEbModelParser):
                 .setOsStacksize(int(self.read_value(ctr_tag, "OsStacksize"))) \
                 .setOsIsrPriority(self.read_optional_value(ctr_tag, "OsIsrPriority"))
             
-            # patch for the infineon Aurix
+            # Infineon Aurix Tricore
             os_isr.setOsIsrPriority(self.read_optional_value(ctr_tag, "OsTricoreIrqLevel"))
-            # patch for the ARM
+            os_isr.setOsIsrVector(self.read_optional_value(ctr_tag, "OsTricoreVector"))
+            os_isr.setOsTricoreIrqLevel(self.read_optional_value(ctr_tag, "OsTricoreIrqLevel"))
+            os_isr.setOsTricoreVector(self.read_optional_value(ctr_tag, "OsTricoreVector"))
+            
+            # ARM Core
             os_isr.setOsIsrPriority(self.read_optional_value(ctr_tag, "OsARMIrqLevel"))
             os_isr.setOsIsrVector(self.read_optional_value(ctr_tag, "OsARMVector"))
+            os_isr.setOsARMIrqLevel(self.read_optional_value(ctr_tag, "OsARMIrqLevel"))
+            os_isr.setOsARMVector(self.read_optional_value(ctr_tag, "OsARMVector"))
+
+            # EB Safety OS
+            for ref in self.read_ref_value_list(ctr_tag, "OsIsrMkMemoryRegionRef"):
+                os_isr.addOsIsrMkMemoryRegionRef(ref)
 
             self.logger.debug("Read OsIsr <%s>" % os_isr.getName())
             os.addOsIsr(os_isr)
@@ -184,3 +197,46 @@ class OsXdmParser(AbstractEbModelParser):
 
             self.logger.debug("Read OsApplication <%s>" % os_app.getName())
             os.addOsApplication(os_app)
+
+    def read_os_resources(self, element: ET.Element, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(element, "OsResource"):
+            os_res = OsResource(os, ctr_tag.attrib["name"])
+            os_res.setImporterInfo(self.read_attrib(ctr_tag, "IMPORTER_INFO"))
+            os_res.setOsResourceProperty(self.read_value(ctr_tag, "OsResourceProperty"))
+
+            for ref in self.read_ref_value_list(ctr_tag, "OsResourceAccessingApplication"):
+                os_res.addOsResourceAccessingApplicationRefs(ref)
+
+            os.addOsResource(os_res)
+
+    def read_mk_memory_regions(self, element: ET.Element, protection: MkMemoryProtection):
+        for ctr_tag in self.find_ctr_tag_list(element, "MkMemoryRegion"):
+            # self.logger.info("Read MkMemoryRegion %s" % ctr_tag.attrib["name"])
+            region = MkMemoryRegion(protection, ctr_tag.attrib["name"])
+            region.setMkMemoryRegionFlags(self.read_value(ctr_tag, "MkMemoryRegionFlags"))
+            region.setMkMemoryRegionInitialize(self.read_value(ctr_tag, "MkMemoryRegionInitialize"))
+            region.setMkMemoryRegionGlobal(self.read_value(ctr_tag, "MkMemoryRegionGlobal"))
+            region.setMkMemoryRegionInitThreadAccess(self.read_value(ctr_tag, "MkMemoryRegionInitThreadAccess"))
+            region.setMkMemoryRegionIdleThreadAccess(self.read_value(ctr_tag, "MkMemoryRegionIdleThreadAccess"))
+            region.setMkMemoryRegionOsThreadAccess(self.read_value(ctr_tag, "MkMemoryRegionOsThreadAccess"))
+            region.setMkMemoryRegionErrorHookAccess(self.read_value(ctr_tag, "MkMemoryRegionErrorHookAccess"))
+            region.setMkMemoryRegionProtHookAccess(self.read_value(ctr_tag, "MkMemoryRegionProtHookAccess"))
+            region.setMkMemoryRegionShutdownHookAccess(self.read_value(ctr_tag, "MkMemoryRegionShutdownHookAccess"))
+            region.setMkMemoryRegionShutdownAccess(self.read_value(ctr_tag, "MkMemoryRegionShutdownAccess"))
+            region.setMkMemoryRegionInitializePerCore(self.read_value(ctr_tag, "MkMemoryRegionInitializePerCore"))
+            protection.addMkMemoryRegion(region)
+
+    def read_mk_memory_protection(self, element: ET.Element, kernel: OsMicrokernel):
+        ctr_tag = self.find_ctr_tag(element, "MkMemoryProtection")
+        if ctr_tag is not None:
+            # self.logger.info("Read MkMemoryProtection")
+            protection = MkMemoryProtection(kernel, ctr_tag.attrib["name"])
+            self.read_mk_memory_regions(ctr_tag, protection)
+            kernel.setMkMemoryProtection(protection)
+
+    def read_os_microkernel(self, element: ET.Element, os: Os):
+        ctr_tag = self.find_ctr_tag(element, "OsMicrokernel")
+        if ctr_tag is not None:
+            kernel = OsMicrokernel(os, ctr_tag.attrib["name"])
+            self.read_mk_memory_protection(ctr_tag, kernel)
+            os.setOsMicrokernel(kernel)

eb_model/parser/rte_xdm_parser.py

@@ -1,9 +1,11 @@
 import xml.etree.ElementTree as ET
 
-from ..models.rte_xdm import Rte, RteBswEventToTaskMapping, RteBswEventToTaskMappingV3, RteBswEventToTaskMappingV4, RteBswModuleInstance, RteEventToTaskMapping, RteEventToTaskMappingV3, RteEventToTaskMappingV4, RteSwComponentInstance
+from ..models.rte_xdm import Rte, RteBswEventToTaskMapping, RteBswEventToTaskMappingV3, RteBswEventToTaskMappingV4, RteBswModuleInstance
+from ..models.rte_xdm import 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__()
@@ -16,16 +18,12 @@ class RteXdmParser(AbstractEbModelParser):
         rte = doc.getRte()
         self.read_version(element, rte)
 
-        self.logger.info("Parse Rte ARVersion:<%s> SwVersion:<%s>" % 
-                         (rte.getArVersion().getVersion(), rte.getSwVersion().getVersion()))
-        
+        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'])
@@ -38,7 +36,7 @@ class RteXdmParser(AbstractEbModelParser):
             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")) 
+                .setRteBswServerQueueLength(self.read_optional_value(ctr_tag, "RteBswServerQueueLength"))
             
             if isinstance(mapping, RteBswEventToTaskMappingV4):
                 for resource_ref in self.read_ref_value_list(ctr_tag, "RteBswEventRef"):
@@ -56,7 +54,7 @@ class RteXdmParser(AbstractEbModelParser):
             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)
 
@@ -71,7 +69,7 @@ class RteXdmParser(AbstractEbModelParser):
             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")) 
+                .setRteServerQueueLength(self.read_optional_value(ctr_tag, "RteServerQueueLength"))
             
             if isinstance(mapping, RteEventToTaskMappingV4):
                 for resource_ref in self.read_ref_value_list(ctr_tag, "RteEventRef"):
@@ -80,6 +78,8 @@ class RteXdmParser(AbstractEbModelParser):
                 mapping.setRteEventRef(self.read_ref_value(ctr_tag, "RteEventRef"))
 
             mapping.setRteMappedToTaskRef(self.read_optional_ref_value(ctr_tag, "RteMappedToTaskRef"))
+
+            self.logger.debug("Rte Event %s" % mapping.getRteEventRef().getShortName())
             
             instance.addRteEventToTaskMapping(mapping)
 
@@ -89,7 +89,7 @@ class RteXdmParser(AbstractEbModelParser):
 
             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"))
+                    .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)
+            rte.addRteSwComponentInstance(instance)

eb_model/reporter/__init__.py

@@ -1 +1,2 @@
-from .excel_reporter.os_xdm import *
+from .excel_reporter.os_xdm import *
+from .excel_reporter.nvm_xdm import *

eb_model/reporter/excel_reporter/abstract.py

@@ -1,43 +1,51 @@
 import logging
 from openpyxl import Workbook
 from openpyxl.cell import Cell
-from openpyxl.styles import Alignment
 from openpyxl.worksheet.worksheet import Worksheet
+from openpyxl.styles import Alignment
+
 
 class ExcelReporter:
     def __init__(self) -> None:
         self.wb = Workbook()
         self.logger = logging.getLogger()
     
-    def auto_width(self, worksheet: Worksheet):
+    def auto_width(self, worksheet, customized={}):
         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)
+            self.logger.debug("Sheet:%s , column: %s, width: %d" % (str(worksheet), col, value))
+            if col in customized:
+                if customized[col] != 0:
+                    worksheet.column_dimensions[col].width = customized[col]
+            else:
+                worksheet.column_dimensions[col].width = value + 4
 
     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]
+            cell.alignment = Alignment(horizontal="center")
 
-    def write_cell(self, sheet, row, column, value, format = None) -> Cell:
-        cell = sheet.cell(row = row, column=column)         # type: Cell
+    def write_cell(self, sheet: Worksheet, row: int, column: int, value, format=None) -> Cell:
+        cell = sheet.cell(row=row, column=column)         # type: Cell
         cell.value = value
-        if (format != None):
+        if (format is not None):
             if ('alignment' in format):
                 cell.alignment = format['alignment']
             if ('number_format' in format):
                 cell.number_format = format['number_format']
         return cell
+    
+    def format_boolean(self, value: bool) -> str:
+        if value is True:
+            return "Y"
+        else:
+            return "N"
 
     def save(self, name: str):
         self.wb.save(name)
-

eb_model/reporter/excel_reporter/nvm_xdm.py

@@ -0,0 +1,40 @@
+from ...models.eb_doc import EBModel
+from ...reporter.excel_reporter.abstract import ExcelReporter
+
+
+class NvMXdmXlsWriter(ExcelReporter):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def write_nvm_block_descriptors(self, doc: EBModel):
+        sheet = self.wb.create_sheet("NvMBlock", 0)
+
+        title_row = [
+            "BlockId", "Name", "NvMBlockEcucPartitionRef", "NvMRamBlockDataAddress", "NvMRomBlockDataAddress",
+            "NvMBlockManagementType", "NvMNvBlockLength", "NvMNvBlockNum", "NvMSelectBlockForReadAll", "NvMSelectBlockForWriteAll"]
+        self.write_title_row(sheet, title_row)
+
+        row = 2
+        for nvm_block in doc.getNvM().getNvMBlockDescriptorList():
+            self.write_cell(sheet, row, 1, nvm_block.getNvMNvramBlockIdentifier())
+            self.write_cell(sheet, row, 2, nvm_block.getName())
+            self.write_cell(sheet, row, 3, nvm_block.getNvMBlockEcucPartitionRef())
+            self.write_cell(sheet, row, 4, nvm_block.getNvMRamBlockDataAddress())
+            self.write_cell(sheet, row, 5, nvm_block.getNvMRomBlockDataAddress())
+            self.write_cell(sheet, row, 6, nvm_block.getNvMBlockManagementType())
+            self.write_cell(sheet, row, 7, nvm_block.getNvMNvBlockLength())
+            self.write_cell(sheet, row, 8, nvm_block.getNvMNvBlockNum())
+
+            
+            row += 1
+
+            self.logger.debug("Write NvM Block <%s>" % nvm_block.getName())
+
+        self.auto_width(sheet)
+
+    def write(self, filename, doc: EBModel, options):
+        self.logger.info("Writing <%s>" % filename)
+
+        self.write_nvm_block_descriptors(doc)
+
+        self.save(filename)