armodel 1.4.0__py3-none-any.whl → 1.5.0__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

@@ -32,15 +32,15 @@ def show_port(indent:int, port_prototype: PortPrototype):
         raise ValueError("Unsupported Port prototype")
 
 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-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/connector_update_cli.py

@@ -4,8 +4,10 @@ import logging
 import sys
 import os.path
 
-from armodel import AUTOSAR
-from armodel.parser import ARXMLParser
+
+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
@@ -16,9 +18,9 @@ def main():
     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("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 excel file")
+    ap.add_argument("OUTPUT", help = "The path of output ARXML file")
 
     args = ap.parse_args()
 
@@ -59,11 +61,16 @@ def main():
         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__":

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

@@ -29,6 +29,6 @@ class SwComponentAnalyzer:
 
         for swc in sorted(swc_list, key = lambda o: o.short_name):
             if option['format'] == 'long':
-                logger.info("%s (%s)" % (swc.full_name, type(swc)))
+                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 * 
@@ -13,6 +15,5 @@ from .implementation import *
 from .bsw_module_template import *
 from .communication import *
 from .calibration import *
-from .ar_object 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,5 +1,9 @@
 from abc import ABCMeta
-from typing import List
+import re
+from typing import Dict, List
+
+import xml.etree.cElementTree as ET
+
 
 class ARObject(metaclass=ABCMeta):
     def __init__(self):
@@ -12,38 +16,179 @@ class ARObject(metaclass=ABCMeta):
         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              
 
-class ARBoolean(ARType):
-    def __init__(self) -> None:
-        super().__init__()              
+    @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
 
-        self.value = ""                 # type: bool
+    def getText(self) -> str:
+        return str(self)
+
+        
 class ARLiteral(ARType):
     def __init__(self) -> None:
         super().__init__()              
 
-        self.value = ""                 # type: str
+    @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 LLongName(ARObject):
-    def __init__(self):
+class ARNumerical(ARType):
+    def __init__(self) -> None:
         super().__init__()
 
-        self.l = ""
-        self.value = ""
+        self._text = None                   # type: str
 
-class MultilanguageLongName(ARObject):
-    def __init__(self):
+    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__()
 
-        self.l4 = []        # type：List[LLongName]
+    @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))
 
-    def add_l4(self, l4: LLongName):
-        self.l4.append(l4)
+    @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 get_l4s(self) -> List[LLongName]:
-        return self.l4
+    def __str__(self) -> str:
+        if self._text is not None:
+            return self._text
+        else:
+            if self._value:
+                return "true"
+            else:
+                return "false"
+