py-eb-model 1.0.0__py3-none-any.whl → 1.1.4__py3-none-any.whl

eb_model/__init__.py

@@ -1,3 +1,4 @@
 from .models import *
 from .parser import *
-from .reporter import *
+from .reporter import *
+from .writer import *

eb_model/cli/os_xdm_2_xls_cli.py

@@ -8,13 +8,16 @@ from ..parser import OsXdmParser
 from ..models import EBModel
 from ..reporter import OsXdmXlsWriter
 
+
 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("INPUT", help = "The path of Os.xdm.")
-    ap.add_argument("OUTPUT", help = "The path of excel file.")
+    ap.description = "Version: %s" % version
+    ap.add_argument("-v", "--verbose", required=False, help="Print debug information.", action="store_true")
+    ap.add_argument("--skip-os-task", required=False, help="Skip to generate Os task.", action="store_true")
+    ap.add_argument("INPUT", help="The path of Os.xdm.")
+    ap.add_argument("OUTPUT", help="The path of excel file.")
 
     args = ap.parse_args()
 
@@ -31,28 +34,34 @@ def main():
     if os.path.exists(log_file):
         os.remove(log_file)
 
-    file_handler = logging.FileHandler(log_file)
-    file_handler.setFormatter(formatter)
+    if args.verbose:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        file_handler.setLevel(logging.DEBUG)
 
     logger.setLevel(logging.DEBUG)
-    file_handler.setLevel(logging.DEBUG)
 
     if args.verbose:
         stdout_handler.setLevel(logging.DEBUG)
-        
     else:
         stdout_handler.setLevel(logging.INFO)
 
-    logger.addHandler(file_handler)
-    logger.addHandler(stdout_handler)    
+    if args.verbose:
+        logger.addHandler(file_handler)
+    logger.addHandler(stdout_handler)
 
     try:
         doc = EBModel.getInstance()
+        
         parser = OsXdmParser()
-        writer = OsXdmXlsWriter()
+        parser.parse_xdm(args.INPUT, doc)
 
-        parser.parse(args.INPUT, doc)
-        writer.write(args.OUTPUT, doc)
+        options = {"skip_os_task": False}
+        if args.skip_os_task:
+            options['skip_os_task'] = True
+
+        writer = OsXdmXlsWriter()
+        writer.write(args.OUTPUT, doc, options)
         
     except Exception as e:
         logger.error(e)

eb_model/cli/pref_system_importer_cli.py

@@ -0,0 +1,94 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+import re
+
+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.")
+
+    args = ap.parse_args()
+
+    logger = logging.getLogger()
+    
+    formatter = logging.Formatter('[%(levelname)s] : %(message)s')
+
+    stdout_handler = logging.StreamHandler(sys.stderr)
+    stdout_handler.setFormatter(formatter)
+
+    base_path = os.path.dirname(args.OUTPUT)
+    log_file = os.path.join(base_path, 'pref_system_importer.log')
+
+    if os.path.exists(log_file):
+        os.remove(log_file)
+
+    if args.verbose:
+        file_handler = logging.FileHandler(log_file)
+        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.verbose:
+        logger.addHandler(file_handler)
+    logger.addHandler(stdout_handler)
+
+    format = "file_list"
+    if args.ab_project:
+        format = "ab_project"
+
+    try:
+        doc = PreferenceModel.getInstance()
+
+        params = {}
+        params['base_path'] = args.base_path
+        params['wildcard'] = True
+        params['project'] = args.project
+
+        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))
+            else:
+                file_name = file
+            parser.parse_preference_xdm(file_name, doc)
+
+        parser.add_ecu_extract(doc, params)
+
+        if args.env is not None:
+            for env in args.env:
+                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
+
+        if format == "file_list":
+            writer = TextPreferenceModelWriter()
+            writer.writer_import_files(args.OUTPUT, doc.getSystemDescriptionImporter(), params)
+        elif format == "ab_project":
+            writer = ABProjectWriter()
+            writer.writer_import_files(args.OUTPUT, doc.getSystemDescriptionImporter(), params)
+        
+    except Exception as e:
+        logger.error(e)
+        raise e

py_eb_model/cli/os_xdm_2_xls_cli.py → eb_model/cli/rte_xdm_2_xls_cli.py

@@ -4,29 +4,32 @@ import logging
 import sys
 import os.path
 
-from ..parser import OsXdmParser
+from eb_model.parser.eb_parser_factory import EbParserFactory
+
+from ..reporter.excel_reporter.rte_xdm import RteRunnableEntityXlsWriter, RteXdmXlsWriter
+from ..parser.rte_xdm_parser import RteXdmParser
 from ..models import EBModel
-from ..reporter import OsXdmXlsWriter
 
 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("INPUT", help = "The path of Os.xdm.")
+    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()
 
     logger = logging.getLogger()
     
-    formatter = logging.Formatter('[%(levelname)s] : %(message)s')
+    formatter = logging.Formatter('[%(levelname)s] [%(asctime)s]: %(message)s')
 
     stdout_handler = logging.StreamHandler(sys.stderr)
     stdout_handler.setFormatter(formatter)
 
     base_path = os.path.dirname(args.OUTPUT)
-    log_file = os.path.join(base_path, 'os_xdm_2_xls.log')
+    log_file = os.path.join(base_path, 'rte_xdm_2_xls.log')
 
     if os.path.exists(log_file):
         os.remove(log_file)
@@ -48,11 +51,17 @@ def main():
 
     try:
         doc = EBModel.getInstance()
-        parser = OsXdmParser()
-        writer = OsXdmXlsWriter()
 
-        parser.parse(args.INPUT, doc)
-        writer.write(args.OUTPUT, doc)
+        for input_file in args.INPUT:
+            parser = EbParserFactory.create(input_file)
+            parser.parse_xdm(input_file, doc)
+
+        if args.runnable:
+            writer = RteRunnableEntityXlsWriter()
+            writer.write(args.OUTPUT, doc)
+        else:
+            writer = RteXdmXlsWriter()
+            writer.write(args.OUTPUT, doc)
         
     except Exception as e:
         logger.error(e)

eb_model/models/__init__.py

@@ -1,3 +1,5 @@
 from .abstract import *
 from .os_xdm import *
+from .rte_xdm import *
 from .eb_doc import *
+from .importer_xdm import *

eb_model/models/abstract.py

@@ -1,35 +1,34 @@
 from abc import ABCMeta
-from typing import Dict, List
-
+from typing import Dict
+import re
 
 class EcucObject(metaclass=ABCMeta):
     def __init__(self, parent, name) -> None:
         if type(self) == EcucObject:
             raise ValueError("Abstract EcucObject cannot be initialized.")
         
-        self.Name = name
-        self.Parent = parent                # type: EcucObject
+        self.name = name
+        self.parent = parent                # type: EcucObject
 
         if isinstance(parent, EcucContainer):
             parent.addElement(self)
 
     def getName(self):
-        return self.Name
+        return self.name
 
     def setName(self, value):
-        self.Name = value
+        self.name = value
         return self
 
     def getParent(self):
-        return self.Parent
+        return self.parent
 
     def setParent(self, value):
-        self.Parent = value
+        self.parent = value
         return self
 
     def getFullName(self) -> str:
-        return self.Parent.getFullName() + "/" + self.Name
-
+        return self.parent.getFullName() + "/" + self.name
 
 class EcucContainer(EcucObject):
     def __init__(self, parent, name) -> None:
@@ -43,7 +42,7 @@ class EcucContainer(EcucObject):
     
     def addElement(self, object: EcucObject):
         if object.getName() not in self.elements:
-            object.Parent = self
+            object.parent = self
             self.elements[object.getName()] = object
 
         return self
@@ -62,5 +61,79 @@ class EcucContainer(EcucObject):
         return self.elements[name]
 
 class EcucRefType:
-    def __init__(self) -> None:
-        self.link  = ""
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+    def getValue(self) -> str:
+        return self.value
+
+    def setValue(self, value: str):
+        self.value = value
+        return self
+    
+    def __str__(self) -> str:
+        return self.value
+    
+    def getShortName(self) -> str:
+        if self.value is None:
+            raise ValueError("Invalid value of EcucRefType")
+        m = re.match(r'\/[\w\/]+\/(\w+)', self.value)
+        if m:
+            return m.group(1)
+        return self.value
+    
+class Version:
+    def __init__(self):
+        self.majorVersion = None
+        self.minorVersion = None
+        self.patchVersion = None
+
+    def getMajorVersion(self):
+        return self.majorVersion
+
+    def setMajorVersion(self, value):
+        if value is not None:
+            self.majorVersion = value
+        return self
+
+    def getMinorVersion(self):
+        return self.minorVersion
+
+    def setMinorVersion(self, value):
+        if value is not None:
+            self.minorVersion = value
+        return self
+
+    def getPatchVersion(self):
+        return self.patchVersion
+
+    def setPatchVersion(self, value):
+        if value is not None:
+            self.patchVersion = value
+        return self
+    
+    def getVersion(self) -> str:
+        return "%d.%d.%d" % (self.majorVersion, self.minorVersion, self.patchVersion)
+
+class Module(EcucContainer):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.arVersion = Version()
+        self.swVersion = Version()
+
+    def getArVersion(self):
+        return self.arVersion
+
+    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

eb_model/models/eb_doc.py

@@ -1,52 +1,80 @@
-
-from typing import List
-
+from .importer_xdm import SystemDescriptionImporter
+from .rte_xdm import Rte
 from .os_xdm import Os
 from .abstract import EcucContainer, EcucObject
 
 
-class EBModel(EcucContainer):
+class AbstractModel(EcucContainer):
+    def getFullName(self):
+        return self.name
+
+    def clear(self):
+        self.elements = {}
+
+    def find_object(self, referred_name: str, element: EcucContainer) -> EcucObject:
+        name_list = referred_name.split("/")
+        # element = EBModel.getInstance()
+        for name in name_list:
+            if (name == ""):
+                continue
+            element = element.getElement(name)
+            if (element is None):
+                return element
+            #    raise ValueError("The %s of reference <%s> does not exist." % (short_name, referred_name))
+        return element
+
+
+class EBModel(AbstractModel):
     __instance = None
 
     @staticmethod
     def getInstance():
-        if (EBModel.__instance == None):
+        if (EBModel.__instance is None):
             EBModel()
         return EBModel.__instance
 
     def __init__(self):
-        if (EBModel.__instance != None):
+        if (EBModel.__instance is not None):
             raise Exception("The EBModel is singleton!")
         
         EcucContainer.__init__(self, None, "")
         EBModel.__instance = self
 
-    def getFullName(self):
-        return self.Name
-
-    def clear(self):
-        self.elements = {}
-
     def find(self, referred_name: str) -> EcucObject:
-        name_list = referred_name.split("/")
-        element = EBModel.getInstance()
-        for name in name_list:
-            if (name == ""):
-                continue
-            element = element.getElement(name)
-            if (element == None):
-                return element
-            #    raise ValueError("The %s of reference <%s> does not exist." % (short_name, referred_name))
-        return element
-    
+        return self.find_object(referred_name, EBModel.getInstance())
+
     def getOs(self) -> Os:
         container = EcucContainer(self, "Os")
-        os = Os(container)
+        Os(container)
         return self.find("/Os/Os")
-        
-
     
+    def getRte(self) -> Rte:
+        container = EcucContainer(self, "Rte")
+        Rte(container)
+        return self.find("/Rte/Rte")
+
 
+class PreferenceModel(AbstractModel):
+    __instance = None
+
+    @staticmethod
+    def getInstance():
+        if (PreferenceModel.__instance is None):
+            PreferenceModel()
+        return PreferenceModel.__instance
+
+    def __init__(self):
+        if (PreferenceModel.__instance is not None):
+            raise Exception("The PreferenceModel is singleton!")
         
+        EcucContainer.__init__(self, None, "")
+        PreferenceModel.__instance = self
 
-    
+        container = EcucContainer(self, "ImporterExporterAdditions")
+        SystemDescriptionImporter(container, "SystemDescriptionImporters")
+
+    def find(self, referred_name: str) -> EcucObject:
+        return self.find_object(referred_name, PreferenceModel.getInstance())
+
+    def getSystemDescriptionImporter(self) -> SystemDescriptionImporter:
+        return self.find("/ImporterExporterAdditions/SystemDescriptionImporters")

eb_model/models/eclipse_project.py

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

eb_model/models/importer_xdm.py

@@ -0,0 +1,115 @@
+from typing import Dict, List
+
+from ..models.eclipse_project import Link
+from ..models.abstract import EcucObject
+import glob
+import os
+import re
+import logging
+
+class SystemDescriptionImporter(EcucObject):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+        
+        self.logger = logging.getLogger()
+        self.inputFiles = []        # type: List[str]
+
+    def getInputFiles(self):
+        return self.inputFiles
+
+    def addInputFile(self, value: str):
+        self.logger.debug("Add the file <%s>" % value)
+        self.inputFiles.append(value)
+        return self
+    
+    def parseWildcard(self, filename: str) -> List[str]:
+        file_list = []
+        for file in glob.iglob(filename, recursive=True):
+            file_list.append(file)
+        return file_list
+    
+    def getParsedInputFiles(self, params = {}) -> List[str]:
+        file_list = []
+        for input_file in self.inputFiles:
+            m = re.match(r'\$\{(env_var:\w+)\}(.*)', input_file)
+            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)))
+            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))):
+                            file_list.append(file_name)
+                    else:
+                        file_list.append(os.path.realpath(os.path.join(params['base_path'], input_file)))
+                else:
+                    file_list.append(os.path.realpath(os.path.join(params['base_path'], input_file)))
+            else:
+                file_list.append(input_file)
+        return file_list
+    
+    def getAllPaths(self, path :str) -> List[str]:
+        path_segments = path.split("/")
+
+        result = []
+        long_path = ""
+        for path_segment in path_segments:
+            if path_segment == "..":
+                continue
+            if long_path == "":
+                long_path = path_segment
+            else:
+                long_path = long_path +"/" + path_segment
+            result.append(long_path)
+        return result
+    
+    def getNameByPath(self, path : str):              
+        path_segments = path.split("/")
+
+        result = []
+        count = 0
+        for path_segment in path_segments:
+            if path_segment == "..":
+                count += 1
+            else:
+                result.append(path_segment)
+        
+        return (count , "/".join(result))
+    
+    def getLinks(self, file_list: List[str]) -> List[Link]:
+        path_sets = {}             # type: Dict[str, List[str]] 
+        path_segment_sets = []
+
+        for file in file_list:
+            path, basename = os.path.split(file)
+            path = os.path.relpath(path).replace("\\", "/")
+            if path not in path_sets:
+                path_sets[path] = []
+            
+            # To avoid the duplicate file
+            if basename not in path_sets[path]:
+                path_sets[path].append(basename)
+
+        links = []
+        for name in path_sets:
+            for path_segment in self.getAllPaths(name):
+                if path_segment not in path_sets:
+                    if path_segment not in path_segment_sets:
+                        path_segment_sets.append(path_segment)
+        
+        for segment in path_segment_sets:
+            link = Link(segment, 2, "virtual:/virtual")
+            links.append(link)
+        
+        for path_set in path_sets:
+            for basename in path_sets[path_set]:
+                path = os.path.relpath(os.path.join(path_set, basename)).replace("\\", "/")
+                count, name = self.getNameByPath(path)
+                link = Link(name, 1, "PARENT-%d-PROJECT_LOC/%s" % (count, name))
+                links.append(link)
+        
+        return links
+
+