armodel 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

armodel/cli/arxml_dump_cli.py

@@ -17,16 +17,16 @@ def show_variable_access(indent:int, variable_access: VariableAccess):
             print("%s: %s" % (" " * indent, autosar_variable_in_impl_datatype.port_prototype.value))
             print("%s: %s" % (" " * indent, autosar_variable_in_impl_datatype.target_data_prototype.value))
 
-def show_port(indent:int, port_portotype: PortPrototype):
-    if (isinstance(port_portotype, RPortPrototype)):
-        print("%s-RPort: %s (%s)" % (" " * indent, port_portotype.short_name, port_portotype.required_interface_tref.value))
-        for client_com_spec in port_portotype.getClientComSpecs():
+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))
-        for com_spec in port_portotype.getNonqueuedReceiverComSpecs():
+        for com_spec in port_prototype.getNonqueuedReceiverComSpecs():
             print("%s    : %s (NonqueuedReceiverComSpec)" % (" " * (indent + 2), com_spec.data_element_ref.value))
-    elif (isinstance(port_portotype, PPortPrototype)):
-        print("%s-PPort: %s (%s)" % (" " * indent, port_portotype.short_name, port_portotype.provided_interface_tref.value))
-        for com_spec in port_portotype.getNonqueuedSenderComSpecs():
+    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))
     else:
         raise ValueError("Unsupported Port prototype")

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,70 @@
+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 ..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("MAPPING", help = "The path of connector excel file which exports with connector2xlsx")
+    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_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)
+
+        writer = ARXMLWriter()
+        writer.save(args.OUTPUT, document)
+        
+    except Exception as e:
+        #print(e)
+        raise e
+
+if __name__ == "__main__":
+    main()

armodel/cli/swc_list_cli.py

@@ -0,0 +1,81 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+
+from armodel import AUTOSAR, ARPackage
+from armodel.parser import ARXMLParser
+
+from ..lib import InputFileParser, SwComponentAnalyzer
+
+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("--filter", required= False, help = "Set the filter condition. [CompositionSwComponent]")
+    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(".", 'swc-list.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)
+
+        filter = ""
+        if args.filter is not None and args.filter.lower() == "compositionswcomponent":
+            filter = "CompositionSwComponent"
+
+        analyzer = SwComponentAnalyzer()
+        analyzer.import_data(document)
+        analyzer.print_out({
+            'format': format,
+            'filter': filter,
+        })
+        
+    except Exception as e:
+        #print(e)
+        raise e
+
+if __name__ == "__main__":
+    main()

armodel/lib/__init__.py

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

armodel/lib/cli_args_parser.py

@@ -0,0 +1,36 @@
+from typing import List
+
+import logging
+import os, re
+
+class InputFileParser:
+    def __init__(self, args: List[str]) -> None:
+        self._args = args
+        self._filenames = []                # type: List[str]
+        self._logger = logging.getLogger()
+
+    def _parse_file_list(self, file):
+        with open(file) as f_in:
+            for line in f_in:
+                self._filenames.append(line.strip())
+
+    def _parse_dir_files(self, dir_name):
+        for (root, _, files) in os.walk(dir_name, topdown=False):
+            for file in files:
+                m = re.match(r'.*\.arxml$', file, re.I)
+
+                if m:
+                    self._filenames.append(os.path.join(root, file))
+
+    def parse(self) -> List[str]:
+        for input_file in self._args:
+            if os.path.isdir(input_file):
+                self._parse_dir_files(input_file)
+            else:
+                if input_file[0] == "@":
+                    self._logger.debug("Parse ARXML list file %s " % input_file)
+                    self._parse_file_list(input_file[1:])
+                else:
+                    self._filenames.append(input_file)
+
+        return self._filenames

armodel/lib/data_analyzer.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 (%s)" % (swc.full_name, type(swc)))
+            else:
+                logger.info("%s" % swc.short_name)

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

@@ -10,4 +10,9 @@ 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 .ar_object import *
+from .global_constraints import *
+from .unit import *

armodel/models/ar_object.py

@@ -1,10 +1,49 @@
 from abc import ABCMeta
+from typing import List
 
 class ARObject(metaclass=ABCMeta):
     def __init__(self):
         if type(self) == ARObject:
             raise NotImplementedError("ARObject is an abstract class.")
         
-        self.parent = None
+        self.parent = None              # type: ARObject
         self.checksum = None            # type: str
+
         self.timestamp = None           # type: str
+        self.uuid = None                # type: str
+
+
+class ARType(metaclass=ABCMeta):
+    def __init__(self) -> None:
+        self.timestamp = None           # type: str   
+        self.uuid = None                # type: str
+
+class ARBoolean(ARType):
+    def __init__(self) -> None:
+        super().__init__()              
+
+        self.value = ""                 # type: bool
+class ARLiteral(ARType):
+    def __init__(self) -> None:
+        super().__init__()              
+
+        self.value = ""                 # type: str
+
+class LLongName(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.l = ""
+        self.value = ""
+
+class MultilanguageLongName(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.l4 = []        # type：List[LLongName]
+
+    def add_l4(self, l4: LLongName):
+        self.l4.append(l4)
+
+    def get_l4s(self) -> List[LLongName]:
+        return self.l4

armodel/models/ar_package.py

@@ -1,11 +1,15 @@
 from typing import List
+
+from .unit import Unit
 from .general_structure import Identifiable, ARObject, Referrable, CollectableElement, SwcBswMapping
 from .port_interface import SenderReceiverInterface, ClientServerInterface
 from .sw_component import SwComponentType, EcuAbstractionSwComponentType, AtomicSwComponentType, ApplicationSwComponentType, ServiceSwComponentType, CompositionSwComponentType, SensorActuatorSwComponentType
 from .datatype import ImplementationDataType, ApplicationDataType, DataTypeMappingSet, DataTypeMap, SwBaseType, ApplicationPrimitiveDataType, ApplicationRecordDataType
 from .m2_msr import CompuMethod
+from .common_structure import ConstantSpecification
 from .implementation import BswImplementation, SwcImplementation, Implementation
 from .bsw_module_template import BswModuleDescription, BswModuleEntry
+from .global_constraints import DataConstr
 
 class ARPackage(Identifiable, CollectableElement):
     def __init__(self, parent: ARObject, short_name: str):
@@ -128,9 +132,30 @@ class ARPackage(Identifiable, CollectableElement):
             sw_component = SwcBswMapping(self, short_name)
             self.elements[short_name] = sw_component
         return self.elements[short_name]
+    
+    def createConstantSpecification(self, short_name: str) -> ConstantSpecification:
+        if (short_name not in self.elements):
+            spec = ConstantSpecification(self, short_name)
+            self.elements[short_name] = spec
+        return self.elements[short_name]
+    
+    def createDataConstr(self, short_name: str) -> DataConstr:
+        if (short_name not in self.elements):
+            spec = DataConstr(self, short_name)
+            self.elements[short_name] = spec
+        return self.elements[short_name]
+    
+    def createUnit(self, short_name: str) -> Unit:
+        if (short_name not in self.elements):
+            spec = Unit(self, short_name)
+            self.elements[short_name] = spec
+        return self.elements[short_name]
 
     def getApplicationPrimitiveDataTypes(self) -> List[ApplicationPrimitiveDataType]:
         return list(filter(lambda a: isinstance(a, ApplicationPrimitiveDataType), self.elements.values()))
+    
+    def getApplicationDataType(self) -> List[ApplicationDataType]:
+        return list(sorted(filter(lambda a: isinstance(a, ApplicationDataType), self.elements.values()), key= lambda o:o.short_name))
 
     def getImplementationDataTypes(self) -> List[ImplementationDataType]:
         return list(filter(lambda a: isinstance(a, ImplementationDataType), self.elements.values()))
@@ -179,8 +204,17 @@ class ARPackage(Identifiable, CollectableElement):
 
     def getSwcBswMappings(self) -> List[SwcBswMapping]:
         return list(filter(lambda a: isinstance(a, SwcBswMapping), self.elements.values()))
+    
+    def getConstantSpecifications(self) -> List[ConstantSpecification]:
+        return list(filter(lambda a: isinstance(a, ConstantSpecification), self.elements.values()))
+    
+    def getDataConstrs(self) -> List[DataConstr]:
+        return list(filter(lambda a: isinstance(a, DataConstr), self.elements.values()))
+    
+    def getUnits(self) -> List[Unit]:
+        return list(filter(lambda a: isinstance(a, Unit), self.elements.values()))
 
-class AUTOSAR (ARObject, CollectableElement):
+class AUTOSAR (CollectableElement):
     __instance = None
 
     @staticmethod

armodel/models/ar_ref.py

@@ -24,13 +24,23 @@ class AtpInstanceRef(ARObject, metaclass=ABCMeta):
             raise NotImplementedError("AtpInstanceRef is an abstract class.")
         super().__init__()
 
-class ProvidedPortPrototypeInstanceRef(AtpInstanceRef):
+class PortInCompositionTypeInstanceRef(AtpInstanceRef, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == PortInCompositionTypeInstanceRef:
+            raise NotImplementedError("PortInCompositionTypeInstanceRef is an abstract class.")
+        super().__init__()
+
+        self.abstract_context_component_ref = None  # type: RefType
+        self.base_ref = None                        # type: RefType
+        self.target_port_ref = None                 # type: RefType
+
+class PPortInCompositionInstanceRef(PortInCompositionTypeInstanceRef):
     def __init__(self):
         super().__init__()
         self.context_component_ref = None   # type: RefType
         self.target_p_port_ref     = None   # type: RefType
 
-class RequiredPortPrototypeInstanceRef(AtpInstanceRef):
+class RPortInCompositionInstanceRef(PortInCompositionTypeInstanceRef):
     def __init__(self):
         super().__init__()
         self.context_component_ref = None   # type: RefType

armodel/models/bsw_module_template.py

@@ -1,6 +1,7 @@
 from abc import ABCMeta
 from typing import List
 from .general_structure import AtpStructureElement, ARObject, ARElement
+from .ar_object import ARBoolean
 from .common_structure import ExecutableEntity, ModeDeclarationGroupPrototype, InternalBehavior, Identifiable
 from .ar_ref import RefType
 
@@ -222,8 +223,8 @@ class BswModuleEntry(ARElement):
         super().__init__(parent, short_name)
 
         self.service_id = None                  # type: int
-        self.is_reentrant = None                # type: bool
-        self.is_synchronous = None              # type: bool
+        self.is_reentrant = None                # type: ARBoolean
+        self.is_synchronous = None              # type: ARBoolean
         self.call_type = None                   # type: str
         self._execution_context = None          # type: str
         self._sw_service_impl_policy = None     # type: str

armodel/models/calibration.py

@@ -0,0 +1,16 @@
+from .ar_object import ARObject
+from .ar_ref import RefType
+
+class SwValues(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.v = None                   # type: float
+
+class SwValueCont(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.unit_ref = None            # type: RefType
+        self.sw_values_phys = None      # type: SwValues
+

armodel/models/common_structure.py

@@ -10,13 +10,105 @@ from .ar_ref import RefType
 import re
 
 class ValueSpecification(ARObject, metaclass=ABCMeta):
+    '''
+    Base class for expressions leading to a value which can be used to initialize a data object.
+    
+    Base        : ARObject
+    Subclasses  : AbstractRuleBasedValueSpecification, ApplicationValueSpecification, CompositeValueSpecification,
+                  ConstantReference, NotAvailableValueSpecification, NumericalValueSpecification, ReferenceValueSpecification, 
+                  TextValueSpecification
+    '''
     def __init__(self):
         if type(self) == ValueSpecification:
             raise NotImplementedError("ValueSpecification is an abstract class.")
+        
         super().__init__()
 
         self.short_label = None
 
+class CompositeRuleBasedValueArgument(ValueSpecification, metaclass=ABCMeta):
+    '''
+    This meta-class has the ability to serve as the abstract base class for ValueSpecifications that can be
+    used for compound primitive data types.
+
+    Base        : ARObject
+    Subclasses  : ApplicationRuleBasedValueSpecification, ApplicationValueSpecification
+    '''
+    def __init__(self):
+        if type(self) == CompositeRuleBasedValueArgument:
+            raise NotImplementedError("CompositeRuleBasedValueArgument is an abstract class.")
+        
+        super().__init__()
+
+class CompositeValueSpecification(ValueSpecification, metaclass=ABCMeta):
+    '''
+    This abstract meta-class acts a base class for ValueSpecifications that have a composite form.
+
+    Base        : ARObject, ValueSpecification
+    Subclasses  : ArrayValueSpecification, RecordValueSpecification
+    '''            
+    def __init__(self):
+        if type(self) == CompositeValueSpecification:
+            raise NotImplementedError("CompositeValueSpecification is an abstract class.")
+        
+        super().__init__()
+
+class ApplicationValueSpecification(CompositeRuleBasedValueArgument):
+    '''
+    This meta-class represents values for DataPrototypes typed by ApplicationDataTypes (this includes in
+    particular compound primitives).
+    For further details refer to ASAM CDF 2.0. This meta-class corresponds to some extent with
+    SW-INSTANCE in ASAM CDF 2.0.
+
+    Base ARObject, CompositeRuleBasedValueArgument, ValueSpecification    
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.category = None
+        self.sw_Axis_cont = []
+        self.sw_value_cont = None
+
+class RecordValueSpecification(CompositeValueSpecification):
+    '''
+    Specifies the values for a record.
+    
+    Base : ARObject, CompositeValueSpecification, ValueSpecification
+    '''
+    def __init__(self):
+        super().__init__()        
+
+        self._fields = []
+
+    def add_field(self, field: ValueSpecification):
+        self._fields.append(field)
+
+    def get_fields(self) -> List[ValueSpecification]:
+        return self._fields
+
+class TextValueSpecification(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self.value = None        # type: str
+
+class NumericalValueSpecification(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self.value = None        # type: float  
+
+class ArrayValueSpecification(ValueSpecification):
+    def __init__(self):
+        super().__init__()
+
+        self._element = []       # type: List[ValueSpecification]
+
+    def add_element(self, element: ValueSpecification):
+        self._element.append(element)
+
+    def get_elements(self) -> List[ValueSpecification]:
+        return self._element
 
 class ConstantSpecification(ARElement):
     def __init__(self, parent, short_name):

armodel/models/communication.py

@@ -0,0 +1,8 @@
+from . import ARObject
+
+class TransmissionAcknowledgementRequest(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.timeout = None     # type: float
+