armodel 1.3.0__py3-none-any.whl → 1.4.3__py3-none-any.whl

armodel/__init__.py

@@ -1,2 +1,3 @@
 from .models import *
-from .parser import ARXMLParser
+from .parser import *
+from .writer import *

armodel/cli/arxml_dump_cli.py

@@ -35,12 +35,12 @@ def show_type(indent: int, data_type: ImplementationDataType):
     print("%s-Implementation Type: %s (%s)" % (" " * indent, data_type.short_name, data_type.parent.full_name))
     print("%s                    : %s" % (" " * indent, data_type.category))
     if (data_type.sw_data_def_props != None):
-        if (data_type.sw_data_def_props.base_type_ref != None):
-            base_type_ref = data_type.sw_data_def_props.base_type_ref
+        if (data_type.sw_data_def_props.baseTypeRef != None):
+            base_type_ref = data_type.sw_data_def_props.baseTypeRef
             print("%s                    : %s (%s)" % (" " * indent, base_type_ref.value, base_type_ref.dest))
             
-        if (data_type.sw_data_def_props.implementation_data_type_ref != None):
-            implementation_data_type_ref = data_type.sw_data_def_props.implementation_data_type_ref
+        if (data_type.sw_data_def_props.implementationDataTypeRef != None):
+            implementation_data_type_ref = data_type.sw_data_def_props.implementationDataTypeRef
             print("%s                    : %s (%s)" % (" " * indent, implementation_data_type_ref.value, implementation_data_type_ref.dest))
 
 def show_data_type_mapping(indent: int, mapping_set: DataTypeMappingSet):
@@ -104,8 +104,8 @@ def show_bsw_internal_behavior(indent: int, behavior: BswInternalBehavior):
 
     for event in behavior.getBswTimingEvents():
         print("%s-%s" % (" " * (indent + 2), event.short_name))
-        print("%s-%s: %s" % (" " * (indent + 4), "StartsOnEventRef", event.starts_on_event_ref.value))
-        starts_on_event = document.find(event.starts_on_event_ref.value) # type: BswModuleEntity
+        print("%s-%s: %s" % (" " * (indent + 4), "StartsOnEventRef", event.startsOnEventRef.value))
+        starts_on_event = document.find(event.startsOnEventRef.value) # type: BswModuleEntity
         print("%s-%s: %s" % (" " * (indent + 4), "StartsOnEvent", starts_on_event.short_name))
         print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntryRef", starts_on_event.implemented_entry_ref.value))
         implemented_entry = document.find(starts_on_event.implemented_entry_ref.value) # type: BswModuleEntry
@@ -121,6 +121,8 @@ def show_bsw_module_description(indent: int, description: BswModuleDescription):
 def show_ar_package(indent: int, ar_package: ARPackage):
     print("%s-%s (Pkg)" % (" " * indent, ar_package.short_name))
      
+    for sub_package in ar_package.getARPackages():
+        show_ar_package(indent + 2, sub_package)
     #for data_type in ar_package.getImplementationDataTypes():
     #    show_type(indent + 2, data_type)
     #for mapping_set in ar_package.getDataTypeMappingSets():

armodel/cli/arxml_format_cli.py

@@ -0,0 +1,72 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+
+
+from ..models.ar_package import AUTOSAR
+from ..parser.arxml_parser import ARXMLParser
+from ..parser.connector_xlsx_parser import ConnectorXlsReader
+
+from ..lib import InputFileParser
+from ..writer import ARXMLWriter
+
+def main():
+    version = pkg_resources.require("armodel")[0].version
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-v", "--verbose", required= False, help= "Print debug information", action= "store_true")
+    ap.add_argument("-w", "--warning", required= False, help= "Skip the error and report it as warning message", action= "store_true")
+    ap.add_argument("INPUT", help = "The path of AUTOSAR ARXML file")
+    ap.add_argument("OUTPUT", help = "The path of output ARXML 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, 'arxml_format.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:
+        options = {}
+        if args.warning:
+            options['warning'] = True
+
+        document = AUTOSAR().getInstance()
+        parser = ARXMLParser(options)
+        parser.load(args.INPUT, document)
+
+        writer = ARXMLWriter()
+        writer.save(args.OUTPUT, document)
+        
+    except Exception as e:
+        #print(e)
+        logger.error(e)
+        raise e
+
+if __name__ == "__main__":
+    main()

armodel/cli/connector2xlsx_cli.py

@@ -0,0 +1,75 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+
+from armodel import AUTOSAR
+from armodel.parser import ARXMLParser
+
+from ..lib import InputFileParser
+from ..report import ConnectorXlsReport
+
+def main():
+    version = pkg_resources.require("armodel")[0].version
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-v", "--verbose", required= False, help= "Print debug information", action= "store_true")
+    ap.add_argument("-w", "--warning", required= False, help= "Skip the error and report it as warning message", action= "store_true")
+    ap.add_argument("INPUT", help = "The path of AUTOSAR XML", nargs='+')
+    ap.add_argument("OUTPUT", help = "The path of output 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, 'connector.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:
+        parser = InputFileParser(args.INPUT)
+        filenames = parser.parse()
+
+        options = {}
+        if args.warning:
+            options['warning'] = True
+
+        document = AUTOSAR().getInstance()
+        parser = ARXMLParser(options)
+
+        for filename in filenames:
+            parser.load(filename, document)
+
+        writer = ConnectorXlsReport()
+        writer.import_data(document)
+        writer.write(args.OUTPUT)
+        
+    except Exception as e:
+        #print(e)
+        raise e
+
+if __name__ == "__main__":
+    main()

armodel/cli/connector_update_cli.py

@@ -0,0 +1,77 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+
+
+from ..models.ar_package import AUTOSAR
+from ..parser.arxml_parser import ARXMLParser
+from ..parser.connector_xlsx_parser import ConnectorXlsReader
+
+from ..lib import InputFileParser
+from ..writer import ARXMLWriter
+
+def main():
+    version = pkg_resources.require("armodel")[0].version
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-v", "--verbose", required= False, help= "Print debug information", action= "store_true")
+    ap.add_argument("-w", "--warning", required= False, help= "Skip the error and report it as warning message", action= "store_true")
+    ap.add_argument("INPUT", help = "The path of input ARXML file")
+    ap.add_argument("MAPPING", help = "The path of connector excel file which exports with connector2xlsx")
+    ap.add_argument("OUTPUT", help = "The path of output ARXML 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, 'connector_update.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:
+        options = {}
+        if args.warning:
+            options['warning'] = True
+
+        document = AUTOSAR().getInstance()
+        parser = ARXMLParser(options)
+        parser.load(args.INPUT, document)
+
+        reader = ConnectorXlsReader()
+        reader.read(args.MAPPING)
+        reader.update(document)
+
+        writer = ARXMLWriter()
+        writer.save(args.OUTPUT, document)
+        
+    except Exception as e:
+        #print(e)
+        logger.error(e)
+        raise e
+
+if __name__ == "__main__":
+    main()

armodel/cli/swc_list_cli.py

@@ -16,7 +16,7 @@ def main():
     ap.add_argument("-v", "--verbose", required= False, help= "Print debug information", action= "store_true")
     ap.add_argument("-f", "--format", required= False, help= "Specify the short or long name of Sw-C. [short|long]")
     ap.add_argument("--filter", required= False, help = "Set the filter condition. [CompositionSwComponent]")
-    ap.add_argument("Input", help = "The path of AUTOSAR XML", nargs='+')
+    ap.add_argument("INPUT", help = "The path of AUTOSAR XML", nargs='+')
 
     args = ap.parse_args()
 
@@ -49,7 +49,7 @@ def main():
     logger.addHandler(stdout_handler)    
 
     try:
-        parser = InputFileParser(args.Input)
+        parser = InputFileParser(args.INPUT)
         filenames = parser.parse()
 
         document = AUTOSAR().getInstance()

armodel/data_models/sw_connector.py

@@ -0,0 +1,22 @@
+class SwConnectorData:
+    def __init__(self) -> None:
+        self.short_name = ""
+
+class DelegationSwConnectorData(SwConnectorData):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.inner_swc = ""
+        self.inner_pport = ""
+        self.inner_rport = ""
+        self.outer_pport = ""
+        self.outer_rport = ""
+
+class AssemblySwConnectorData(SwConnectorData):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.provider_swc= ""
+        self.pport = ""
+        self.requester_swc = ""
+        self.rport = ""        

armodel/lib/__init__.py

@@ -1,3 +1,3 @@
 
 from .cli_args_parser import InputFileParser
-from .data_analyzer import SwComponentAnalyzer
+from .sw_component import SwComponentAnalyzer

armodel/lib/sw_component.py

@@ -0,0 +1,34 @@
+import logging
+
+from typing import List
+from ..models import AUTOSAR, ARPackage, AtomicSwComponentType, CompositionSwComponentType
+
+class SwComponentAnalyzer:
+    def __init__(self) -> None:
+        self.swcs = []      # type: List[AtomicSwComponentType]
+
+    def parse_pkg(self, parent: ARPackage):
+        for pkg in parent.getARPackages():
+            self.parse_pkg(pkg)
+        for swc in parent.getSwComponentTypes():
+            self.swcs.append(swc)
+
+    def import_data(self, document: AUTOSAR):
+        for pkg in document.getARPackages():
+            self.parse_pkg(pkg)
+
+    def print_out(self, option = {}):
+        logger = logging.getLogger()
+
+        logger.info("== SW-C LIST ==")
+
+        if option['filter'] == 'CompositionSwComponent':
+            swc_list = filter(lambda o: isinstance(o, CompositionSwComponentType), self.swcs)
+        else:
+            swc_list = self.swcs
+
+        for swc in sorted(swc_list, key = lambda o: o.short_name):
+            if option['format'] == 'long':
+                logger.info("%s" % swc.full_name)
+            else:
+                logger.info("%s" % swc.short_name)

armodel/models/__init__.py

@@ -1,7 +1,9 @@
+from .annotation import *
+from .ar_object import *
 from .general_structure import *
 from .common_structure import *
 from .sw_component import *
-from .ar_package import ARPackage, AUTOSAR
+from .ar_package import *
 from .ar_ref import *
 from .datatype import *
 from .port_prototype import * 
@@ -10,4 +12,8 @@ from .data_dictionary import *
 from .port_interface import *
 from .m2_msr import *
 from .implementation import *
-from .bsw_module_template import *
+from .bsw_module_template import *
+from .communication import *
+from .calibration import *
+from .global_constraints import *
+from .unit import *

armodel/models/annotation.py

@@ -0,0 +1,20 @@
+
+from abc import ABCMeta
+
+from .multilanguage_data import MultilanguageLongName
+from .ar_object import ARObject
+
+
+class GeneralAnnotation(ARObject, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == ARObject:
+            raise NotImplementedError("GeneralAnnotation is an abstract class.")
+        
+        self.label = None       # type: MultilanguageLongName
+
+        super().__init__()
+
+class Annotation(GeneralAnnotation):
+    def __init__(self):
+        super().__init__()
+

armodel/models/ar_object.py

@@ -1,4 +1,9 @@
 from abc import ABCMeta
+import re
+from typing import Dict, List
+
+import xml.etree.cElementTree as ET
+
 
 class ARObject(metaclass=ABCMeta):
     def __init__(self):
@@ -7,4 +12,183 @@ class ARObject(metaclass=ABCMeta):
         
         self.parent = None              # type: ARObject
         self.checksum = None            # type: str
+
         self.timestamp = None           # type: str
+        self.uuid = None                # type: str
+
+    def getTagName(self, tag: str, nsmap: Dict) -> str:
+        return tag.replace("{%s}" % nsmap["xmlns"], "")
+    
+class ARType(metaclass=ABCMeta):
+    def __init__(self) -> None:
+        self.timestamp = None           # type: str   
+        self.uuid = None                # type: str
+        self._value = None              
+
+    @property
+    def value(self):
+        return self._value
+    
+    @value.setter
+    def value(self, val):
+        self._value = val
+
+    def getValue(self):
+        return self.value
+    
+    def setValue(self, val):
+        self.value = val
+
+    def getText(self) -> str:
+        return str(self)
+
+        
+class ARLiteral(ARType):
+    def __init__(self) -> None:
+        super().__init__()              
+
+    @property
+    def value(self) -> str:
+        if self._value is None:
+            return ""
+        return self._value
+    
+    @value.setter
+    def value(self, val: any):
+        if isinstance(val, str):
+            self._value = val
+        else:
+            self._value = str(val)
+    
+    def __str__(self) -> str:
+        return self.value
+    
+    def upper(self) -> str:
+        return self.value.upper()
+
+class ARNumerical(ARType):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._text = None                   # type: str
+
+    def _convertStringToNumberValue(self, value: str) -> int:
+        m = re.match(r"0x([0-9a-f]+)", value, re.I)
+        if (m):
+            return int(m.group(1), 16)
+        return int(value)
+    
+    @property
+    def value(self) -> int:
+        return self._value
+    
+    @value.setter
+    def value(self, val: any):
+        if isinstance(val, int):
+            self._value = val
+        elif isinstance(val, str):
+            self._text = val
+            self._value = self._convertStringToNumberValue(val)
+        else:
+            raise ValueError("Unsupported Type <%s>", type(val))
+
+    def __str__(self) -> str:
+        if self._text is not None:
+            return self._text
+        else:
+            return str(self._value)
+    
+class ARPositiveInteger(ARNumerical):
+    def __init__(self) -> None:
+        super().__init__()
+
+    @property
+    def value(self) -> int:
+        return self._value
+    
+    @value.setter
+    def value(self, val: any):
+        if isinstance(val, int):
+            if val < 0:
+                raise ValueError("Invalid Positive Integer <%s>" % val)
+            self._value = val
+        elif isinstance(val, str):
+            self._text = val
+            self._value = self._convertStringToNumberValue(val)
+        else:
+            raise ValueError("Unsupported Type <%s>", type(val))
+
+class ARFloat(ARType):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._text = None                   # type: str
+
+    @property
+    def value(self) -> float:
+        return self._value
+    
+    @value.setter
+    def value(self, val: any):
+        if isinstance(val, float):
+            self._value = val
+        elif isinstance(val, int):
+            self._value = val * 1.0
+        elif isinstance(val, str):
+            self._text = val
+            self._value = float(val)
+        else:
+            raise ValueError("Unsupported Type <%s>", type(val))
+
+    def __str__(self) -> str:
+        if self._text is not None:
+            return self._text
+        else:
+            return str(self._value)
+        
+class ARBoolean(ARType):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._text = None   
+
+    def _convertNumberToBoolean(self, value: int) -> bool:
+        if value == 0:
+            return False
+        return True
+
+    def _convertStringToBoolean(self, value: str) -> bool:
+        value = value.lower()
+        if value == "true":
+            return True
+        elif value == "false":
+            return False
+        else:
+            return self._convertNumberToBoolean(int(value))
+
+    @property
+    def value(self) -> int:
+        return self._value
+    
+    @value.setter
+    def value(self, val: any):
+        if isinstance(val, bool):
+            self._value = val
+        elif isinstance(val, int):
+            self._value = self._convertNumberToBoolean(val)
+            self._text = str(val)
+        elif isinstance(val, str):
+            self._text = val
+            self._value = self._convertStringToBoolean(val)
+        else:
+            raise ValueError("Unsupported Type <%s>", type(val))
+
+    def __str__(self) -> str:
+        if self._text is not None:
+            return self._text
+        else:
+            if self._value:
+                return "true"
+            else:
+                return "false"
+