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

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

@@ -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/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/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" % swc.full_name)
+                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,4 +1,5 @@
 from abc import ABCMeta
+from typing import List
 
 class ARObject(metaclass=ABCMeta):
     def __init__(self):
@@ -7,4 +8,42 @@ class ARObject(metaclass=ABCMeta):
         
         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
+

armodel/models/datatype.py

@@ -1,7 +1,9 @@
 from abc import ABCMeta
 from typing import List
-from .general_structure import ARElement, Referrable, ARObject
-from .data_prototype import ApplicationArrayElement, ApplicationRecordElement
+
+from .ar_package import Referrable
+from .general_structure import ARElement, ARObject
+from .data_prototype import ApplicationRecordElement
 from .data_dictionary import SwDataDefProps
 from .common_structure import ImplementationDataTypeElement
 
@@ -14,11 +16,23 @@ class ImplementationProps(Referrable, metaclass=ABCMeta):
         super().__init__(parent, short_name)
         self.symbol = ""
 
-
 class SymbolProps(ImplementationProps):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+class BaseTypeDefinition(ARObject):
+    def __init__(self):
+        super().__init__()
+    
+class BaseTypeDirectDefinition(BaseTypeDefinition):
+    def __init__(self):
+        super().__init__()
+
+        self.base_type_encoding = None
+        self.base_type_size = None          # type: int
+        self.byte_order = None              # type: str
+        self.mem_alignment = None
+        self.native_declaration = None      
 
 class BaseType(ARElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -26,14 +40,13 @@ class BaseType(ARElement, metaclass=ABCMeta):
             raise NotImplementedError("BaseType is an abstract class.")
 
         super().__init__(parent, short_name)
-        self.base_type_definition = None  # Type: BaseTypeDefinition
 
+        self.base_type_definition = BaseTypeDirectDefinition()
 
 class SwBaseType(BaseType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-
 class AtpType(ARElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == AtpType:
@@ -84,12 +97,17 @@ class ApplicationRecordDataType(ApplicationCompositeDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        self.record_elements = []
+
     def createApplicationRecordElement(self, short_name: str) -> ApplicationRecordElement:
         if (short_name not in self.elements):
             record_element = ApplicationRecordElement(self, short_name)
             self.elements[short_name] = record_element
+            self.record_elements.append(self.elements[short_name])
         return self.elements[short_name]
 
+    def getApplicationRecordElements(self) -> List[ApplicationRecordElement]:
+        return self.record_elements
 
 class AbstractImplementationDataType(AutosarDataType, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):

armodel/models/general_structure.py

@@ -1,13 +1,52 @@
 from abc import ABCMeta
 from typing import List
+
 from .ar_object import ARObject
-from .ar_ref import RefType
 
 
+class Sd(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.gid = ""
+        self.value = ""
+
+class Sdg(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.gid = ""
+        self.sd = []                        # type: List[Sd]
+        self.sdg_caption = None
+        self.sdg_contents_type = None
+
+    def addSd(self, sd: Sd):
+        self.sd.append(sd)
+
+    def getSds(self) -> List[Sd]:
+        return self.sd
+    
+class AdminData(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.doc_revision = []
+        self.language = None
+        self.sdg = []
+        self.used_languages = None
+
+    def addSdg(self, sdg: Sdg):
+        self.sdg.append(sdg)
+
+    def getSdgs(self) -> List[Sdg]:
+        return self.sdg
+
 class Referrable(ARObject, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == Referrable:
             raise NotImplementedError("Referrable is an abstract class.")
+        ARObject.__init__(self)
+
         self.parent = parent
         self.short_name = short_name
 
@@ -23,11 +62,15 @@ class MultilanguageReferrable(Referrable, metaclass=ABCMeta):
         self.parent = parent
         self.long_name = None
 
-class CollectableElement(metaclass=ABCMeta):
+class CollectableElement(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) == CollectableElement:
             raise NotImplementedError("CollectableElement is an abstract class.")
-        self.elements = {}              # type: dict(PackageableElement)
+        self.elements = {}              # type: dict[str, PackageableElement]
+
+    def getTotalElement(self) -> int:
+        #return len(list(filter(lambda a: not isinstance(a, ARPackage) , self.elements.values())))
+        return len(self.elements.values())
 
     def getElements(self):
         return self.elements.values()
@@ -44,6 +87,7 @@ class Identifiable(MultilanguageReferrable, CollectableElement, metaclass=ABCMet
         MultilanguageReferrable.__init__(self, parent, short_name)
         CollectableElement.__init__(self)
 
+        self.admin_data = None      # type: AdminData
         self._category = None
         self.desc = None
 
@@ -102,6 +146,7 @@ class ARElement(PackageableElement, metaclass=ABCMeta):
         if type(self) == ARElement:
             raise NotImplementedError("ARElement is an abstract class.")
         super().__init__(parent, short_name)
+        
 
 class AtpStructureElement(AtpFeature, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):