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

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/__init__.py

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

py_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

py_eb_model/models/__init__.py

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

py_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  = ""

py_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")
+        
+
+    
+
+        
+
+    

py_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

py_eb_model/parser/__init__.py

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