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

eb_model/cli/nvm_xdm_2_xls_cli.py

@@ -0,0 +1,63 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+
+from ..parser import NvMXdmParser
+from ..models import EBModel
+from ..reporter import NvMXdmXlsWriter
+
+
+def main():
+    version = pkg_resources.require("py_eb_model")[0].version
+
+    ap = argparse.ArgumentParser()
+    ap.description = "Version: %s" % version
+    ap.add_argument("-v", "--verbose", required=False, help="Print debug information.", action="store_true")
+    ap.add_argument("--log", required=False, help="Specify the log file name.")
+    ap.add_argument("INPUT", help="The path of NvM.xdm.")
+    ap.add_argument("OUTPUT", help="The path of excel file.")
+
+    args = ap.parse_args()
+
+    logger = logging.getLogger()
+    
+    formatter = logging.Formatter('[%(levelname)s] : %(message)s')
+
+    stdout_handler = logging.StreamHandler(sys.stderr)
+    stdout_handler.setFormatter(formatter)
+
+    if args.log:
+        if os.path.exists(args.log):
+            os.remove(args.log)
+
+        file_handler = logging.FileHandler(args.log)
+        file_handler.setFormatter(formatter)
+        file_handler.setLevel(logging.DEBUG)
+
+    logger.setLevel(logging.DEBUG)
+
+    if args.verbose:
+        stdout_handler.setLevel(logging.DEBUG)
+    else:
+        stdout_handler.setLevel(logging.INFO)
+
+    if args.log:
+        logger.addHandler(file_handler)
+    logger.addHandler(stdout_handler)
+
+    try:
+        doc = EBModel.getInstance()
+        
+        parser = NvMXdmParser()
+        parser.parse_xdm(args.INPUT, doc)
+
+        options = {}
+
+        writer = NvMXdmXlsWriter()
+        writer.write(args.OUTPUT, doc, options)
+        
+    except Exception as e:
+        logger.error(e)
+        raise e

eb_model/models/abstract.py

@@ -8,7 +8,7 @@ class EcucObject(metaclass=ABCMeta):
         if type(self) is EcucObject:
             raise ValueError("Abstract EcucObject cannot be initialized.")
         
-        self.name = name
+        self.name = name                    # type: str
         self.parent = parent                # type: EcucObject
 
         if isinstance(parent, EcucParamConfContainerDef):
@@ -30,6 +30,11 @@ class EcucObject(metaclass=ABCMeta):
 
     def getFullName(self) -> str:
         return self.parent.getFullName() + "/" + self.name
+    
+
+class EcucEnumerationParamDef(EcucObject):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
 
 
 class EcucParamConfContainerDef(EcucObject):

eb_model/models/eb_doc.py

@@ -1,7 +1,8 @@
-from .importer_xdm import SystemDescriptionImporter
-from .rte_xdm import Rte
-from .os_xdm import Os
-from .abstract import EcucParamConfContainerDef, EcucObject
+from ..models.nvm_xdm import NvM
+from ..models.importer_xdm import SystemDescriptionImporter
+from ..models.rte_xdm import Rte
+from ..models.os_xdm import Os
+from ..models.abstract import EcucParamConfContainerDef, EcucObject
 
 
 class AbstractModel(EcucParamConfContainerDef):
@@ -44,6 +45,9 @@ class EBModel(AbstractModel):
         return self.find_object(referred_name, EBModel.getInstance())
 
     def getOs(self) -> Os:
+        '''
+            get the Os Container
+        '''
         container = EcucParamConfContainerDef(self, "Os")
         Os(container)
         return self.find("/Os/Os")
@@ -52,6 +56,11 @@ class EBModel(AbstractModel):
         container = EcucParamConfContainerDef(self, "Rte")
         Rte(container)
         return self.find("/Rte/Rte")
+    
+    def getNvM(self) -> NvM:
+        container = EcucParamConfContainerDef(self, "NvM")
+        NvM(container)
+        return self.find("/NvM/NvM")
 
 
 class PreferenceModel(AbstractModel):

eb_model/models/nvm_xdm.py

@@ -0,0 +1,347 @@
+from typing import List
+from ..models.abstract import EcucParamConfContainerDef, Module, EcucRefType
+
+
+class NvM(Module):
+    def __init__(self, parent):
+        super().__init__(parent, "NvM")
+
+        self.NvMBlockDescriptors = []                       # type: List[NvMBlockDescriptor]
+
+    def getNvMBlockDescriptorList(self):
+        return self.NvMBlockDescriptors
+
+    def addNvMBlockDescriptor(self, value):
+        if value is not None:
+            self.NvMBlockDescriptors.append(value)
+        return self
+
+
+class NvMBlockDescriptor(EcucParamConfContainerDef):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.nvMBlockCrcType = None                         # type: str # optional
+        self.nvMBlockHeaderInclude = None                   # type: int # optional
+        self.nvMBlockJobPriority = None                     # type: str # required
+        self.nvMBlockManagementType = None                  # type: str # required
+        self.nvMBlockUseAutoValidation = None               # required
+        self.nvMBlockUseCompression = None                  # required
+        self.nvMBlockUseCrc = None                          # required
+        self.nvMBlockUseCRCCompMechanism = None             # required
+        self.NvMBlockUsePort = None                         # required
+        self.nvMBlockUseSetRamBlockStatus = None            # required
+        self.nvMBlockUseSyncMechanism = None                # required
+        self.nvMBlockWriteProt = None                       # required
+        self.nvMBswMBlockStatusInformation = None           # required
+        self.nvMCalcRamBlockCrc = None                      # optional
+        self.nvMMaxNumOfReadRetries = None                  # required
+        self.nvMMaxNumOfWriteRetries = None                 # required
+        self.nvMNvBlockBaseNumber = None                    # required
+        self.nvMNvBlockLength = None                        # type: int # required
+        self.nvMNvBlockNum = None                           # type: int # required
+        self.nvMNvramBlockIdentifier = None                 # required
+        self.nvMNvramDeviceId = None                        # required
+        self.nvMRamBlockDataAddress = None                  # optional
+        self.nvMReadRamBlockFromNvCallback = None           # optional
+        self.nvMResistantToChangedSw = None                 # required
+        self.nvMRomBlockDataAddress = None                  # optional
+        self.nvMRomBlockNum = None                          # required
+        self.nvMSelectBlockForFirstInitAll = None           # optional
+        self.nvMSelectBlockForReadAll = None                # required
+        self.nvMSelectBlockForWriteAll = None               # required
+        self.nvMStaticBlockIDCheck = None                   # required
+        self.nvMWriteBlockOnce = None                       # required
+        self.nvMWriteRamBlockToNvCallback = None            # optional
+        self.nvMWriteVerification = None                    # required
+        self.nvMWriteVerificationDataSize = None            # required
+        self.nvMBlockCipheringRef = None                    # optional
+        self.nvMBlockEcucPartitionRef = None                # type: EcucRefType # required
+
+    def getNvMBlockCrcType(self):
+        return self.nvMBlockCrcType
+
+    def setNvMBlockCrcType(self, value):
+        if value is not None:
+            self.nvMBlockCrcType = value
+        return self
+
+    def getNvMBlockHeaderInclude(self):
+        return self.nvMBlockHeaderInclude
+
+    def setNvMBlockHeaderInclude(self, value):
+        if value is not None:
+            self.nvMBlockHeaderInclude = value
+        return self
+
+    def getNvMBlockJobPriority(self):
+        return self.nvMBlockJobPriority
+
+    def setNvMBlockJobPriority(self, value):
+        if value is not None:
+            self.nvMBlockJobPriority = value
+        return self
+
+    def getNvMBlockManagementType(self):
+        return self.nvMBlockManagementType
+
+    def setNvMBlockManagementType(self, value):
+        if value is not None:
+            self.nvMBlockManagementType = value
+        return self
+
+    def getNvMBlockUseAutoValidation(self):
+        return self.nvMBlockUseAutoValidation
+
+    def setNvMBlockUseAutoValidation(self, value):
+        if value is not None:
+            self.nvMBlockUseAutoValidation = value
+        return self
+
+    def getNvMBlockUseCompression(self):
+        return self.nvMBlockUseCompression
+
+    def setNvMBlockUseCompression(self, value):
+        if value is not None:
+            self.nvMBlockUseCompression = value
+        return self
+
+    def getNvMBlockUseCrc(self):
+        return self.nvMBlockUseCrc
+
+    def setNvMBlockUseCrc(self, value):
+        if value is not None:
+            self.nvMBlockUseCrc = value
+        return self
+
+    def getNvMBlockUseCRCCompMechanism(self):
+        return self.nvMBlockUseCRCCompMechanism
+
+    def setNvMBlockUseCRCCompMechanism(self, value):
+        if value is not None:
+            self.nvMBlockUseCRCCompMechanism = value
+        return self
+
+    def getNvMBlockUsePort(self):
+        return self.NvMBlockUsePort
+
+    def setNvMBlockUsePort(self, value):
+        if value is not None:
+            self.NvMBlockUsePort = value
+        return self
+
+    def getNvMBlockUseSetRamBlockStatus(self):
+        return self.nvMBlockUseSetRamBlockStatus
+
+    def setNvMBlockUseSetRamBlockStatus(self, value):
+        if value is not None:
+            self.nvMBlockUseSetRamBlockStatus = value
+        return self
+
+    def getNvMBlockUseSyncMechanism(self):
+        return self.nvMBlockUseSyncMechanism
+
+    def setNvMBlockUseSyncMechanism(self, value):
+        if value is not None:
+            self.nvMBlockUseSyncMechanism = value
+        return self
+
+    def getNvMBlockWriteProt(self):
+        return self.nvMBlockWriteProt
+
+    def setNvMBlockWriteProt(self, value):
+        if value is not None:
+            self.nvMBlockWriteProt = value
+        return self
+
+    def getNvMBswMBlockStatusInformation(self):
+        return self.nvMBswMBlockStatusInformation
+
+    def setNvMBswMBlockStatusInformation(self, value):
+        if value is not None:
+            self.nvMBswMBlockStatusInformation = value
+        return self
+
+    def getNvMCalcRamBlockCrc(self):
+        return self.nvMCalcRamBlockCrc
+
+    def setNvMCalcRamBlockCrc(self, value):
+        if value is not None:
+            self.nvMCalcRamBlockCrc = value
+        return self
+
+    def getNvMMaxNumOfReadRetries(self):
+        return self.nvMMaxNumOfReadRetries
+
+    def setNvMMaxNumOfReadRetries(self, value):
+        if value is not None:
+            self.nvMMaxNumOfReadRetries = value
+        return self
+
+    def getNvMMaxNumOfWriteRetries(self):
+        return self.nvMMaxNumOfWriteRetries
+
+    def setNvMMaxNumOfWriteRetries(self, value):
+        if value is not None:
+            self.nvMMaxNumOfWriteRetries = value
+        return self
+
+    def getNvMNvBlockBaseNumber(self):
+        return self.nvMNvBlockBaseNumber
+
+    def setNvMNvBlockBaseNumber(self, value):
+        if value is not None:
+            self.nvMNvBlockBaseNumber = value
+        return self
+
+    def getNvMNvBlockLength(self):
+        return self.nvMNvBlockLength
+
+    def setNvMNvBlockLength(self, value):
+        if value is not None:
+            self.nvMNvBlockLength = value
+        return self
+
+    def getNvMNvBlockNum(self):
+        return self.nvMNvBlockNum
+
+    def setNvMNvBlockNum(self, value):
+        if value is not None:
+            self.nvMNvBlockNum = value
+        return self
+
+    def getNvMNvramBlockIdentifier(self):
+        return self.nvMNvramBlockIdentifier
+
+    def setNvMNvramBlockIdentifier(self, value):
+        if value is not None:
+            self.nvMNvramBlockIdentifier = value
+        return self
+
+    def getNvMNvramDeviceId(self):
+        return self.nvMNvramDeviceId
+
+    def setNvMNvramDeviceId(self, value):
+        if value is not None:
+            self.nvMNvramDeviceId = value
+        return self
+
+    def getNvMRamBlockDataAddress(self):
+        return self.nvMRamBlockDataAddress
+
+    def setNvMRamBlockDataAddress(self, value):
+        if value is not None:
+            self.nvMRamBlockDataAddress = value
+        return self
+
+    def getNvMReadRamBlockFromNvCallback(self):
+        return self.nvMReadRamBlockFromNvCallback
+
+    def setNvMReadRamBlockFromNvCallback(self, value):
+        if value is not None:
+            self.nvMReadRamBlockFromNvCallback = value
+        return self
+
+    def getNvMResistantToChangedSw(self):
+        return self.nvMResistantToChangedSw
+
+    def setNvMResistantToChangedSw(self, value):
+        if value is not None:
+            self.nvMResistantToChangedSw = value
+        return self
+
+    def getNvMRomBlockDataAddress(self):
+        return self.nvMRomBlockDataAddress
+
+    def setNvMRomBlockDataAddress(self, value):
+        if value is not None:
+            self.nvMRomBlockDataAddress = value
+        return self
+
+    def getNvMRomBlockNum(self):
+        return self.nvMRomBlockNum
+
+    def setNvMRomBlockNum(self, value):
+        if value is not None:
+            self.nvMRomBlockNum = value
+        return self
+
+    def getNvMSelectBlockForFirstInitAll(self):
+        return self.nvMSelectBlockForFirstInitAll
+
+    def setNvMSelectBlockForFirstInitAll(self, value):
+        if value is not None:
+            self.nvMSelectBlockForFirstInitAll = value
+        return self
+
+    def getNvMSelectBlockForReadAll(self):
+        return self.nvMSelectBlockForReadAll
+
+    def setNvMSelectBlockForReadAll(self, value):
+        if value is not None:
+            self.nvMSelectBlockForReadAll = value
+        return self
+
+    def getNvMSelectBlockForWriteAll(self):
+        return self.nvMSelectBlockForWriteAll
+
+    def setNvMSelectBlockForWriteAll(self, value):
+        if value is not None:
+            self.nvMSelectBlockForWriteAll = value
+        return self
+
+    def getNvMStaticBlockIDCheck(self):
+        return self.nvMStaticBlockIDCheck
+
+    def setNvMStaticBlockIDCheck(self, value):
+        if value is not None:
+            self.nvMStaticBlockIDCheck = value
+        return self
+
+    def getNvMWriteBlockOnce(self):
+        return self.nvMWriteBlockOnce
+
+    def setNvMWriteBlockOnce(self, value):
+        if value is not None:
+            self.nvMWriteBlockOnce = value
+        return self
+
+    def getNvMWriteRamBlockToNvCallback(self):
+        return self.nvMWriteRamBlockToNvCallback
+
+    def setNvMWriteRamBlockToNvCallback(self, value):
+        if value is not None:
+            self.nvMWriteRamBlockToNvCallback = value
+        return self
+
+    def getNvMWriteVerification(self):
+        return self.nvMWriteVerification
+
+    def setNvMWriteVerification(self, value):
+        if value is not None:
+            self.nvMWriteVerification = value
+        return self
+
+    def getNvMWriteVerificationDataSize(self):
+        return self.nvMWriteVerificationDataSize
+
+    def setNvMWriteVerificationDataSize(self, value):
+        if value is not None:
+            self.nvMWriteVerificationDataSize = value
+        return self
+
+    def getNvMBlockCipheringRef(self):
+        return self.nvMBlockCipheringRef
+
+    def setNvMBlockCipheringRef(self, value):
+        if value is not None:
+            self.nvMBlockCipheringRef = value
+        return self
+
+    def getNvMBlockEcucPartitionRef(self) -> EcucRefType:
+        return self.nvMBlockEcucPartitionRef
+
+    def setNvMBlockEcucPartitionRef(self, value: EcucRefType):
+        if value is not None:
+            self.nvMBlockEcucPartitionRef = value
+        return self

eb_model/models/os_xdm.py

@@ -1,6 +1,6 @@
 from typing import Dict, List                                                       # noqa F401
 import logging
-from ..models.abstract import EcucParamConfContainerDef, EcucObject, EcucRefType, Module
+from ..models.abstract import EcucEnumerationParamDef, EcucParamConfContainerDef, EcucObject, EcucRefType, Module
 
 
 class OsAlarmAction(EcucParamConfContainerDef):
@@ -483,10 +483,38 @@ class OsCounter(EcucParamConfContainerDef):
 
 
 class OsResource(EcucParamConfContainerDef):
-    def __init__(self) -> None:
-        pass
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.osResourceProperty = None                                  # type: EcucEnumerationParamDef
+        self.osResourceAccessingApplicationRefs = []                    # type: List[EcucRefType]
+        self.osResourceLinkedResourceRefs = []                          # type: List[EcucRefType]
+
+    def getOsResourceProperty(self):
+        return self.osResourceProperty
+
+    def setOsResourceProperty(self, value):
+        if value is not None:
+            self.osResourceProperty = value
+        return self
+
+    def getOsResourceAccessingApplicationRefs(self):
+        return self.osResourceAccessingApplicationRefs
+
+    def addOsResourceAccessingApplicationRefs(self, value):
+        if value is not None:
+            self.osResourceAccessingApplicationRefs.append(value)
+        return self
+
+    def getOsResourceLinkedResourceRefs(self):
+        return self.osResourceLinkedResourceRefs
 
+    def setOsResourceLinkedResourceRefs(self, value):
+        if value is not None:
+            self.osResourceLinkedResourceRefs = value
+        return self
 
+    
 class OsIsrResourceLock(EcucParamConfContainerDef):
     def __init__(self) -> None:
         self.osIsrResourceLockBudget = None
@@ -944,6 +972,7 @@ class Os(Module):
         self.osScheduleTables = []                      # type: List[OsScheduleTable]
         self.osCounters = []                            # type: List[OsCounter]
         self.osApplications = []                        # type: List[OsApplication]
+        self.osResources = []                           # type: List[OsResource]
 
         # extended attributes to speed up performance
         self.osIsrToOsAppMappings = {}                  # type: Dict[str, OsApplication]
@@ -992,22 +1021,30 @@ class Os(Module):
         return self
     
     def getOsApplicationList(self) -> List[OsApplication]:
-        return list(sorted(filter(lambda a: isinstance(a, OsApplication), self.elements.values()), key=lambda o: o.name))
+        return list(sorted(filter(lambda a: isinstance(a, OsApplication), self.elements.values()), key=lambda o: o.getName()))
 
     def addOsApplication(self, value: OsApplication):
         self.addElement(value)
         self.osApplications.append(value)
         
         for isr_ref in value.getOsAppIsrRefs():
-            self.logger.debug("Create OsISR <%s> -> OsApp <%s> Mapping." % (isr_ref.getShortName(), value.getName))
+            self.logger.debug("Create OsISR <%s> -> OsApp <%s> Mapping." % (isr_ref.getShortName(), value.getName()))
             self.osIsrToOsAppMappings[isr_ref.getShortName()] = value
 
         for task_ref in value.getOsAppTaskRefs():
-            self.logger.debug("Create OsTask <%s> -> OsApp <%s> Mapping." % (task_ref.getShortName(), value.getName))
+            self.logger.debug("Create OsTask <%s> -> OsApp <%s> Mapping." % (task_ref.getShortName(), value.getName()))
             self.osTaskToOsAppMappings[task_ref.getShortName()] = value
 
         return self
     
+    def getOsResourceList(self) -> List[OsResource]:
+        return list(sorted(filter(lambda a: isinstance(a, OsResource), self.elements.values()), key=lambda o: o.getName()))
+
+    def addOsResource(self, os_task: OsResource):
+        self.addElement(os_task)
+        self.osResources.append(os_task)
+        return self
+    
     def getOsIsrOsApplication(self, isr_name: str) -> OsApplication:
         if isr_name in self.osIsrToOsAppMappings:
             return self.osIsrToOsAppMappings[isr_name]

eb_model/parser/__init__.py

@@ -1,4 +1,5 @@
 from .os_xdm_parser import OsXdmParser
 from .rte_xdm_parser import RteXdmParser
+from .nvm_xdm_parser import NvMXdmParser
 from .eb_parser import AbstractEbModelParser
-from .pref_xdm_parser import PerfXdmParser
+from .pref_xdm_parser import PerfXdmParser

eb_model/parser/eb_parser.py

@@ -86,7 +86,9 @@ class AbstractEbModelParser(metaclass = ABCMeta):
         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']))
+        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)

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,6 +1,7 @@
 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 ..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,7 @@ 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)
 
     def read_os_task_autostart(self, element: ET.Element, os_task: OsTask):
         ctr_tag = self.find_ctr_tag(element, "OsTaskAutostart")
@@ -184,3 +186,13 @@ 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.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)

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,8 +1,9 @@
 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:
@@ -15,12 +16,12 @@ class ExcelReporter:
             for cell in row:
                 if cell.value:
                     alignment = cell.alignment      # type: Alignment
-                    if (alignment.wrapText == True):
+                    if (alignment.wrapText is 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):
@@ -28,10 +29,10 @@ class ExcelReporter:
             cell = sheet.cell(row=1, column=idx + 1)
             cell.value = title_row[idx]
 
-    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):
@@ -40,4 +41,3 @@ class ExcelReporter:
 
     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)

eb_model/reporter/excel_reporter/rte_xdm.py

@@ -2,6 +2,7 @@ from ...models.rte_xdm import RteBswEventToTaskMapping, RteBswModuleInstance, Rt
 from ...models.eb_doc import EBModel
 from .abstract import ExcelReporter
 
+
 class RteXdmXlsWriter(ExcelReporter):
     def __init__(self) -> None:
         super().__init__()
@@ -45,6 +46,7 @@ class RteXdmXlsWriter(ExcelReporter):
 
         self.save(filename)
 
+
 class RteRunnableEntityXlsWriter(ExcelReporter):
     def __init__(self) -> None:
         super().__init__()
@@ -57,7 +59,7 @@ class RteRunnableEntityXlsWriter(ExcelReporter):
 
         row = 2
         for os_task, mappings in doc.getRte().getMappedEvents().items():
-            for mapping in sorted(mappings, key = lambda a:a.getRtePositionInTask()):
+            for mapping in sorted(mappings, key=lambda a: a.getRtePositionInTask()):
                 self.write_cell(sheet, row, 1, os_task)
                 if isinstance(mapping, RteBswEventToTaskMapping):
                     self.logger.debug("Write Mapping %s" % mapping.getName())
@@ -68,7 +70,7 @@ class RteRunnableEntityXlsWriter(ExcelReporter):
                     self.write_cell(sheet, row, 7, mapping.getRteBswActivationOffset())
                 elif isinstance(mapping, RteEventToTaskMapping):
                     self.logger.debug("Write Mapping %s" % mapping.getName())
-                    instance = mapping.getRteSwComponentInstance() 
+                    instance = mapping.getRteSwComponentInstance()
                     self.write_cell(sheet, row, 2, mapping.getRteEventRef().getShortName())
                     self.write_cell(sheet, row, 5, instance.getRteSoftwareComponentInstanceRef().getValue())
                     self.write_cell(sheet, row, 6, mapping.getRtePositionInTask())
@@ -84,4 +86,4 @@ class RteRunnableEntityXlsWriter(ExcelReporter):
         self.logger.info("Writing <%s>" % filename)
         self.write_mapped_events(doc)
 
-        self.save(filename)
+        self.save(filename)

{py_eb_model-1.1.5.dist-info → py_eb_model-1.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py-eb-model
-Version: 1.1.5
+Version: 1.1.6
 Summary: The parser for EB XDM file
 Home-page: UNKNOWN
 Author: melodypapa
@@ -34,7 +34,7 @@ And more details can be found at https://packaging.python.org/
 
 # 3. CLI 
 
-## 3.1. os-task-xlsx
+## 3.1. os-xdm-xlsx
 
 Extract the Os Task information from os.xdm and then report all to Excel file.
 
@@ -60,7 +60,7 @@ os-xdm-xlsx data/Os.xdm data/Os.xlsx
 
 ![](doc/os-xdm-xlsx/os_counter_in_excel.png)
 
-## 3.2. rte-task-xls
+## 3.2. rte-xdm-xlsx
 
 Extract the Rte Configuration information from rte.xdm and then report all to Excel file.
 
@@ -76,6 +76,16 @@ rte-xdm-xlsx data/Rte.xdm data/Rte.xlsx
 rte-xdm-xlsx -r data/Rte.xdm data/Os.xdm data/Runnable.xlsx
 ```
 
+# nvm-xdm-xlsx
+
+Extract the NvM Configuration information from nvm.xdm and then report all to Excel file.
+
+1. Export the Nvm Configuration information to excel file
+
+```bash
+nvm-xdm-xlsx data/NvM.xdm data/NvM.xlsx
+```
+
 ## 3.3. PrefSystemImporter
 
 Read the EB preference XDM and generate the ARXML file list into text file or create the AUTOSAR builder project file.
@@ -205,3 +215,10 @@ PrefSystemImporter --base-path c:/EB/ACG-8_8_8_WIN32X86/workspace/simple_demo_rt
    * Rte::getRteBswModuleInstance
 
 
+**Version 1.1.6**
+
+1. Add the OsResource support in Os Module:
+   * Os::getOsResourceList
+   * Os::addOsResource
+2. Read the NvMBlockDescriptor List
+

{py_eb_model-1.1.5.dist-info → py_eb_model-1.1.6.dist-info}/RECORD

@@ -1,27 +1,31 @@
 eb_model/__init__.py,sha256=oMw5xoAS-lHLxufQSlBIXhGZZMcPmwGFA3PYpTwaQTU,92
 eb_model/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eb_model/cli/nvm_xdm_2_xls_cli.py,sha256=9OxWkT7OdL2DZbG8N_2sE3y8T0GWyzpwYKWnpTm8lag,1742
 eb_model/cli/os_xdm_2_xls_cli.py,sha256=zUnxJ4uHWRSjMmpSK5hXRAzVt-_YGEyiMXrexnJSk6g,1970
 eb_model/cli/pref_system_importer_cli.py,sha256=Cra-rVpgxruLLyWHRdYAgbwfcHVPV2L8Jk6ck0v4lJU,3361
 eb_model/cli/rte_xdm_2_xls_cli.py,sha256=83uzE2Vk0h267gWxF9mnWN3Bh69RJpYyKULFXpxTByY,2127
 eb_model/models/__init__.py,sha256=Jn4oOg6CxbAvULNaVt0obDLGPZC2sLzeo6rQt4eTDQ0,245
-eb_model/models/abstract.py,sha256=rYy45TV8HzcG1dQWbXD0yalWpkxubUzjAvwOugAwtbE,3884
-eb_model/models/eb_doc.py,sha256=Kx0eExrQCmkWdPC0OnzVcZAOeXtRcwNM6AFMANntgAQ,2671
+eb_model/models/abstract.py,sha256=MSG0RYrrVbQtyWDqG1hlfpQa8nlvGdPsnLsBgU2NcxQ,4046
+eb_model/models/eb_doc.py,sha256=d_vNhWda7ZwpmLPiCmlq316G-C2hvWz5bJBss9P2y_A,2955
 eb_model/models/eclipse_project.py,sha256=I1y4UUPJQqy8Bh77sJkufzcH9wXMN1Wk82er-m1Sxhc,155
 eb_model/models/importer_xdm.py,sha256=wUdwZQ-uq75EkhU4nzrYeNR5UphaTJ41MjywOPcCHsE,4246
-eb_model/models/os_xdm.py,sha256=Kj5DuBP3-RJUdEf3d5Q1iKhpqCF_lnM-evougloAsZo,33983
+eb_model/models/nvm_xdm.py,sha256=cFeAblxdSNlGP7yN2cPLMmvvJVMNB0LuYmuM_eRQOyQ,11956
+eb_model/models/os_xdm.py,sha256=0iQrMshsbibxaTYwhHpbQFP5Xz3VoxV5eWSyd19GGNY,35557
 eb_model/models/rte_xdm.py,sha256=dEsGhpnaG-VG5QfEPv6hxQdopzwMkHHz8kDHj_7MuYM,21851
-eb_model/parser/__init__.py,sha256=7VOmPr4dng_TrOyDZFu2_s3r0BJZQGiOUxALMY8EnqI,170
-eb_model/parser/eb_parser.py,sha256=_5sUl2pMt1SchHvrLOhU2axqa3FmKTWElSB79taz0O4,8188
+eb_model/parser/__init__.py,sha256=K_sp7EVjS2KoWUCdX_0h2jIY8Gxhwqs6AtRP1Pgj1TU,214
+eb_model/parser/eb_parser.py,sha256=6zYPYku30JfnLOV75k-MrfLc75sCkKdMwc11runqIbk,8248
 eb_model/parser/eb_parser_factory.py,sha256=zqsqq52uImU4-WcS5dvHfhM95hiEPAGRtNzVik8i8wc,971
-eb_model/parser/os_xdm_parser.py,sha256=folWFp-4HdxIBmEzrBW4LA3ZQRAYygI30sZbks6rOnQ,10510
+eb_model/parser/nvm_xdm_parser.py,sha256=UME7IRySnnkKvwHY1jehdraEatWTAxWWykxntWqadUk,2216
+eb_model/parser/os_xdm_parser.py,sha256=M_77-Gxhe101WXo-97CSTNEa-oJmWjDKYeweuL7Niy0,11083
 eb_model/parser/pref_xdm_parser.py,sha256=EjfR4vrnjRVLw_7wyPmMYlBj6lPXZbBZMEdWlYPj3uI,1539
 eb_model/parser/rte_xdm_parser.py,sha256=plUue0c4ejreE9w71_mT0JNzGSClf30cXhfC2NalrII,5471
-eb_model/reporter/__init__.py,sha256=H8D_23UwJi1Ph6yjBfZhxWVbu9ci5_O4471gqXGiZCM,36
+eb_model/reporter/__init__.py,sha256=p-sMv7gJkxe3u8la09SZJjiWPgGGjZSaX0WoBD-hn-0,77
 eb_model/reporter/markdown.py,sha256=NhcJOFQ_BVbkgGe66uAT7KUPIchWU4kfVMtMLQtbK-w,1647
 eb_model/reporter/excel_reporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-eb_model/reporter/excel_reporter/abstract.py,sha256=PfIoiKNKy1eRJBABln7rADkSdwWzS03Vs03jBYM-_5Y,1622
+eb_model/reporter/excel_reporter/abstract.py,sha256=x_jW38GfyMGyHXsYQWRUUyRc6r6ywMo3zYoH_v79jto,1644
+eb_model/reporter/excel_reporter/nvm_xdm.py,sha256=OM_hKXcuFQyZUnia0kuZ03OSSrOMW0i2vIpUa5LTdEc,1698
 eb_model/reporter/excel_reporter/os_xdm.py,sha256=MG6-6qi7Dh1XXv4CR2I-iQpOvypso0dlfXt_ZQ3lO7I,6406
-eb_model/reporter/excel_reporter/rte_xdm.py,sha256=OHuVPUV7xCdDzxELyXi766YJ6GejTHrzPrlAUBqexIw,3937
+eb_model/reporter/excel_reporter/rte_xdm.py,sha256=IeBAeVJYSSle6sR0K4FiPgQToTziHKjXxr68Er7bXyg,3941
 eb_model/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 eb_model/tests/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 eb_model/tests/models/test_eb_model.py,sha256=3fpIHhzQlf9KZjm4fZxcSTT4Zio6YhTrcn9UBvlhOfo,1632
@@ -30,9 +34,9 @@ eb_model/tests/models/test_importer_xdm.py,sha256=F80kO77jeyfCkLPRgRLjEj3UPcrACi
 eb_model/writer/__init__.py,sha256=CXvQAsNV1OvYClkHdKCG7Q300OVBzcl2TmoD68MyQOs,95
 eb_model/writer/project_writer.py,sha256=9BQU1CJAktVxFvQk89Pj4IbizTJXnlQidt4eX_CIFXU,2800
 eb_model/writer/text_writer.py,sha256=7d4_PUTJk5Y6S_EQflAH3ACDnUw9VwJzP90GFDh0n0I,991
-py_eb_model-1.1.5.dist-info/LICENSE,sha256=I52rGS7W1IwAmYCUfqTpDaSHoFAdt7grcNiBhk-Z3eI,1088
-py_eb_model-1.1.5.dist-info/METADATA,sha256=ZT0KjMQ8x1ezJYgwhkrupkz4lcb0-hKKVw4WWxTyKcI,6476
-py_eb_model-1.1.5.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-py_eb_model-1.1.5.dist-info/entry_points.txt,sha256=yDLH9wnJ5Fp7ImgyFRSnr3mU6nvaenuKZnbe2rgs8Mk,183
-py_eb_model-1.1.5.dist-info/top_level.txt,sha256=DGBNh6YW_x4RF_UoLKW3cKqb2SLnmfuEIZlkTewR66A,9
-py_eb_model-1.1.5.dist-info/RECORD,,
+py_eb_model-1.1.6.dist-info/LICENSE,sha256=I52rGS7W1IwAmYCUfqTpDaSHoFAdt7grcNiBhk-Z3eI,1088
+py_eb_model-1.1.6.dist-info/METADATA,sha256=t0LEDXkC1J778lrXQjCP0jA1UOgdqsReB4lY_AEDXAU,6861
+py_eb_model-1.1.6.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+py_eb_model-1.1.6.dist-info/entry_points.txt,sha256=N7cHTMb7nGQXu2X5JvJo3JJQdRE11vRMlLyx27uarHg,234
+py_eb_model-1.1.6.dist-info/top_level.txt,sha256=DGBNh6YW_x4RF_UoLKW3cKqb2SLnmfuEIZlkTewR66A,9
+py_eb_model-1.1.6.dist-info/RECORD,,

{py_eb_model-1.1.5.dist-info → py_eb_model-1.1.6.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 PrefSystemImporter = eb_model.cli.pref_system_importer_cli:main
+nvm-xdm-xlsx = eb_model.cli.nvm_xdm_2_xls_cli:main
 os-xdm-xlsx = eb_model.cli.os_xdm_2_xls_cli:main
 rte-xdm-xlsx = eb_model.cli.rte_xdm_2_xls_cli:main