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

armodel/cli/arxml_dump_cli.py

@@ -70,7 +70,7 @@ def show_behavior(indent:int, behavior: SwcInternalBehavior):
         print("                           : %s" % (event.start_on_event_ref.value))
     for event in behavior.getTimingEvents():
         print("")
-        print("   - TimingEvent : %s (%d ms)" % (event.short_name, event.peroid_ms))
+        print("   - TimingEvent : %s (%d ms)" % (event.short_name, event.period_ms))
         print("                 : %s" % (event.start_on_event_ref.value))
 
 def show_sw_component(indent: int, sw_component: SwComponentType):

armodel/models/ar_object.py

@@ -0,0 +1,10 @@
+from abc import ABCMeta
+
+class ARObject(metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == ARObject:
+            raise NotImplementedError("ARObject is an abstract class.")
+        
+        self.parent = None
+        self.checksum = None            # type: str
+        self.timestamp = None           # type: str

armodel/models/ar_package.py

@@ -1,10 +1,10 @@
 from typing import List
-from .general_structure import Identifiable, ARObject, Referrable, CollectableElement
+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
+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 .implementation import BswImplementation
+from .implementation import BswImplementation, SwcImplementation, Implementation
 from .bsw_module_template import BswModuleDescription, BswModuleEntry
 
 class ARPackage(Identifiable, CollectableElement):
@@ -38,6 +38,12 @@ class ARPackage(Identifiable, CollectableElement):
             sw_component = ServiceSwComponentType(self, short_name)
             self.elements[short_name] = sw_component
         return self.elements[short_name]
+    
+    def createSensorActuatorSwComponentType(self, short_name: str) -> SensorActuatorSwComponentType:
+        if (short_name not in self.elements):
+            sw_component = SensorActuatorSwComponentType(self, short_name)
+            self.elements[short_name] = sw_component
+        return self.elements[short_name]
 
     def createCompositionSwComponentType(self, short_name: str) -> CompositionSwComponentType:
         if (short_name not in self.elements):
@@ -110,6 +116,18 @@ class ARPackage(Identifiable, CollectableElement):
             sw_component = BswImplementation(self, short_name)
             self.elements[short_name] = sw_component
         return self.elements[short_name]
+    
+    def createSwcImplementation(self, short_name: str) -> SwcImplementation:
+        if (short_name not in self.elements):
+            sw_component = SwcImplementation(self, short_name)
+            self.elements[short_name] = sw_component
+        return self.elements[short_name]
+
+    def createSwcBswMapping(self, short_name: str) -> SwcBswMapping:
+        if (short_name not in self.elements):
+            sw_component = SwcBswMapping(self, short_name)
+            self.elements[short_name] = sw_component
+        return self.elements[short_name]
 
     def getApplicationPrimitiveDataTypes(self) -> List[ApplicationPrimitiveDataType]:
         return list(filter(lambda a: isinstance(a, ApplicationPrimitiveDataType), self.elements.values()))
@@ -122,6 +140,9 @@ class ARPackage(Identifiable, CollectableElement):
 
     def getSwComponentTypes(self) -> List[SwComponentType]:
         return list(filter(lambda a : isinstance(a, SwComponentType), self.elements.values()))
+    
+    def getSensorActuatorSwComponentType(self) -> List[SensorActuatorSwComponentType]:
+        return list(filter(lambda a : isinstance(a, SensorActuatorSwComponentType), self.elements.values()))
 
     def getAtomicSwComponentTypes(self) -> List[AtomicSwComponentType]:
         return list(filter(lambda a : isinstance(a, AtomicSwComponentType), self.elements.values()))
@@ -147,6 +168,18 @@ class ARPackage(Identifiable, CollectableElement):
     def getBswModuleEntries(self) -> List[BswModuleEntry]:
         return list(filter(lambda a: isinstance(a, BswModuleEntry), self.elements.values()))
 
+    def getBswImplementations(self) -> List[BswImplementation]:
+        return list(filter(lambda a: isinstance(a, BswImplementation), self.elements.values()))
+    
+    def getSwcImplementations(self) -> List[SwcImplementation]:
+        return list(filter(lambda a: isinstance(a, SwcImplementation), self.elements.values()))
+    
+    def getImplementations(self) -> List[Implementation]:
+        return list(filter(lambda a: isinstance(a, Implementation), self.elements.values()))
+
+    def getSwcBswMappings(self) -> List[SwcBswMapping]:
+        return list(filter(lambda a: isinstance(a, SwcBswMapping), self.elements.values()))
+
 class AUTOSAR (ARObject, CollectableElement):
     __instance = None
 
@@ -189,9 +222,9 @@ class AUTOSAR (ARObject, CollectableElement):
             if (short_name == ""):
                 continue
             element = element.getElement(short_name)
-            #print("<%s>" % short_name)
             if (element == None):
-                raise ValueError("The %s of reference <%s> does not exist." % (short_name, referred_name))
+                return element
+            #    raise ValueError("The %s of reference <%s> does not exist." % (short_name, referred_name))
         return element
 
     def getDataType(self, data_type: ImplementationDataType) -> ImplementationDataType:
@@ -208,6 +241,8 @@ class AUTOSAR (ARObject, CollectableElement):
             raise ValueError("%s is not ImplementationDataType." % data_type)
             
     def addDataTypeMap(self, data_type_map: DataTypeMap):
+        if (data_type_map.application_data_type_ref is None) or (data_type_map.implementation_data_type_ref is None):
+            return
         self._appl_impl_type_maps[data_type_map.application_data_type_ref.value] = data_type_map.implementation_data_type_ref.value
         self._impl_appl_type_maps[data_type_map.implementation_data_type_ref.value] = data_type_map.application_data_type_ref.value
 

armodel/models/ar_ref.py

@@ -1,5 +1,5 @@
 from abc import ABCMeta
-from .general_structure import ARObject
+from .ar_object import ARObject
 
 class RefType(ARObject):
     def __init__(self):
@@ -60,3 +60,32 @@ class ROperationInAtomicSwcInstanceRef(OperationInAtomicSwcInstanceRef):
         self.context_r_port_ref = None              # type: RefType
         self.target_required_operation_ref = None   # type: RefType
 
+class VariableInAtomicSwcInstanceRef(AtpInstanceRef, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == OperationInAtomicSwcInstanceRef:
+            raise NotImplementedError("OperationInAtomicSwcInstanceRef is an abstract class.")
+
+        super().__init__()
+
+class RVariableInAtomicSwcInstanceRef(VariableInAtomicSwcInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.context_r_port_ref = None              # type: RefType
+        self.target_data_element_ref = None         # type: RefType
+
+class RVariableInAtomicSwcInstanceRef(VariableInAtomicSwcInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.context_r_port_ref = None              # type: RefType
+        self.target_data_element_ref = None         # type: RefType
+
+class RModeInAtomicSwcInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.base_ref = None                                    # type: RefType
+        self.context_mode_declaration_group_prototype = None    # type: RefType
+        self.context_port = None                                # type: RefType
+        self.target_mode_declaration = None                     # type: RefType

armodel/models/bsw_module_template.py

@@ -155,11 +155,23 @@ class BswInternalBehavior(InternalBehavior):
         return list(filter(lambda a: isinstance(a, BswInternalTriggerOccurredEvent), self.elements.values()))
 
 class BswModuleDescription(AtpStructureElement):
+    '''
+        Root element for the description of a single BSW module or BSW cluster. In case it
+        describes a BSW module, the short name of this element equals the name of the
+        BSW module.
+        
+        **attributes**:
+         module_id              : MODULE-ID  
+         implemented_entry_refs : PROVIDED-ENTRYS
+    '''
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        # MODULE-ID
         self.module_id = 0
+        # PROVIDED-ENTRYS
         self.implemented_entry_refs = []                # type: List[RefType]
+
         self.provided_mode_groups   = {}                # ModeDeclarationGroupPrototype         *
         self.required_mode_groups   = {}                # ModeDeclarationGroupPrototype         * 
 
@@ -194,6 +206,9 @@ class BswModuleDescription(AtpStructureElement):
         return sorted(self.required_mode_groups.values(), key=lambda v: v.short_name) 
 
     def createBswInternalBehavior(self, short_name: str) -> BswInternalBehavior:
+        '''
+            Create the INTERNAL-BEHAVIORS tag
+        '''
         if (short_name not in self.elements):
             prototype = BswInternalBehavior(self, short_name)
             self.elements[short_name] = prototype

armodel/models/common_structure.py

@@ -7,6 +7,8 @@ from .general_structure import ARObject, ARElement, Identifiable
 from .data_dictionary import SwDataDefProps
 from .ar_ref import RefType
 
+import re
+
 class ValueSpecification(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) == ValueSpecification:
@@ -22,19 +24,16 @@ class ConstantSpecification(ARElement):
 
         self.value_spec = None  # type: ValueSpecification
 
-
 class ConstantReference(ValueSpecification):
     def __init__(self):
         super().__init__()
 
         self.constant_ref = None
 
-
 class AbstractImplementationDataTypeElement(Identifiable):
     def __init__(self, parent, short_name: str):
         super().__init__(parent, short_name)
 
-
 class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
     ARRAY_SIZE_SEMANTICS_FIXED_SIZE = "FIXED-SIZE"
     ARRAY_SIZE_SEMANTICS_VARIABLE_SIZE = "VARIABLE_SIZE"
@@ -42,11 +41,10 @@ class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
     def __init__(self, parent, short_name: str):
         super().__init__(parent, short_name)
 
-        self.array_size = None    # type: int
-        self.array_size_semantics = None  # type: str
-        self.is_optional = None    # type: bool
-        self.sw_data_def_props = None    # type: SwDataDefProps
-
+        self.array_size = None              # type: int
+        self.array_size_semantics = None    # type: str
+        self.is_optional = None             # type: bool
+        self.sw_data_def_props = None       # type: SwDataDefProps
     
     def createImplementationDataTypeElement(self, short_name: str): # type: (...) -> ImplementationDataTypeElement
         if (short_name not in self.elements):
@@ -84,6 +82,12 @@ class InternalBehavior(Identifiable, metaclass=ABCMeta):
     def getExclusiveAreas(self) -> List[ExclusiveArea]:
         return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements.values()))
 
+class ModeDeclaration(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.value = 0
+
 class ExecutableEntity(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == ExecutableEntity:
@@ -124,3 +128,46 @@ class ModeDeclarationGroupPrototype(Identifiable):
         if (value not in ("notAccessible", "readOnly", "readWrite")):
             raise ValueError("Invalid SwCalibrationAccess <%s> of ModeDeclarationGroupPrototype <%s>" % (value, self.short_name))
         self._sw_calibration_access = value
+
+class MemorySection(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+        
+        self._alignment = None
+        self.sw_addr_method_ref = None  # type: RefType
+
+    @property
+    def alignment(self) -> str:
+        return self._alignment
+
+    @alignment.setter
+    def alignment(self, value:str):
+        match = False
+        if value in ("UNKNOWN", "UNSPECIFIED", "BOOLEAN", "PTR"):
+            self._alignment = value
+            match = True
+        else:
+            m = re.match(r'^\d+', value)
+            if m:
+                self._alignment = value
+                match = True
+                
+        if not match:
+            raise ValueError("Invalid alignment <%s> of memory section <%s>" % (value, self.short_name))
+        
+
+class ResourceConsumption(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+    def createMemorySection(self, short_name: str) -> MemorySection:
+        if (short_name not in self.elements):
+            entry = MemorySection(self, short_name)
+            self.elements[short_name] = entry
+        return self.elements[short_name]
+
+    def getMemorySections(self) -> List[MemorySection]:
+        return list(filter(lambda a : isinstance(a, MemorySection), self.elements.values()))
+
+    def getMemorySection(self, short_name: str) -> MemorySection:
+        return next(filter(lambda o: isinstance(o, MemorySection) and (o.short_name == short_name), self.elements.values()), None)

armodel/models/general_structure.py

@@ -1,11 +1,7 @@
-from abc import ABCMeta, abstractmethod
-
-
-class ARObject(metaclass=ABCMeta):
-    def __init__(self):
-        if type(self) == ARObject:
-            raise NotImplementedError("ARObject is an abstract class.")
-        self.parent = None
+from abc import ABCMeta
+from typing import List
+from .ar_object import ARObject
+from .ar_ref import RefType
 
 
 class Referrable(ARObject, metaclass=ABCMeta):
@@ -71,6 +67,36 @@ class PackageableElement(Identifiable, metaclass=ABCMeta):
             raise NotImplementedError("PackageableElement is an abstract class.")
         super().__init__(parent, short_name)
 
+class SwcBswRunnableMapping(ARObject):
+    def __init__(self):
+        '''
+            Maps a BswModuleEntity to a RunnableEntity if it is implemented as part of a BSW
+            module (in the case of an AUTOSAR Service, a Complex Driver or an ECU
+            Abstraction). The mapping can be used by a tool to find relevant information on the
+            behavior, e.g. whether the bswEntity shall be running in interrupt context.
+
+        '''
+        super().__init__()
+
+        self.bsw_entity_ref   = None        # type: RefType
+        self.swc_runnable_ref = None        # type: RefType
+
+class SwcBswMapping(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.bsw_behavior_ref = None            # type: RefType
+        self.runnable_mappings = []
+        self.swc_behavior_ref = None            # type: RefType
+        self.synchronized_mode_groups = []       
+        self.synchronized_triggers = []
+
+    def addRunnableMapping(self, mapping: SwcBswRunnableMapping):
+        self.runnable_mappings.append(mapping)
+
+    def getRunnableMappings(self) -> List[SwcBswRunnableMapping]:
+        return self.runnable_mappings
+
 class ARElement(PackageableElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == ARElement:

armodel/models/implementation.py

@@ -1,12 +1,49 @@
 from abc import ABCMeta
 from typing import List
-from . import PackageableElement, ARObject
+from .ar_object import ARObject
+from .general_structure import PackageableElement, Identifiable
+from .common_structure import ResourceConsumption
+from .ar_ref import RefType
+
+class EngineeringObject(ARObject, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == EngineeringObject:
+            raise NotImplementedError("EngineeringObject is an abstract class.")
+
+        super().__init__()
+
+        self.category = ""
+        self.domain = None                  # type: str
+        self.revision_label = None          # type: str
+        self.short_label = ""               # type: str
+
+class AutosarEngineeringObject(EngineeringObject):
+    def __init__(self):
+        super().__init__()
+
+class Code(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.artifact_descriptors = []          # type: List[AutosarEngineeringObject]
+        self.callback_header_refs = []          # type: List[RefType]
+
+    def addArtifactDescriptor(self, desc: AutosarEngineeringObject):
+        self.artifact_descriptors.append(desc)
+
+    def getArtifactDescriptors(self, category:str = "") -> List[AutosarEngineeringObject]:
+        if (category == ""):
+            return self.artifact_descriptors
+        else:
+            return list(filter(lambda a: a.category == category, self.artifact_descriptors))
 
 class Implementation(PackageableElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str) -> None:
+        if type(self) == Implementation:
+            raise NotImplementedError("Implementation is an abstract class.")
+
         super().__init__(parent, short_name)
         self.build_action_manifest = None       # 0..1   
-        self.code_descriptor = None             # 1..*
         self.compiler = None                    # *
         self.generated_artifact = None          # *
         self.hw_element = None                  # *
@@ -15,18 +52,37 @@ class Implementation(PackageableElement, metaclass=ABCMeta):
         self.programming_language = ""          # 1
         self.required_artifact = None           # *
         self.required_generator_tool = None     # *
-        self.resource_consumption = None        # 1
+        self.resource_consumption = None        # type: ResourceConsumption
         self.sw_version = ""                    # 1
-        self.swc_bsw_mapping = None             # 0..1
+        self.swc_bsw_mapping_ref = None         # type: RefType
         self.used_code_generator = ""           # 0..1
         self.vendor_id = 0                      # 1
 
+    def createCodeDescriptor(self, short_name: str) -> Code:
+        if (short_name not in self.elements):
+            sw_component = Code(self, short_name)
+            self.elements[short_name] = sw_component
+        return self.elements[short_name]
+
+    def getCodeDescriptors(self)-> List[Code]:
+        return list(filter(lambda a : isinstance(a, Code), self.elements.values()))
+
 class BswImplementation(Implementation):
     def __init__(self, parent: ARObject, short_name: str) -> None:
         super().__init__(parent, short_name)
+
+        self.ar_release_version = ""
         self.revision_label_string = ""                 # 1
-        self.behavior = None                            # 1
+        self.behavior_ref = None                        # type: RefType
         self.preconfigured_configuration_ref = None     # *
         self.recommended_configuration_ref = None       # *
         self.vendor_api_infix = ""                      # 0..1
-        self.vendor_specific_module_def_ref = None      # *
+        self.vendor_specific_module_def_ref = None      # *
+
+class SwcImplementation(Implementation):
+    def __init__(self, parent: ARObject, short_name: str) -> None:
+        super().__init__(parent, short_name)
+
+        self.behavior_ref = None                        # type: RefType
+        self.per_instance_memory_size = None
+        self.required_rte_vendor = ""

armodel/models/sw_component.py

@@ -1,7 +1,8 @@
 from typing import List, Dict
 from abc import ABCMeta
 from .general_structure import ARElement, Identifiable, ARObject
-from .ar_ref import AutosarVariableRef, RefType, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef, ProvidedPortPrototypeInstanceRef, RequiredPortPrototypeInstanceRef
+from .ar_ref import AutosarVariableRef, RefType, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef, ProvidedPortPrototypeInstanceRef
+from .ar_ref import RequiredPortPrototypeInstanceRef, RVariableInAtomicSwcInstanceRef, RModeInAtomicSwcInstanceRef
 from .port_prototype import RPortPrototype, PPortPrototype
 from .data_prototype import VariableDataPrototype
 from .common_structure import ExecutableEntity, InternalBehavior
@@ -169,15 +170,43 @@ class DataReceivedEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        self.data_iref = None       # type: RVariableInAtomicSwcInstanceRef
+
+class SwcModeSwitchEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._activation = ""     
+        self.mode_irefs = []       # type: List[RModeInAtomicSwcInstanceRef]
+
+    @property
+    def activation(self) -> str:
+        return self._activation
+
+    @activation.setter
+    def activation(self, value: str):
+        if value not in ("ON-ENTRY", "ON-EXIT", "ON-TRANSITION"):
+            raise ValueError("Invalid activation <%s> of SwcModeSwitchEvent <%s>" % (value, self.short_name))
+        self._activation = value
+
+    def addModeIRef(self, mode_iref: RModeInAtomicSwcInstanceRef):
+        self.mode_irefs.append(mode_iref)
+
 class DataReceiveErrorEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        self.variable_data_prototype_iref = None    
+
 class OperationInvokedEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
         self.operation_iref = None      # type: POperationInAtomicSwcInstanceRef
 
+class InitEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
 class TimingEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -185,7 +214,7 @@ class TimingEvent(RTEEvent):
         self.period = 0
     
     @property
-    def peroid_ms(self):
+    def period_ms(self):
         if (self.period < 0.001):
             return self.period * 1000
         else:
@@ -213,6 +242,24 @@ class SwcInternalBehavior(InternalBehavior):
             self.elements[short_name] = event
         return self.elements[short_name]
 
+    def createInitEvent(self, short_name: str) -> InitEvent:
+        if (short_name not in self.elements):
+            event = InitEvent(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def createDataReceivedEvent(self, short_name: str) -> DataReceivedEvent:
+        if (short_name not in self.elements):
+            event = DataReceivedEvent(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def createSwcModeSwitchEvent(self, short_name: str) -> SwcModeSwitchEvent:
+        if (short_name not in self.elements):
+            event = SwcModeSwitchEvent(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
     def createInternalTriggerOccurredEvent(self, short_name: str) -> InternalTriggerOccurredEvent:
         if (short_name not in self.elements):
             event = InternalTriggerOccurredEvent(self, short_name)
@@ -225,9 +272,18 @@ class SwcInternalBehavior(InternalBehavior):
     def getOperationInvokedEvents(self) -> List[OperationInvokedEvent]:
         return sorted(filter(lambda c: isinstance(c, OperationInvokedEvent), self.elements.values()), key=lambda e: e.short_name)
 
+    def getInitEvents(self) -> List[InitEvent]:
+        return sorted(filter(lambda c: isinstance(c, InitEvent), self.elements.values()), key=lambda e: e.short_name)
+
     def getTimingEvents(self) -> List[TimingEvent]:
         return sorted(filter(lambda c: isinstance(c, TimingEvent), self.elements.values()), key=lambda e: e.short_name)
 
+    def getDataReceivedEvents(self) -> List[DataReceivedEvent]:
+        return sorted(filter(lambda c: isinstance(c, DataReceivedEvent), self.elements.values()), key=lambda e: e.short_name)
+
+    def getSwcModeSwitchEvents(self) -> List[SwcModeSwitchEvent]:
+        return sorted(filter(lambda c: isinstance(c, SwcModeSwitchEvent), self.elements.values()), key=lambda e: e.short_name)
+
     def getInternalTriggerOccurredEvents(self) -> List[InternalTriggerOccurredEvent]:
         return sorted(filter(lambda c: isinstance(c, InternalTriggerOccurredEvent), self.elements.values()), key= lambda e: e.short_name)