py-eb-model 1.1.5__py3-none-any.whl → 1.1.7__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/cli/rte_xdm_2_xls_cli.py

@@ -10,45 +10,46 @@ from ..reporter.excel_reporter.rte_xdm import RteRunnableEntityXlsWriter, RteXdm
 from ..parser.rte_xdm_parser import RteXdmParser
 from ..models import EBModel
 
-def main():
-    version = pkg_resources.require("py_eb_model")[0].version
-
-    ap = argparse.ArgumentParser()
-    ap.add_argument("-v", "--verbose", required= False, help= "Print debug information", action= "store_true")
-    ap.add_argument("-r", "--runnable", required= False, help= "Export the runnable entities", action= "store_true")
-    ap.add_argument("INPUT", help = "The path of xdm file.", nargs='+')
-    ap.add_argument("OUTPUT", help = "The path of excel file.")
-
-    args = ap.parse_args()
 
+def process_logger(args):
     logger = logging.getLogger()
+    formatter = logging.Formatter('[%(levelname)s] : %(message)s')
+    logger.setLevel(logging.DEBUG)
     
-    formatter = logging.Formatter('[%(levelname)s] [%(asctime)s]: %(message)s')
+    if args.verbose:
+        log_level = logging.DEBUG
+    else:
+        log_level = logging.INFO
 
     stdout_handler = logging.StreamHandler(sys.stderr)
     stdout_handler.setFormatter(formatter)
+    stdout_handler.setLevel(log_level)
+    logger.addHandler(stdout_handler)
 
-    base_path = os.path.dirname(args.OUTPUT)
-    log_file = os.path.join(base_path, 'rte_xdm_2_xls.log')
+    if args.log:
+        if os.path.exists(args.log):
+            os.remove(args.log)
 
-    if os.path.exists(log_file):
-        os.remove(log_file)
+        file_handler = logging.FileHandler(args.log)
+        file_handler.setFormatter(formatter)
+        file_handler.setLevel(log_level)
+        logger.addHandler(file_handler)
+    return logger
 
-    file_handler = logging.FileHandler(log_file)
-    file_handler.setFormatter(formatter)
 
-    logger.setLevel(logging.DEBUG)
-    file_handler.setLevel(logging.DEBUG)
-
-    if args.verbose:
-        stdout_handler.setLevel(logging.DEBUG)
-        
-    else:
-        stdout_handler.setLevel(logging.INFO)
+def main():
+    # version = pkg_resources.require("py_eb_model")[0].version
 
-    logger.addHandler(file_handler)
-    logger.addHandler(stdout_handler)    
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-v", "--verbose", required=False, help="Print debug information", action="store_true")
+    ap.add_argument("-r", "--runnable", required=False, help="Export the runnable entities", action="store_true")
+    ap.add_argument("--log", required=False, help="The Log file name.")
+    ap.add_argument("INPUT", help="The path of xdm file.", nargs='+')
+    ap.add_argument("OUTPUT", help="The path of excel file.")
 
+    args = ap.parse_args()
+    logger = process_logger(args)
+    
     try:
         doc = EBModel.getInstance()
 

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,12 +30,18 @@ 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):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
+        self.importerInfo: str = None
         self.elements = {}                  # type: Dict[str, EcucObject]
 
     def getTotalElement(self) -> int:
@@ -61,6 +67,17 @@ class EcucParamConfContainerDef(EcucObject):
         if (name not in self.elements):
             return None
         return self.elements[name]
+    
+    def getImporterInfo(self) -> str:
+        return self.importerInfo
+    
+    def setImporterInfo(self, value: str) -> None:
+        self.importerInfo = value
+
+    def isCalculatedSvcAs(self) -> bool:
+        if self.importerInfo is not None and self.importerInfo.startswith("@CALC(SvcAs"):
+            return True
+        return False
 
 
 class EcucRefType:
@@ -130,15 +147,15 @@ class Module(EcucParamConfContainerDef):
     def getArVersion(self):
         return self.arVersion
 
-    def setArVersion(self, value):
-        if value is not None:
-            self.arVersion = value
-        return self
+    # def setArVersion(self, value):
+    #    if value is not None:
+    #        self.arVersion = value
+    #    return self
 
     def getSwVersion(self):
         return self.swVersion
 
-    def setSwVersion(self, value):
-        if value is not None:
-            self.swVersion = value
-        return self
+    # def setSwVersion(self, value):
+    #    if value is not None:
+    #        self.swVersion = value
+    #    return self

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