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

armodel/cli/arxml_dump_cli.py

@@ -2,9 +2,9 @@ import getopt
 import sys
 import logging
 
-from ..models import AUTOSAR, ARPackage, AtomicSwComponentType, VariableAccess, SwComponentType, DataTypeMappingSet
+from ..models import AUTOSAR, ARPackage, VariableAccess, SwComponentType, DataTypeMappingSet
 from ..models import SwcInternalBehavior, ImplementationDataType
-from ..models import BswModuleDescription, BswEvent, BswInternalBehavior, BswModuleEntity, BswModuleEntry
+from ..models import BswModuleDescription, BswInternalBehavior, BswModuleEntity, BswModuleEntry
 from ..models import PortPrototype, RPortPrototype, PPortPrototype
 from ..models import SenderReceiverInterface, ClientServerInterface
 from ..parser import ARXMLParser
@@ -21,26 +21,26 @@ def show_port(indent:int, port_prototype: PortPrototype):
     if (isinstance(port_prototype, RPortPrototype)):
         print("%s-RPort: %s (%s)" % (" " * indent, port_prototype.short_name, port_prototype.required_interface_tref.value))
         for client_com_spec in port_prototype.getClientComSpecs():
-            print("%s    : %s (ClientComSpec)" % (" " * (indent + 2), client_com_spec.operation_ref.value))
+            print("%s    : %s (ClientComSpec)" % (" " * (indent + 2), client_com_spec.operationRef.value))
         for com_spec in port_prototype.getNonqueuedReceiverComSpecs():
-            print("%s    : %s (NonqueuedReceiverComSpec)" % (" " * (indent + 2), com_spec.data_element_ref.value))
+            print("%s    : %s (NonqueuedReceiverComSpec)" % (" " * (indent + 2), com_spec.dataElementRef.value))
     elif (isinstance(port_prototype, PPortPrototype)):
         print("%s-PPort: %s (%s)" % (" " * indent, port_prototype.short_name, port_prototype.provided_interface_tref.value))
         for com_spec in port_prototype.getNonqueuedSenderComSpecs():
-            print("%s    : %s (NonqueuedSenderComSpec)" % (" " * (indent + 2), com_spec.data_element_ref.value))
+            print("%s    : %s (NonqueuedSenderComSpec)" % (" " * (indent + 2), com_spec.dataElementRef.value))
     else:
         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.baseTypeRef != None):
-            base_type_ref = data_type.sw_data_def_props.baseTypeRef
+    if (data_type.swDataDefProps != None):
+        if (data_type.swDataDefProps.baseTypeRef != None):
+            base_type_ref = data_type.swDataDefProps.baseTypeRef
             print("%s                    : %s (%s)" % (" " * indent, base_type_ref.value, base_type_ref.dest))
             
-        if (data_type.sw_data_def_props.implementationDataTypeRef != None):
-            implementation_data_type_ref = data_type.sw_data_def_props.implementationDataTypeRef
+        if (data_type.swDataDefProps.implementationDataTypeRef != None):
+            implementation_data_type_ref = data_type.swDataDefProps.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):
@@ -92,7 +92,7 @@ def show_client_server_interface(indent: int, cs_interface: ClientServerInterfac
         print("%sOperation:%s" % (" " * (indent + 2), operation.short_name))
         for argument in operation.getArgumentDataPrototypes():
             print("%s         :%s (%s: %s)" % (" " * (indent + 2), argument.short_name, 
-                argument.direction, argument.type_tref.value))
+                argument.direction, argument.typeTRef.value))
 
 def show_bsw_internal_behavior(indent: int, behavior: BswInternalBehavior):
     document = AUTOSAR.getInstance()
@@ -107,8 +107,8 @@ def show_bsw_internal_behavior(indent: int, behavior: BswInternalBehavior):
         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
+        print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntryRef", starts_on_event.implementedEntryRef.value))
+        implemented_entry = document.find(starts_on_event.implementedEntryRef.value) # type: BswModuleEntry
         print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntry", implemented_entry.short_name))
         print("%s-%s: %d" % (" " * (indent + 6), "Service Id", implemented_entry.service_id))
 

armodel/cli/memory_section_cli.py

@@ -0,0 +1,76 @@
+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, SystemSignalAnalyzer
+
+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("-f", "--format", required= False, help= "Specify the short or long name of Sw-C. [short|long]")
+    
+    ap.add_argument("INPUT", help = "The path of AUTOSAR XML", nargs='+')
+    ap.add_argument("")
+
+    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(".", 'system-signals.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()
+
+        document = AUTOSAR().getInstance()
+        parser = ARXMLParser({'warning': True})
+
+        format = "short"
+        if args.format is not None and args.format.lower() == "long":
+            format = "long"
+
+        for filename in filenames:
+            parser.load(filename, document)
+
+        analyzer = SystemSignalAnalyzer()
+        analyzer.import_data(document)
+        analyzer.print_out({
+            'format': format,
+        })
+        
+    except Exception as e:
+        print(e)
+        #raise e
+
+if __name__ == "__main__":
+    main()

armodel/cli/system_signal_cli.py

@@ -0,0 +1,74 @@
+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, SystemSignalAnalyzer
+
+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("-f", "--format", required= False, help= "Specify the name format of SW-C. [short|full]")
+    ap.add_argument("INPUT", help = "The path of AUTOSAR XML", nargs='+')
+
+    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(".", 'system-signals.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()
+
+        document = AUTOSAR().getInstance()
+        parser = ARXMLParser({'warning': True})
+
+        format = "short"
+        if args.format is not None and args.format.lower() == "full":
+            format = "full"
+
+        for filename in filenames:
+            parser.load(filename, document)
+
+        analyzer = SystemSignalAnalyzer()
+        analyzer.import_data(document)
+        analyzer.print_out({
+            'format': format,
+        })
+        
+    except Exception as e:
+        print(e)
+        #raise e
+
+if __name__ == "__main__":
+    main()

armodel/lib/__init__.py

@@ -1,3 +1,4 @@
 
 from .cli_args_parser import InputFileParser
-from .sw_component import SwComponentAnalyzer
+from .sw_component import SwComponentAnalyzer
+from .system_signal import SystemSignalAnalyzer

armodel/lib/system_signal.py

@@ -0,0 +1,37 @@
+import logging
+from typing import List
+
+from ..models.ar_package import AUTOSAR, ARPackage
+from ..models.fibex.fibex_core.core_communication import SystemSignal
+
+class SystemSignalAnalyzer:
+    def __init__(self) -> None:
+        self.system_signals = []      # type: List[SystemSignal]
+
+    def add_system_signal(self, signal: SystemSignal):
+        self.system_signals.append(signal)
+
+    def get_system_signals(self) -> List[SystemSignal]:
+        return self.system_signals
+    
+    def parse_pkg(self, parent: ARPackage):
+        for pkg in parent.getARPackages():
+            self.parse_pkg(pkg)
+        for signal in parent.getSystemSignals():
+            
+            self.add_system_signal(signal)
+
+    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("== SYSTEM SIGNAL LIST ==")
+
+        for signal in sorted(self.system_signals, key = lambda o: o.short_name):
+            if option['format'] == 'full':
+                logger.info("%s" % signal.full_name)
+            else:
+                logger.info("%s" % signal.short_name)

armodel/models/__init__.py

@@ -8,12 +8,15 @@ from .ar_ref import *
 from .datatype import *
 from .port_prototype import * 
 from .data_prototype import *
-from .data_dictionary import *
-from .port_interface import *
+from .m2.msr.asam_hdo.units import *
+from .m2.msr.data_dictionary.data_def_properties import *
+from .m2.msr.data_dictionary.auxillary_objects import *
+from .m2.autosar_templates.sw_component_template.port_interface import *
 from .m2_msr import *
 from .implementation import *
 from .bsw_module_template import *
 from .communication import *
 from .calibration import *
 from .global_constraints import *
-from .unit import *
+from .m2.msr.asam_hdo.units import *
+from .m2.autosar_templates.sw_component_template import *

armodel/models/annotation.py

@@ -1,8 +1,9 @@
 
 from abc import ABCMeta
 
+from .m2.msr.documentation.block_elements import DocumentationBlock
 from .multilanguage_data import MultilanguageLongName
-from .ar_object import ARObject
+from .ar_object import ARLiteral, ARObject
 
 
 class GeneralAnnotation(ARObject, metaclass=ABCMeta):
@@ -10,10 +11,33 @@ class GeneralAnnotation(ARObject, metaclass=ABCMeta):
         if type(self) == ARObject:
             raise NotImplementedError("GeneralAnnotation is an abstract class.")
         
-        self.label = None       # type: MultilanguageLongName
-
         super().__init__()
 
+        self.annotationOrigin = None        # type: ARLiteral
+        self.annotationText = None          # type: DocumentationBlock
+        self.label = None                   # type: MultilanguageLongName
+
+    def getAnnotationOrigin(self) -> ARLiteral:
+        return self.annotationOrigin
+
+    def setAnnotationOrigin(self, value: ARLiteral):
+        self.annotationOrigin = value
+        return self
+    
+    def getAnnotationText(self) -> DocumentationBlock:
+        return self.annotationText
+
+    def setAnnotationText(self, value: DocumentationBlock):
+        self.annotationText = value
+        return self
+
+    def getLabel(self) -> MultilanguageLongName:
+        return self.label
+
+    def setLabel(self, value: MultilanguageLongName):
+        self.label = value
+        return  self
+
 class Annotation(GeneralAnnotation):
     def __init__(self):
         super().__init__()

armodel/models/ar_object.py

@@ -73,10 +73,21 @@ class ARNumerical(ARType):
         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)
+        try:
+            if value == 'true':
+                return 1
+            elif value == 'false':
+                return 0
+            else:
+                m = re.match(r"0x([0-9a-f]+)", value, re.I)
+                if m:
+                    return int(m.group(1), 16)
+                m = re.match(r"\d+\.\d+", value)
+                if m:
+                    return float(value)
+                return int(value)
+        except:
+            raise ValueError("Invalid Numerical Type <%s>" % value)
     
     @property
     def value(self) -> int:
@@ -118,7 +129,7 @@ class ARPositiveInteger(ARNumerical):
         else:
             raise ValueError("Unsupported Type <%s>", type(val))
 
-class ARFloat(ARType):
+class ARFloat(ARNumerical):
     def __init__(self) -> None:
         super().__init__()
 
@@ -136,7 +147,8 @@ class ARFloat(ARType):
             self._value = val * 1.0
         elif isinstance(val, str):
             self._text = val
-            self._value = float(val)
+            #self._value = float(val)
+            self._value = self._convertStringToNumberValue(val)
         else:
             raise ValueError("Unsupported Type <%s>", type(val))