py-eb-model 0.8.0__py3-none-any.whl

eb_model/__init__.py

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

eb_model/cli/os_xdm_2_xls_cli.py

@@ -0,0 +1,59 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+
+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.")
+
+    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, 'os_xdm_2_xls.log')
+
+    if os.path.exists(log_file):
+        os.remove(log_file)
+
+    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)
+
+    logger.addHandler(file_handler)
+    logger.addHandler(stdout_handler)    
+
+    try:
+        doc = EBModel.getInstance()
+        parser = OsXdmParser()
+        writer = OsXdmXlsWriter()
+
+        parser.parse(args.INPUT, doc)
+        writer.write(args.OUTPUT, doc)
+        
+    except Exception as e:
+        logger.error(e)
+        raise e

eb_model/models/__init__.py

@@ -0,0 +1,3 @@
+from .abstract import *
+from .os_xdm import *
+from .eb_doc import *

eb_model/models/abstract.py

@@ -0,0 +1,66 @@
+from abc import ABCMeta
+from typing import Dict, List
+
+
+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
+
+        if isinstance(parent, EcucContainer):
+            parent.addElement(self)
+
+    def getName(self):
+        return self.Name
+
+    def setName(self, value):
+        self.Name = value
+        return self
+
+    def getParent(self):
+        return self.Parent
+
+    def setParent(self, value):
+        self.Parent = value
+        return self
+
+    def getFullName(self) -> str:
+        return self.Parent.getFullName() + "/" + self.Name
+
+
+class EcucContainer(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(self.elements)
+    
+    def addElement(self, object: EcucObject):
+        if object.getName() not in self.elements:
+            object.Parent = self
+            self.elements[object.getName()] = object
+
+        return self
+    
+    def removeElement(self, key):
+        if key not in self.elements:
+            raise KeyError("Invalid key <%s> for removing element" % key)
+        self.elements.pop(key)
+
+    def getElementList(self):
+        return self.elements.values()
+
+    def getElement(self, name: str) -> EcucObject:
+        if (name not in self.elements):
+            return None
+        return self.elements[name]
+
+class EcucRefType:
+    def __init__(self) -> None:
+        self.link  = ""

eb_model/models/eb_doc.py

@@ -0,0 +1,52 @@
+
+from typing import List
+
+from .os_xdm import Os
+from .abstract import EcucContainer, EcucObject
+
+
+class EBModel(EcucContainer):
+    __instance = None
+
+    @staticmethod
+    def getInstance():
+        if (EBModel.__instance == None):
+            EBModel()
+        return EBModel.__instance
+
+    def __init__(self):
+        if (EBModel.__instance != 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
+    
+    def getOs(self) -> Os:
+        container = EcucContainer(self, "Os")
+        os = Os(container)
+        return self.find("/Os/Os")
+        
+
+    
+
+        
+
+    

eb_model/models/os_xdm.py

@@ -0,0 +1,220 @@
+from typing import List
+
+from ..models.abstract import EcucObject
+
+class OsApplication:
+    def __init__(self) -> None:
+        pass
+
+class OsCounter:
+    def __init__(self) -> None:
+        pass
+
+class OsResource:
+    def __init__(self) -> None:
+        pass
+
+class OsIsrResourceLock:
+    def __init__(self) -> None:
+        self.OsIsrResourceLockBudget = None
+        self.OsIsrResourceLockResourceRef = None
+
+
+class OsIsrTimingProtection:
+    def __init__(self) -> None:
+        self.OsIsrAllInterruptLockBudget = None
+        self.OsIsrExecutionBudget = None
+        self.OsIsrOsInterruptLockBudget = None
+        self.OsIsrTimeFrame = None                 
+        self.OsIsrResourceLock = OsIsrResourceLock()
+
+class OsIsr(EcucObject):
+    '''
+    The OsIsr container represents an ISO 17356 interrupt service routine.
+    '''
+    
+    OS_ISR_CATEGORY_1 = "CATEGORY_1"       # Interrupt is of category 1
+    OS_ISR_CATEGORY_2 = "CATEGORY_2"       # Interrupt is of category 2
+
+    def __init__(self) -> None:
+        self.OsIsrCategory = None
+        self.OsIsrPeriod = None
+        self.OsIsrResourceRef = None
+        self.OsMemoryMappingCodeLocationRef = None
+        self.OsIsrTimingProtection = OsIsrTimingProtection()    # type: OsIsrTimingProtection
+
+        self.OsIsrPriority = None
+        self.OsStacksize = None
+
+    def getOsIsrCategory(self):
+        return self.OsIsrCategory
+
+    def setOsIsrCategory(self, value):
+        self.OsIsrCategory = value
+        return self
+
+    def getOsIsrPeriod(self):
+        return self.OsIsrPeriod
+
+    def setOsIsrPeriod(self, value):
+        self.OsIsrPeriod = value
+        return self
+
+    def getOsIsrResourceRef(self):
+        return self.OsIsrResourceRef
+
+    def setOsIsrResourceRef(self, value):
+        self.OsIsrResourceRef = value
+        return self
+
+    def getOsMemoryMappingCodeLocationRef(self):
+        return self.OsMemoryMappingCodeLocationRef
+
+    def setOsMemoryMappingCodeLocationRef(self, value):
+        self.OsMemoryMappingCodeLocationRef = value
+        return self
+
+    def getOsIsrTimingProtection(self):
+        return self.OsIsrTimingProtection
+
+    def setOsIsrTimingProtection(self, value):
+        self.OsIsrTimingProtection = value
+        return self
+    
+    def getOsIsrPriority(self):
+        return self.OsIsrPriority
+
+    def setOsIsrPriority(self, value):
+        self.OsIsrPriority = value
+        return self
+
+    def getOsStacksize(self):
+        return self.OsStacksize
+
+    def setOsStacksize(self, value):
+        self.OsStacksize = value
+        return self
+
+class OsTaskAutostart:
+    def __init__(self) -> None:
+        self.OsTaskAppModeRef = None
+
+class OsTaskResourceLock:
+    def __init__(self) -> None:
+        self.OsTaskResourceLockBudget = None
+
+class OsTaskTimingProtection:
+    def __init__(self) -> None:
+        self.OsTaskAllInterruptLockBudget = None
+        self.OsTaskExecutionBudget = None
+        self.OsTaskOsInterruptLockBudget = None
+        self.OsTaskTimeFrame = None
+
+class OsTimeConstant:
+    def __init__(self) -> None:
+        self.OsTimeValue
+
+class OsTask(EcucObject):
+
+    FULL = "FULL"   # Task is preemptable.
+    NON  = "NON"    # Task is not preemptable.
+
+    def __init__(self) -> None:
+        self.OsTaskActivation = None                    # type: int 
+        self.OsTaskPeriod = 0.0                         # type: float
+        self.OsTaskPriority = None                      # type: int
+        self.OsTaskSchedule = ""
+        self.OsStacksize = 0                            # type: int
+        self.OsMemoryMappingCodeLocationRef = None
+        self.OsTaskAccessingApplication = None
+        self.OsTaskEventRef = None
+        self.OsTaskResourceRef = None
+
+    def getOsTaskActivation(self):
+        return self.OsTaskActivation
+
+    def setOsTaskActivation(self, value):
+        self.OsTaskActivation = value
+        return self
+
+    def getOsTaskPeriod(self):
+        return self.OsTaskPeriod
+
+    def setOsTaskPeriod(self, value):
+        self.OsTaskPeriod = value
+        return self
+
+    def getOsTaskPriority(self):
+        return self.OsTaskPriority
+
+    def setOsTaskPriority(self, value):
+        self.OsTaskPriority = value
+        return self
+
+    def getOsTaskSchedule(self):
+        return self.OsTaskSchedule
+
+    def setOsTaskSchedule(self, value):
+        self.OsTaskSchedule = value
+        return self
+    
+    def getOsStacksize(self):
+        return self.OsStacksize
+
+    def setOsStacksize(self, value):
+        self.OsStacksize = value
+        return self
+
+    def getOsMemoryMappingCodeLocationRef(self):
+        return self.OsMemoryMappingCodeLocationRef
+
+    def setOsMemoryMappingCodeLocationRef(self, value):
+        self.OsMemoryMappingCodeLocationRef = value
+        return self
+
+    def getOsTaskAccessingApplication(self):
+        return self.OsTaskAccessingApplication
+
+    def setOsTaskAccessingApplication(self, value):
+        self.OsTaskAccessingApplication = value
+        return self
+
+    def getOsTaskEventRef(self):
+        return self.OsTaskEventRef
+
+    def setOsTaskEventRef(self, value):
+        self.OsTaskEventRef = value
+        return self
+
+    def getOsTaskResourceRef(self):
+        return self.OsTaskResourceRef
+
+    def setOsTaskResourceRef(self, value):
+        self.OsTaskResourceRef = value
+        return self
+    
+    def IsPreemptable(self) -> bool:
+        if self.OsTaskSchedule == OsTask.FULL:
+            return True
+        return False
+
+class Os(EcucObject):
+    def __init__(self, parent) -> None:
+        super().__init__(parent, "Os")
+
+        self.osTasks = []                               # type: List[OsTask]
+        self.osIsrs = []                                # type: List[OsIsr]
+
+    def getOsTaskList(self) -> List[OsTask]:
+        return self.osTasks
+    
+    def addOsTask(self, os_task: OsTask):
+        self.osTasks.append(os_task)
+        return self
+
+    def getOsIsrList(self) -> List[OsIsr]:
+        return self.osIsrs
+    
+    def addOsIsr(self, os_isr: OsIsr):
+        self.osIsrs.append(os_isr)
+        return self

eb_model/parser/__init__.py

@@ -0,0 +1 @@
+from .os_xdm_parser import OsXdmParser

eb_model/parser/eb_parser.py

@@ -0,0 +1,147 @@
+#from xml.etree import cElementTree as ET
+import xml.etree.ElementTree as ET
+import re
+
+from abc import ABCMeta
+from typing import List
+
+class EBModelParser(metaclass = ABCMeta):
+
+    def __init__(self) -> None:
+        self.ns = {}
+
+        if type(self) == "EBModelParser":
+            raise ValueError("Abstract EBModelParser cannot be initialized.")
+
+    def validate_root(self, element: ET.Element):
+        if (element.tag != "{%s}%s" % (self.ns[''], "datamodel")):
+            raise ValueError("This document <%s> is not EB xdm format" % element.tag)
+
+    def read_ref_raw_value(self, value):
+        '''
+            Internal function and please call _read_ref_value instead of it
+        '''
+        #match = re.match(r'ASPath.*\/(.*)', value)
+        match = re.match(r'ASPath:(.*)', value)
+        if (match):
+            return match.group(1)
+        return value
+
+    def read_value(self, parent: ET.Element, name: str) -> str:
+        tag = parent.find(".//d:var[@name='%s']" % name, self.ns)
+        if tag == None:
+            raise KeyError("XPath d:var[@name='%s'] is invalid" % name)
+        if (tag.attrib['type'] == 'INTEGER'):
+            return int(tag.attrib['value'])
+        elif (tag.attrib['type'] == "FLOAT"):
+            return float(tag.attrib['value'])
+        elif (tag.attrib['type'] == 'BOOLEAN'):
+            if (tag.attrib['value'] == 'true'):
+                return True
+            else:
+                return False
+        else:
+            return tag.attrib['value']
+
+    def read_optional_value(self, parent: ET.Element, name: str, default_value = None) -> str:
+        tag = parent.find(".//d:var[@name='%s']" % name, self.ns)
+        if tag is None:
+            return default_value
+        if ('value' not in tag.attrib):
+            return default_value
+        return tag.attrib['value']
+
+    def find_choice_tag(self, parent: ET.Element, name: str) -> ET.Element:
+        return parent.find(".//d:chc[@name='%s']" % name, self.ns)
+
+    def read_choice_value(self, parent: ET.Element, name: str) -> str:
+        tag = self.find_choice_tag(parent, name)
+        return tag.attrib['value']
+
+    def read_ref_value(self, parent: ET.Element, name: str) -> str:
+        tag = parent.find(".//d:ref[@name='%s']" % name, self.ns)
+        return self.read_ref_raw_value(tag.attrib['value'])
+
+    def read_optional_ref_value(self, parent: ET.Element, name: str) -> str:
+        tag = parent.find(".//d:ref[@name='%s']" % name, self.ns)
+        enable = self.read_attrib(tag, 'ENABLE')
+        if (enable == 'false'):
+            return ""
+        return self.read_ref_raw_value(tag.attrib['value'])
+
+    def read_ref_value_list(self, parent: ET.Element, name: str) -> List[str]:
+        ref_value_list = []
+        for tag in parent.findall(".//d:lst[@name='%s']/d:ref" % name, self.ns):
+            ref_value_list.append(
+                self.read_ref_raw_value(tag.attrib['value']))
+        return ref_value_list
+
+    def find_ctr_tag_list(self, parent: ET.Element, name: str) -> List[ET.Element]:
+        return parent.findall(".//d:lst[@name='%s']/d:ctr" % name, self.ns)
+    
+    def find_chc_tag_list(self, parent: ET.Element, name: str) -> List[ET.Element]:
+        return parent.findall(".//d:lst[@name='%s']/d:chc" % name, self.ns)
+
+    def find_ctr_tag(self, parent: ET.Element, name: str) -> ET.Element:
+        '''
+        Read the child ctr tag. 
+        '''
+        tag = parent.find(".//d:ctr[@name='%s']" % name, self.ns)
+        if tag is None:
+            return None
+        enable = self.read_attrib(tag, 'ENABLE')
+        # ctr has the value if 
+        #   1. enable attribute do not exist
+        #   2. enable attribute is not false
+        if enable is not None and enable == "false":    
+            return None
+        return tag
+
+    def create_ctr_tag(self, name: str, type: str)-> ET.Element:
+        ctr_tag = ET.Element("d:ctr")
+        ctr_tag.attrib['name'] = name
+        ctr_tag.attrib['type'] = type
+        return ctr_tag
+
+    def create_ref_tag(self, name:str, type: str, value = "")-> ET.Element:
+        ref_tag = ET.Element("d:ref")
+        ref_tag.attrib['name'] = name
+        ref_tag.attrib['type'] = type
+        if (value != ""):
+            ref_tag.attrib['value'] = "ASPath:%s" % value
+        return ref_tag
+
+    def create_choice_tag(self, name:str, type:str, value: str)-> ET.Element:
+        choice_tag = ET.Element("d:chc")
+        choice_tag.attrib['name'] = name
+        choice_tag.attrib['type'] = type
+        choice_tag.attrib['value'] = value
+        return choice_tag
+
+    def create_attrib_tag(self, name:str, value: str) -> ET.Element:
+        attrib_tag = ET.Element("a:a")
+        attrib_tag.attrib['name'] = name
+        attrib_tag.attrib['value'] = value
+        return attrib_tag
+
+    def create_ref_lst_tag(self, name:str, type:str = "", ref_list: List[str] = []) -> ET.Element:
+        lst_tag = ET.Element("d:lst")
+        lst_tag.attrib['name'] = name
+        for ref in ref_list:
+            ref_tag = ET.Element("d:ref")
+            ref_tag.attrib['type'] = type
+            ref_tag.attrib['value'] = "ASPath:%s" % ref
+            lst_tag.append(ref_tag)
+        return lst_tag
+
+    def find_lst_tag(self, parent: ET.Element, name: str) -> ET.Element:
+        return parent.find(".//d:lst[@name='%s']" % name, self.ns)
+
+    def read_attrib(self, parent: ET.Element, name: str) -> str:
+        attrib_tag = parent.find(".//a:a[@name='%s']" % name, self.ns)
+        if attrib_tag is None:
+            return None
+        return attrib_tag.attrib['value']
+
+    def _read_namespaces(self, xdm: str):
+        self.ns = dict([node for _, node in ET.iterparse(xdm, events=['start-ns'])])

eb_model/parser/os_xdm_parser.py

@@ -0,0 +1,43 @@
+from typing import List, Dict
+import xml.etree.ElementTree as ET
+import re
+
+from ..models.abstract import EcucContainer, EcucObject
+from ..models.eb_doc import EBModel
+from ..models.os_xdm import Os, OsApplication, OsCounter, OsResource, OsTask, OsIsr
+from .eb_parser import EBModelParser
+
+class OsXdmParser(EBModelParser):
+    def __init__(self, ) -> None:
+        super().__init__()
+
+    def parse(self, filename: str, doc: EBModel):
+        self._read_namespaces(filename)
+        tree = ET.parse(filename)
+        self.root_tag = tree.getroot()
+        self.validate_root(self.root_tag)
+
+        self.read_os_tasks(doc.getOs())
+        self.read_os_isrs(doc.getOs())
+
+    def read_os_tasks(self, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(self.root_tag, 'OsTask'):
+            os_task = OsTask()
+            os_task.setName(ctr_tag.attrib['name']) \
+                .setOsTaskPriority(self.read_value(ctr_tag, "OsTaskPriority")) \
+                .setOsTaskActivation(self.read_value(ctr_tag, "OsTaskActivation")) \
+                .setOsTaskSchedule(self.read_value(ctr_tag, "OsTaskSchedule")) \
+                .setOsStacksize(self.read_optional_value(ctr_tag, "OsStacksize", 0))
+            os.addOsTask(os_task)
+    
+    def read_os_isrs(self, os: Os):
+        for ctr_tag in self.find_ctr_tag_list(self.root_tag, 'OsIsr'):
+            os_isr = OsIsr()
+            os_isr.setName(ctr_tag.attrib['name']) \
+                .setOsIsrCategory(self.read_value(ctr_tag, "OsIsrCategory")) \
+                .setOsIsrPeriod(self.read_optional_value(ctr_tag, "OsIsrPeriod", 0.0)) \
+                .setOsStacksize(self.read_value(ctr_tag, "OsStacksize")) \
+                .setOsIsrPriority(self.read_optional_value(ctr_tag, "OsIsrPriority"))
+
+            os.addOsIsr(os_isr)
+    

eb_model/reporter/__init__.py

@@ -0,0 +1 @@
+from .excel_reporter.os_xdm import *

eb_model/reporter/excel_reporter/abstract.py

@@ -0,0 +1,43 @@
+import logging
+from openpyxl import Workbook
+from openpyxl.worksheet.worksheet import Worksheet
+
+class ExcelReporter:
+    def __init__(self) -> None:
+        self.wb = Workbook()
+        self._logger = logging.getLogger()
+    
+    def write_revision(self):
+        sheet = self.wb['Sheet']
+        sheet.title = "History"
+
+        title_rows = ["When", "Who", "Version", "History"]
+        self.write_title_row(sheet, title_rows)
+
+    def auto_width(self, worksheet: Worksheet):
+        dims = {}
+        for row in worksheet.rows:
+            for cell in row:
+                if cell.value:
+                    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
+
+    def write_title_row(self, sheet: Worksheet, title_row):
+        for idx in range(0, len(title_row)):
+            cell = sheet.cell(row=1, column=idx + 1)
+            cell.value = title_row[idx]
+
+    def write_cell(self, sheet, row, column, value, format = None):
+        cell = sheet.cell(row = row, column=column) 
+        cell.value = value
+        if (format != None):
+            if ('alignment' in format):
+                cell.alignment = format['alignment']
+            if ('number_format' in format):
+                cell.number_format = format['number_format']
+
+    def save(self, name: str):
+        self.wb.save(name)
+

eb_model/reporter/excel_reporter/os_xdm.py

@@ -0,0 +1,44 @@
+from ...models.eb_doc import EBModel
+from .abstract import ExcelReporter
+
+class OsXdmXlsWriter(ExcelReporter):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def write_os_tasks(self, doc: EBModel):
+        sheet = self.wb.create_sheet("OsTask", 0)
+
+        title_row = ["Name", "OsTaskActivation", "OsTaskPriority", "OsTaskSchedule", "OsStacksize"]
+        self.write_title_row(sheet, title_row)
+
+        row = 2
+        for os_task in doc.getOs().getOsTaskList():
+            self.write_cell(sheet, row, 1, os_task.getName())
+            self.write_cell(sheet, row, 2, os_task.getOsTaskActivation())
+            self.write_cell(sheet, row, 3, os_task.getOsTaskPriority())
+            self.write_cell(sheet, row, 4, os_task.getOsTaskSchedule())
+            self.write_cell(sheet, row, 5, os_task.getOsStacksize())
+            row += 1
+
+        self.auto_width(sheet)
+
+    def write_os_isrs(self, doc: EBModel):
+        sheet = self.wb.create_sheet("OsIsr", 0)
+
+        title_row = ["Name", "OsIsrCategory", "OsStacksize"]
+        self.write_title_row(sheet, title_row)
+
+        row = 2
+        for os_isr in doc.getOs().getOsIsrList():
+            self.write_cell(sheet, row, 1, os_isr.getName())
+            self.write_cell(sheet, row, 2, os_isr.getOsIsrCategory())
+            self.write_cell(sheet, row, 3, os_isr.getOsStacksize())
+            row += 1
+
+        self.auto_width(sheet)
+
+    def write(self, filename, doc: EBModel):
+        self.write_os_tasks(doc)
+        self.write_os_isrs(doc)
+
+        self.save(filename)

eb_model/reporter/markdown.py

@@ -0,0 +1,40 @@
+import logging
+
+from ..models import OsAutoSARDoc, OsApplication, BswModuleInstance
+
+class OsApplicationMarkdownWriter:
+    def __init__(self) -> None:
+        self._logger = logging.getLogger()
+
+    def _write_line(self, f_in, line: str):
+        f_in.write(line + "\n")
+
+    def _write_instances(self, f_in, os_application: OsApplication):
+        self._write_line(f_in, "|Instance|Instance Type|Component Type|ASIL|Runnable|Task")
+        self._write_line(f_in, "|--|--|--|--|--|--|")
+        for instance in os_application.get_instances():
+            if isinstance(instance, BswModuleInstance):
+                component_type = "BSW Module"
+            else:
+                component_type = "SW Component"
+            if len(instance.get_mappings()) > 0:
+                package = instance.get_mappings()[0].package
+            else:
+                package = ""
+            self._write_line(f_in, "|%s|%s|%s|%s|%s|%s|" % (instance.name, instance.type, component_type , "", package, ""))
+            for mapping in instance.get_mappings():
+                self._write_line(f_in, "|%s|%s|%s|%s|%s|%s|" % ("", "", "", "", mapping.event, mapping.task))
+
+
+    def _write_os_applications(self, f_in, doc: OsAutoSARDoc):
+        self._write_line(f_in, "# OS Application")
+        for os_app in doc.get_os_applications():
+            self._write_line(f_in, "## %s" % os_app.name)
+            self._write_instances(f_in, os_app)
+                
+
+    def write(self, filename: str, doc: OsAutoSARDoc):
+        with open(filename, 'w') as f_in:
+            self._write_os_applications(f_in, doc)
+            
+

eb_model/tests/models/test_eb_model.py

@@ -0,0 +1,25 @@
+import pytest
+from ...models.eb_doc import EBModel
+
+class TestEBModel:
+
+    def test_ebmodel_singleton_exception(self):
+        EBModel.getInstance()
+        with pytest.raises(Exception) as err:
+            EBModel()
+        assert(str(err.value) == "The EBModel is singleton!")
+
+    def test_cannot_find_element(self):
+        document = EBModel.getInstance()
+        assert(document.find("/os/os") == None)
+
+    def test_ebmodel(self):
+        document = EBModel.getInstance()
+        assert (isinstance(document, EBModel))
+        assert (isinstance(document, EBModel))
+        assert (document.getFullName() == "")
+
+    def test_ebmodel_get_os(self):
+        document = EBModel.getInstance()
+        os = document.getOs()
+        assert (os.getFullName() == "/Os/Os")

eb_model/tests/models/test_ecuc_container.py

@@ -0,0 +1,22 @@
+
+from ...models.eb_doc import EBModel
+from ...models.abstract import EcucContainer, EcucObject
+
+class TestEcucContainer:
+
+    def test_create_container(self):
+        document = EBModel.getInstance()
+        os_container = EcucContainer(document, "Os")
+
+        assert (os_container.getFullName() == "/Os")
+        assert (os_container.getParent() == document)
+        assert (os_container.getName() == "Os")
+
+        container = document.find("/Os")
+
+        assert (container.getFullName() == "/Os")
+        assert (container.getParent() == document)
+        assert (container.getName() == "Os")
+
+        assert(isinstance(container, EcucContainer))
+        assert(isinstance(container, EcucObject))

py_eb_model-0.8.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 melodypapa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

py_eb_model-0.8.0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: py-eb-model
+Version: 0.8.0
+Summary: The parser for EB XDM file
+Home-page: 
+Author: melodypapa
+Author-email: melodypapa@outlook.com
+License: proprietary
+Keywords: EB Tresos XDM
+Classifier: Development Status :: 1 - Planning
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openpyxl
+Provides-Extra: pytest
+Requires-Dist: pytest-cov ; extra == 'pytest'
+
+# 1. py-eb-model
+
+1. The python parser engine for EB Tresos Xdm file.
+2. To support EB Tresos data model with python.
+
+# 2. How to create the distribution and upload to pypi
+
+1. Run `python setup.py bdist_wheel` to generate distribution
+2. Run `twine check dist/*` to check the validation of distribution
+3. Run `twine upload dist/*` to upload to pypi repository
+4. Check the website https://pypi.org/project/armodel/ to find out it works or not
+
+And more details can be found at https://packaging.python.org/  
+
+# 3. CLI 
+
+## 3.1. os-task-xlsx
+
+Extract the Os Task information from os.xdm and then report all to Excel file.
+
+```bash
+os-xdm-xlsx data/Os.xdm data/Os.xlsx
+```
+
+**Result:**
+
+1. OsIsrs
+
+![](doc/ox-xdm-xlsx/excel_os_isrs.png)
+
+2. OsTasks
+
+![](doc/ox-xdm-xlsx/excel_os_tasks.png)
+
+
+# 4. Change History
+
+**Version 1.0.0** 
+
+1. Create the basic model for EB xdm. (Issue #1)
+2. Support to extract the Os Tasks/Isrs from EB xdm and store them in the excel files. (Issue #1)
+

py_eb_model-0.8.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+eb_model/__init__.py,sha256=u3VUin2V_1eExLd9NIpw_LGHIAwaG2vEoyhssZurrvM,69
+eb_model/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eb_model/cli/os_xdm_2_xls_cli.py,sha256=BzeFhyWHbG57qieDNESaXYggszHSy17uwCeXvEfrbCQ,1629
+eb_model/models/__init__.py,sha256=_WDgFMwl8w3WnI4ZpjHXMdJVdmqPRpwJ8GLMb4_RGk0,71
+eb_model/models/abstract.py,sha256=JS_aVD3vPWbYTTpPVo7POilqnXVixVCqbdbMel8Rt7s,1901
+eb_model/models/eb_doc.py,sha256=5SbUrleAKPQaHSoOlvHwVxpKLdxVlksB4lxXTsKhvro,1296
+eb_model/models/os_xdm.py,sha256=8Zbl4zPvX4V5cemwVej3QlIe7xTw61d6shOR0jWHU58,6274
+eb_model/parser/__init__.py,sha256=5qHXKEfEMcE0WvvinJQu_21bNzWFdXTJxUudy-85DEE,40
+eb_model/parser/eb_parser.py,sha256=OQ94JBOHuX4FleQDgOpvI-VMU8IsM4S7lz0onmPFro0,5840
+eb_model/parser/os_xdm_parser.py,sha256=ZzS45j_0R6kj1Og0iXKP2IupwGLkNrbzPhPrqNFRvXs,1834
+eb_model/reporter/__init__.py,sha256=H8D_23UwJi1Ph6yjBfZhxWVbu9ci5_O4471gqXGiZCM,36
+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=BOuLhWwwTwqBzErtmwPrelB1iByMfZP9haFmg9ayFQw,1488
+eb_model/reporter/excel_reporter/os_xdm.py,sha256=WGMxK0PYxi9J5fUZ-EeiiM8NBpIg2WyxRsrN-gK37YE,1589
+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=9CQ503ZaMf3LhBBmw8Yvoa7HUWTBctTsgvrGxKOAKZA,798
+eb_model/tests/models/test_ecuc_container.py,sha256=lZmtXwPMz9T52WFduTgFy16fO2agjSW-Rl2cVypM86s,722
+py_eb_model-0.8.0.dist-info/LICENSE,sha256=I52rGS7W1IwAmYCUfqTpDaSHoFAdt7grcNiBhk-Z3eI,1088
+py_eb_model-0.8.0.dist-info/METADATA,sha256=xmKdk0hpGFM4s8wrqIGyYMgO_uPEtC0AOMnS-ditrxY,1633
+py_eb_model-0.8.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+py_eb_model-0.8.0.dist-info/entry_points.txt,sha256=KZ8zDEf2EQhJULVtV7pjWHfoNbrohMEE9xhMyRx7oIw,67
+py_eb_model-0.8.0.dist-info/top_level.txt,sha256=DGBNh6YW_x4RF_UoLKW3cKqb2SLnmfuEIZlkTewR66A,9
+py_eb_model-0.8.0.dist-info/RECORD,,

py_eb_model-0.8.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

py_eb_model-0.8.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+os-xdm-xlsx = eb_model.cli.os_xdm_2_xls_cli:main

py_eb_model-0.8.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+eb_model