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

eb_model/cli/pref_system_importer_cli.py

@@ -9,23 +9,31 @@ from ..writer import TextPreferenceModelWriter, ABProjectWriter
 from ..parser import PerfXdmParser
 from ..models import PreferenceModel
 
+
 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("--file-list", required=False, help = "generate the file list (Default)", action = "store_true")
-    ap.add_argument("--ab-project", required=False, help = "generate the AUTOSAR builder project", action = "store_true")
-    ap.add_argument("--base-path", required=True, help="base Path for EB tresos")
-    ap.add_argument("--env", required=False, help="specify the environment variable", nargs='+')
-    ap.add_argument("--project", required=False, help="specify the project name")
-    ap.add_argument("INPUTS", nargs='+', help = "The path of perf_imp_xxx.xdm.")
-    ap.add_argument("OUTPUT", help = "The path of output file.")
+    ap.description = "PrefSystemImporter ver: %s" % version
+    ap.add_argument("-v", "--verbose", required=False,
+                    help="print debug information.", action="store_true")
+    ap.add_argument("--file-list", required=False,
+                    help="generate the file list (Default)", action="store_true")
+    ap.add_argument("--ab-project", required=False,
+                    help="generate the AUTOSAR builder project", action="store_true")
+    ap.add_argument("--base-path", required=True,
+                    help="base Path for EB tresos")
+    ap.add_argument("--env", required=False,
+                    help="specify the environment variable", nargs='+')
+    ap.add_argument("--project", required=False,
+                    help="specify the project name")
+    ap.add_argument("INPUTS", nargs='+', help="The path of perf_imp_xxx.xdm.")
+    ap.add_argument("OUTPUT", help="The path of output file.")
 
     args = ap.parse_args()
 
     logger = logging.getLogger()
-    
+
     formatter = logging.Formatter('[%(levelname)s] : %(message)s')
 
     stdout_handler = logging.StreamHandler(sys.stderr)
@@ -48,7 +56,7 @@ def main():
         stdout_handler.setLevel(logging.DEBUG)
     else:
         stdout_handler.setLevel(logging.INFO)
-    
+
     if args.verbose:
         logger.addHandler(file_handler)
     logger.addHandler(stdout_handler)
@@ -68,7 +76,8 @@ def main():
         parser = PerfXdmParser()
         for file in args.INPUTS:
             if args.base_path is not None:
-                file_name = os.path.realpath(os.path.join(args.base_path, file))
+                file_name = os.path.realpath(
+                    os.path.join(args.base_path, file))
             else:
                 file_name = file
             parser.parse_preference_xdm(file_name, doc)
@@ -80,7 +89,7 @@ def main():
                 m = re.match(r'(\w+)=([:\/\\\.\w]+)', env)
                 if m:
                     params["env_var:%s" % m.group(1)] = m.group(2)
-        #params['tresos_output_base_dir'] = args.TRESOS_OUTPUT_BASE_DIR
+        # params['tresos_output_base_dir'] = args.TRESOS_OUTPUT_BASE_DIR
 
         if format == "file_list":
             writer = TextPreferenceModelWriter()
@@ -88,7 +97,7 @@ def main():
         elif format == "ab_project":
             writer = ABProjectWriter()
             writer.writer_import_files(args.OUTPUT, doc.getSystemDescriptionImporter(), params)
-        
+
     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

@@ -41,6 +41,7 @@ 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:
@@ -66,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:
@@ -135,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/importer_xdm.py

@@ -36,12 +36,14 @@ class SystemDescriptionImporter(EcucObject):
             if m and m.group(1) in params:
                 old_input_file = input_file
                 input_file = params[m.group(1)] + m.group(2)
-                self.logger.info("Replace Environment Variable Path: %s => %s" % (old_input_file, os.path.realpath(input_file)))
+                # self.logger.info("Replace Environment Variable Path: %s => %s" % (old_input_file, os.path.realpath(input_file)))
+                self.logger.info("Replace Environment Variable Path: %s => %s" % (old_input_file, input_file))
             if params['base_path'] is not None:
                 if params['wildcard']:
                     m = re.match(r'(.+)\\(\*\.\w+)', input_file)
                     if m:
                         for file_name in self.parseWildcard(os.path.realpath(os.path.join(params['base_path'], input_file))):
+                            # self.logger.info("Add the file <%s>." % file_name)
                             file_list.append(file_name)
                     else:
                         file_list.append(os.path.realpath(os.path.join(params['base_path'], input_file)))

eb_model/models/nvm_xdm.py

@@ -2,18 +2,254 @@ from typing import List
 from ..models.abstract import EcucParamConfContainerDef, Module, EcucRefType
 
 
-class NvM(Module):
-    def __init__(self, parent):
-        super().__init__(parent, "NvM")
+class NvMTargetBlockReference(EcucParamConfContainerDef):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
 
-        self.NvMBlockDescriptors = []                       # type: List[NvMBlockDescriptor]
 
-    def getNvMBlockDescriptorList(self):
-        return self.NvMBlockDescriptors
+class NvMEaRef(NvMTargetBlockReference):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.NvMNameOfEaBlock: EcucRefType = None
 
-    def addNvMBlockDescriptor(self, value):
+    def getNvMNameOfEaBlock(self) -> EcucRefType:
+        return self.NvMNameOfEaBlock
+
+    def setNvMNameOfEaBlock(self, value: EcucRefType):
         if value is not None:
-            self.NvMBlockDescriptors.append(value)
+            self.NvMNameOfEaBlock = value
+        return self
+
+
+class NvMFeeRef(NvMTargetBlockReference):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.NvMNameOfFeeBlock: EcucRefType = None
+
+    def getNvMNameOfFeeBlock(self) -> EcucRefType:
+        return self.NvMNameOfFeeBlock
+
+    def setNvMNameOfFeeBlock(self, value: EcucRefType):
+        if value is not None:
+            self.NvMNameOfFeeBlock = value
+        return self
+
+
+class NvMCommon(EcucParamConfContainerDef):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.NvMApiConfigClass: str = None
+        self.NvMBswMMultiBlockJobStatusInformation: bool = None
+        self.NvMCompiledConfigId: int = None
+        self.NvMCrcNumOfBytes: int = None
+        self.NvMCsmRetryCounter: int = None
+        self.NvMDatasetSelectionBits: int = None
+        self.NvMDevErrorDetect: bool = None
+        self.NvMDynamicConfiguration: bool = None
+        self.NvMJobPrioritization: bool = None
+        self.NvMMainFunctionPeriod: float = None
+        self.NvMMultiBlockCallback: str = None
+        self.NvMPollingMode: bool = None
+        self.NvMRepeatMirrorOperations: int = None
+        self.NvMSetRamBlockStatusApi: bool = None
+        self.NvMSizeImmediateJobQueue: int = None
+        self.NvMSizeStandardJobQueue: int = None
+        self.NvMVersionInfoApi: bool = None
+        self.NvMBufferAlignmentValue: str = None
+        self.NvMEcucPartitionRefs: List[EcucRefType] = []
+        self.NvMMasterEcucPartitionRef: EcucRefType = None
+
+    def getNvMApiConfigClass(self) -> str:
+        return self.NvMApiConfigClass
+
+    def setNvMApiConfigClass(self, value: str):
+        if value is not None:
+            self.NvMApiConfigClass = value
+        return self
+
+    def getNvMBswMMultiBlockJobStatusInformation(self) -> bool:
+        return self.NvMBswMMultiBlockJobStatusInformation
+
+    def setNvMBswMMultiBlockJobStatusInformation(self, value: bool):
+        if value is not None:
+            self.NvMBswMMultiBlockJobStatusInformation = value
+        return self
+
+    def getNvMCompiledConfigId(self) -> int:
+        return self.NvMCompiledConfigId
+
+    def setNvMCompiledConfigId(self, value: int):
+        if value is not None:
+            self.NvMCompiledConfigId = value
+        return self
+
+    def getNvMCrcNumOfBytes(self) -> int:
+        return self.NvMCrcNumOfBytes
+
+    def setNvMCrcNumOfBytes(self, value: int):
+        if value is not None:
+            self.NvMCrcNumOfBytes = value
+        return self
+
+    def getNvMCsmRetryCounter(self) -> int:
+        return self.NvMCsmRetryCounter
+
+    def setNvMCsmRetryCounter(self, value: int):
+        if value is not None:
+            self.NvMCsmRetryCounter = value
+        return self
+
+    def getNvMDatasetSelectionBits(self) -> int:
+        return self.NvMDatasetSelectionBits
+
+    def setNvMDatasetSelectionBits(self, value: int):
+        if value is not None:
+            self.NvMDatasetSelectionBits = value
+        return self
+
+    def getNvMDevErrorDetect(self) -> bool:
+        return self.NvMDevErrorDetect
+
+    def setNvMDevErrorDetect(self, value: bool):
+        if value is not None:
+            self.NvMDevErrorDetect = value
+        return self
+
+    def getNvMDynamicConfiguration(self) -> bool:
+        return self.NvMDynamicConfiguration
+
+    def setNvMDynamicConfiguration(self, value: bool):
+        if value is not None:
+            self.NvMDynamicConfiguration = value
+        return self
+
+    def getNvMJobPrioritization(self) -> bool:
+        return self.NvMJobPrioritization
+
+    def setNvMJobPrioritization(self, value: bool):
+        if value is not None:
+            self.NvMJobPrioritization = value
+        return self
+
+    def getNvMMainFunctionPeriod(self) -> float:
+        return self.NvMMainFunctionPeriod
+
+    def setNvMMainFunctionPeriod(self, value: float):
+        if value is not None:
+            self.NvMMainFunctionPeriod = value
+        return self
+
+    def getNvMMultiBlockCallback(self) -> str:
+        return self.NvMMultiBlockCallback
+
+    def setNvMMultiBlockCallback(self, value: str):
+        if value is not None:
+            self.NvMMultiBlockCallback = value
+        return self
+
+    def getNvMPollingMode(self) -> bool:
+        return self.NvMPollingMode
+
+    def setNvMPollingMode(self, value: bool):
+        if value is not None:
+            self.NvMPollingMode = value
+        return self
+
+    def getNvMRepeatMirrorOperations(self) -> int:
+        return self.NvMRepeatMirrorOperations
+
+    def setNvMRepeatMirrorOperations(self, value: int):
+        if value is not None:
+            self.NvMRepeatMirrorOperations = value
+        return self
+
+    def getNvMSetRamBlockStatusApi(self) -> bool:
+        return self.NvMSetRamBlockStatusApi
+
+    def setNvMSetRamBlockStatusApi(self, value: bool):
+        if value is not None:
+            self.NvMSetRamBlockStatusApi = value
+        return self
+
+    def getNvMSizeImmediateJobQueue(self) -> int:
+        return self.NvMSizeImmediateJobQueue
+
+    def setNvMSizeImmediateJobQueue(self, value: int):
+        if value is not None:
+            self.NvMSizeImmediateJobQueue = value
+        return self
+
+    def getNvMSizeStandardJobQueue(self) -> int:
+        return self.NvMSizeStandardJobQueue
+
+    def setNvMSizeStandardJobQueue(self, value: int):
+        if value is not None:
+            self.NvMSizeStandardJobQueue = value
+        return self
+
+    def getNvMVersionInfoApi(self) -> bool:
+        return self.NvMVersionInfoApi
+
+    def setNvMVersionInfoApi(self, value: bool):
+        if value is not None:
+            self.NvMVersionInfoApi = value
+        return self
+
+    def getNvMBufferAlignmentValue(self) -> str:
+        return self.NvMBufferAlignmentValue
+
+    def setNvMBufferAlignmentValue(self, value: str):
+        if value is not None:
+            self.NvMBufferAlignmentValue = value
+        return self
+
+    def getNvMEcucPartitionRefList(self) -> List[EcucRefType]:
+        return self.NvMEcucPartitionRefs
+
+    def addNvMEcucPartitionRef(self, value: EcucRefType):
+        if value is not None:
+            self.NvMEcucPartitionRefs.append(value)
+        return self
+
+    def getNvMMasterEcucPartitionRef(self) -> EcucRefType:
+        return self.NvMMasterEcucPartitionRef
+
+    def setNvMMasterEcucPartitionRef(self, value: EcucRefType):
+        if value is not None:
+            self.NvMMasterEcucPartitionRef = value
+        return self
+
+
+class NvMSingleBlockCallback(EcucParamConfContainerDef):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.NvMSingleBlockCallbackFnc: str = None
+
+    def getNvMSingleBlockCallbackFnc(self) -> str:
+        return self.NvMSingleBlockCallbackFnc
+
+    def setNvMSingleBlockCallbackFnc(self, value: str):
+        if value is not None:
+            self.NvMSingleBlockCallbackFnc = value
+        return self
+
+
+class NvMInitBlockCallback(EcucParamConfContainerDef):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.NvMInitBlockCallbackFnc: str = None
+
+    def getNvMInitBlockCallbackFnc(self) -> str:
+        return self.NvMInitBlockCallbackFnc
+
+    def setNvMInitBlockCallbackFnc(self, value: str):
+        if value is not None:
+            self.NvMInitBlockCallbackFnc = value
         return self
 
 
@@ -23,11 +259,11 @@ class NvMBlockDescriptor(EcucParamConfContainerDef):
 
         self.nvMBlockCrcType = None                         # type: str # optional
         self.nvMBlockHeaderInclude = None                   # type: int # optional
-        self.nvMBlockJobPriority = None                     # type: str # required
+        self.nvMBlockJobPriority: int = None
         self.nvMBlockManagementType = None                  # type: str # required
         self.nvMBlockUseAutoValidation = None               # required
         self.nvMBlockUseCompression = None                  # required
-        self.nvMBlockUseCrc = None                          # required
+        self.nvMBlockUseCrc: bool = False
         self.nvMBlockUseCRCCompMechanism = None             # required
         self.NvMBlockUsePort = None                         # required
         self.nvMBlockUseSetRamBlockStatus = None            # required
@@ -44,7 +280,7 @@ class NvMBlockDescriptor(EcucParamConfContainerDef):
         self.nvMNvramDeviceId = None                        # required
         self.nvMRamBlockDataAddress = None                  # optional
         self.nvMReadRamBlockFromNvCallback = None           # optional
-        self.nvMResistantToChangedSw = None                 # required
+        self.nvMResistantToChangedSw: bool = False
         self.nvMRomBlockDataAddress = None                  # optional
         self.nvMRomBlockNum = None                          # required
         self.nvMSelectBlockForFirstInitAll = None           # optional
@@ -56,7 +292,15 @@ class NvMBlockDescriptor(EcucParamConfContainerDef):
         self.nvMWriteVerification = None                    # required
         self.nvMWriteVerificationDataSize = None            # required
         self.nvMBlockCipheringRef = None                    # optional
-        self.nvMBlockEcucPartitionRef = None                # type: EcucRefType # required
+        self.nvMBlockEcucPartitionRef: EcucRefType = None
+
+        self.nvMInitBlockCallback: NvMInitBlockCallback = None
+        self.nvMSingleBlockCallback: NvMSingleBlockCallback = None
+        self.nvMTargetBlockReference: NvMTargetBlockReference = None
+
+        # EB extended
+        self.nvMProvideRteJobFinishedPort: bool = False
+        self.nvMProvideRteServicePort: bool = False
 
     def getNvMBlockCrcType(self):
         return self.nvMBlockCrcType
@@ -345,3 +589,68 @@ class NvMBlockDescriptor(EcucParamConfContainerDef):
         if value is not None:
             self.nvMBlockEcucPartitionRef = value
         return self
+
+    def getNvMInitBlockCallback(self) -> NvMInitBlockCallback:
+        return self.nvMInitBlockCallback
+
+    def setNvMInitBlockCallback(self, value: NvMInitBlockCallback):
+        if value is not None:
+            self.nvMInitBlockCallback = value
+        return self
+
+    def getNvMSingleBlockCallback(self) -> NvMSingleBlockCallback:
+        return self.nvMSingleBlockCallback
+
+    def setNvMSingleBlockCallback(self, value: NvMSingleBlockCallback):
+        if value is not None:
+            self.nvMSingleBlockCallback = value
+        return self
+
+    def getNvMTargetBlockReference(self) -> NvMTargetBlockReference:
+        return self.nvMTargetBlockReference
+
+    def setNvMTargetBlockReference(self, value: NvMTargetBlockReference):
+        if value is not None:
+            self.nvMTargetBlockReference = value
+        return self
+
+    def getNvMProvideRteJobFinishedPort(self) -> bool:
+        return self.nvMProvideRteJobFinishedPort
+
+    def setNvMProvideRteJobFinishedPort(self, value: bool):
+        if value is not None:
+            self.nvMProvideRteJobFinishedPort = value
+        return self
+
+    def getNvMProvideRteServicePort(self) -> bool:
+        return self.nvMProvideRteServicePort
+
+    def setNvMProvideRteServicePort(self, value: bool):
+        if value is not None:
+            self.nvMProvideRteServicePort = value
+        return self
+
+
+class NvM(Module):
+    def __init__(self, parent):
+        super().__init__(parent, "NvM")
+
+        # type: List[NvMBlockDescriptor]
+        self.NvMBlockDescriptors = []
+        self.NvMCommon: NvMCommon = None
+
+    def getNvMCommon(self) -> NvMCommon:
+        return self.NvMCommon
+
+    def setNvMCommon(self, value: NvMCommon):
+        if value is not None:
+            self.NvMCommon = value
+        return self
+
+    def getNvMBlockDescriptorList(self) -> List[NvMBlockDescriptor]:
+        return self.NvMBlockDescriptors
+
+    def addNvMBlockDescriptor(self, value: NvMBlockDescriptor):
+        if value is not None:
+            self.NvMBlockDescriptors.append(value)
+        return self