py-eb-model 1.1.4__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/__init__.py

@@ -1,5 +1,5 @@
-from .abstract import *
-from .os_xdm import *
-from .rte_xdm import *
-from .eb_doc import *
-from .importer_xdm import *
+from .abstract import *             # noqa F403
+from .os_xdm import *               # noqa F403
+from .rte_xdm import *              # noqa F403
+from .eb_doc import *               # noqa F403
+from .importer_xdm import *         # noqa F403

eb_model/models/abstract.py

@@ -2,15 +2,16 @@ from abc import ABCMeta
 from typing import Dict
 import re
 
+
 class EcucObject(metaclass=ABCMeta):
     def __init__(self, parent, name) -> None:
-        if type(self) == EcucObject:
+        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, EcucContainer):
+        if isinstance(parent, EcucParamConfContainerDef):
             parent.addElement(self)
 
     def getName(self):
@@ -29,15 +30,21 @@ 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 EcucContainer(EcucObject):
+
+class EcucParamConfContainerDef(EcucObject):
     def __init__(self, parent, name) -> None:
         super().__init__(parent, name)
 
         self.elements = {}                  # type: Dict[str, EcucObject]
 
     def getTotalElement(self) -> int:
-        #return len(list(filter(lambda a: not isinstance(a, ARPackage) , self.elements.values())))
+        # return len(list(filter(lambda a: not isinstance(a, ARPackage) , self.elements.values())))
         return len(self.elements)
     
     def addElement(self, object: EcucObject):
@@ -60,6 +67,7 @@ class EcucContainer(EcucObject):
             return None
         return self.elements[name]
 
+
 class EcucRefType:
     def __init__(self, value: str) -> None:
         self.value = value
@@ -82,6 +90,7 @@ class EcucRefType:
             return m.group(1)
         return self.value
     
+    
 class Version:
     def __init__(self):
         self.majorVersion = None
@@ -115,7 +124,8 @@ class Version:
     def getVersion(self) -> str:
         return "%d.%d.%d" % (self.majorVersion, self.minorVersion, self.patchVersion)
 
-class Module(EcucContainer):
+
+class Module(EcucParamConfContainerDef):
     def __init__(self, parent, name):
         super().__init__(parent, name)
 

eb_model/models/eb_doc.py

@@ -1,17 +1,18 @@
-from .importer_xdm import SystemDescriptionImporter
-from .rte_xdm import Rte
-from .os_xdm import Os
-from .abstract import EcucContainer, 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(EcucContainer):
+class AbstractModel(EcucParamConfContainerDef):
     def getFullName(self):
         return self.name
 
     def clear(self):
         self.elements = {}
 
-    def find_object(self, referred_name: str, element: EcucContainer) -> EcucObject:
+    def find_object(self, referred_name: str, element: EcucParamConfContainerDef) -> EcucObject:
         name_list = referred_name.split("/")
         # element = EBModel.getInstance()
         for name in name_list:
@@ -37,21 +38,29 @@ class EBModel(AbstractModel):
         if (EBModel.__instance is not None):
             raise Exception("The EBModel is singleton!")
         
-        EcucContainer.__init__(self, None, "")
+        EcucParamConfContainerDef.__init__(self, None, "")
         EBModel.__instance = self
 
     def find(self, referred_name: str) -> EcucObject:
         return self.find_object(referred_name, EBModel.getInstance())
 
     def getOs(self) -> Os:
-        container = EcucContainer(self, "Os")
+        '''
+            get the Os Container
+        '''
+        container = EcucParamConfContainerDef(self, "Os")
         Os(container)
         return self.find("/Os/Os")
     
     def getRte(self) -> Rte:
-        container = EcucContainer(self, "Rte")
+        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):
@@ -67,10 +76,10 @@ class PreferenceModel(AbstractModel):
         if (PreferenceModel.__instance is not None):
             raise Exception("The PreferenceModel is singleton!")
         
-        EcucContainer.__init__(self, None, "")
+        EcucParamConfContainerDef.__init__(self, None, "")
         PreferenceModel.__instance = self
 
-        container = EcucContainer(self, "ImporterExporterAdditions")
+        container = EcucParamConfContainerDef(self, "ImporterExporterAdditions")
         SystemDescriptionImporter(container, "SystemDescriptionImporters")
 
     def find(self, referred_name: str) -> EcucObject:

eb_model/models/eclipse_project.py

@@ -1,8 +1,5 @@
-
 class Link:
     def __init__(self, name, type, locationURI):
         self.name = name
         self.type = type
         self.locationURI = locationURI
-
-        

eb_model/models/importer_xdm.py

@@ -7,6 +7,7 @@ import os
 import re
 import logging
 
+
 class SystemDescriptionImporter(EcucObject):
     def __init__(self, parent, name):
         super().__init__(parent, name)
@@ -28,7 +29,7 @@ class SystemDescriptionImporter(EcucObject):
             file_list.append(file)
         return file_list
     
-    def getParsedInputFiles(self, params = {}) -> List[str]:
+    def getParsedInputFiles(self, params={}) -> List[str]:
         file_list = []
         for input_file in self.inputFiles:
             m = re.match(r'\$\{(env_var:\w+)\}(.*)', input_file)
@@ -50,7 +51,7 @@ class SystemDescriptionImporter(EcucObject):
                 file_list.append(input_file)
         return file_list
     
-    def getAllPaths(self, path :str) -> List[str]:
+    def getAllPaths(self, path: str) -> List[str]:
         path_segments = path.split("/")
 
         result = []
@@ -61,11 +62,11 @@ class SystemDescriptionImporter(EcucObject):
             if long_path == "":
                 long_path = path_segment
             else:
-                long_path = long_path +"/" + path_segment
+                long_path = long_path + "/" + path_segment
             result.append(long_path)
         return result
     
-    def getNameByPath(self, path : str):              
+    def getNameByPath(self, path: str):
         path_segments = path.split("/")
 
         result = []
@@ -76,10 +77,10 @@ class SystemDescriptionImporter(EcucObject):
             else:
                 result.append(path_segment)
         
-        return (count , "/".join(result))
+        return (count, "/".join(result))
     
     def getLinks(self, file_list: List[str]) -> List[Link]:
-        path_sets = {}             # type: Dict[str, List[str]] 
+        path_sets = {}                              # type: Dict[str, List[str]]
         path_segment_sets = []
 
         for file in file_list:
@@ -111,5 +112,3 @@ class SystemDescriptionImporter(EcucObject):
                 links.append(link)
         
         return links
-
-

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