Merge pull request #394 from andlaus/base_variant_patterns

Implement base variant patterns

Author: andlaus

examples/somersaultecu.py

@@ -2419,6 +2419,7 @@ class SomersaultSID(IntEnum):
     variable_groups=NamedItemList(),
     libraries=NamedItemList(),
     sub_components=NamedItemList(),
+    base_variant_pattern=None,
     dyn_defined_spec=None)
 somersault_base_variant = BaseVariant(diag_layer_raw=somersault_base_variant_raw)
 

odxtools/basevariantpattern.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Union
+from xml.etree import ElementTree
+
+from typing_extensions import override
+
+from .exceptions import odxassert
+from .matchingbasevariantparameter import MatchingBaseVariantParameter
+from .matchingparameter import MatchingParameter
+from .odxlink import OdxDocFragment
+from .variantpattern import VariantPattern
+
+
+@dataclass
+class BaseVariantPattern(VariantPattern):
+    """Base variant patterns are variant patterns used to identify the
+    base variant of an ECU.
+    """
+    matching_base_variant_parameters: List[MatchingBaseVariantParameter]
+
+    @override
+    def get_matching_parameters(
+            self) -> Union[List[MatchingParameter], List[MatchingBaseVariantParameter]]:
+        return self.matching_base_variant_parameters
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "BaseVariantPattern":
+
+        matching_base_variant_parameters = [
+            MatchingBaseVariantParameter.from_et(mbvp_el, doc_frags)
+            for mbvp_el in et_element.iterfind("MATCHING-BASE-VARIANT-PARAMETERS/"
+                                               "MATCHING-BASE-VARIANT-PARAMETER")
+        ]
+
+        odxassert(len(matching_base_variant_parameters) > 0)  # required by ISO 22901-1 Figure 141
+        return BaseVariantPattern(matching_base_variant_parameters=matching_base_variant_parameters)

odxtools/createecuvariantpatterns.py

@@ -6,6 +6,7 @@
 
 from typing_extensions import override
 
+from ..basevariantpattern import BaseVariantPattern
 from ..diagvariable import DiagVariable
 from ..dyndefinedspec import DynDefinedSpec
 from ..exceptions import odxassert
@@ -38,6 +39,10 @@ def diag_variables_raw(self) -> List[Union[DiagVariable, OdxLinkRef]]:
     def dyn_defined_spec(self) -> Optional[DynDefinedSpec]:
         return self.base_variant_raw.dyn_defined_spec
 
+    @property
+    def base_variant_pattern(self) -> Optional[BaseVariantPattern]:
+        return self.base_variant_raw.base_variant_pattern
+
     @property
     def parent_refs(self) -> List[ParentRef]:
         return self.base_variant_raw.parent_refs

odxtools/diaglayers/basevariant.py

@@ -3,6 +3,7 @@
 from typing import Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
+from ..basevariantpattern import BaseVariantPattern
 from ..diagvariable import DiagVariable
 from ..dyndefinedspec import DynDefinedSpec
 from ..exceptions import odxraise
@@ -23,7 +24,7 @@ class BaseVariantRaw(HierarchyElementRaw):
     diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]]
     variable_groups: NamedItemList[VariableGroup]
     dyn_defined_spec: Optional[DynDefinedSpec]
-    # TODO: base_variant_pattern: Optional[BaseVariantPattern]
+    base_variant_pattern: Optional[BaseVariantPattern]
     parent_refs: List[ParentRef]
 
     @property
@@ -63,6 +64,10 @@ def from_et(et_element: ElementTree.Element,
         if (dds_elem := et_element.find("DYN-DEFINED-SPEC")) is not None:
             dyn_defined_spec = DynDefinedSpec.from_et(dds_elem, doc_frags)
 
+        base_variant_pattern = None
+        if (bvp_elem := et_element.find("BASE-VARIANT-PATTERN")) is not None:
+            base_variant_pattern = BaseVariantPattern.from_et(bvp_elem, doc_frags)
+
         parent_refs = [
             ParentRef.from_et(pr_elem, doc_frags)
             for pr_elem in et_element.iterfind("PARENT-REFS/PARENT-REF")
@@ -72,6 +77,7 @@ def from_et(et_element: ElementTree.Element,
             diag_variables_raw=diag_variables_raw,
             variable_groups=variable_groups,
             dyn_defined_spec=dyn_defined_spec,
+            base_variant_pattern=base_variant_pattern,
             parent_refs=parent_refs,
             **kwargs)
 

odxtools/diaglayers/basevariantraw.py

@@ -14,6 +14,7 @@
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
 from ..parentref import ParentRef
 from ..variablegroup import HasVariableGroups, VariableGroup
+from .basevariant import BaseVariant
 from .diaglayer import DiagLayer
 from .ecuvariantraw import EcuVariantRaw
 from .hierarchyelement import HierarchyElement
@@ -38,6 +39,21 @@ def dyn_defined_spec(self) -> Optional[DynDefinedSpec]:
     def parent_refs(self) -> List[ParentRef]:
         return self.ecu_variant_raw.parent_refs
 
+    @property
+    def base_variant(self) -> Optional[BaseVariant]:
+        """Return the base variant for the ECU variant
+
+        The ODX specification allows at a single base variant for each
+        ECU variant, cf checker rule 50 of appendix B.2 of the
+        specification document.
+
+        """
+        for pr in self.ecu_variant_raw.parent_refs:
+            if isinstance(pr.layer, BaseVariant):
+                return pr.layer
+
+        return None
+
     @property
     def ecu_variant_patterns(self) -> List[EcuVariantPattern]:
         return self.ecu_variant_raw.ecu_variant_patterns

odxtools/diaglayers/ecuvariant.py

@@ -1,27 +1,38 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import List, Union
 from xml.etree import ElementTree
 
-from .exceptions import odxassert, odxrequire
+from typing_extensions import override
+
+from .exceptions import odxassert
+from .matchingbasevariantparameter import MatchingBaseVariantParameter
 from .matchingparameter import MatchingParameter
 from .odxlink import OdxDocFragment
+from .variantpattern import VariantPattern
 
 
 @dataclass
-class EcuVariantPattern:
+class EcuVariantPattern(VariantPattern):
+    """ECU variant patterns are variant patterns used to identify the
+    concrete variant of an ECU.
+    """
     matching_parameters: List[MatchingParameter]
 
+    @override
+    def get_matching_parameters(
+            self) -> Union[List[MatchingParameter], List[MatchingBaseVariantParameter]]:
+        return self.matching_parameters
+
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "EcuVariantPattern":
 
-        mp_collection_el = odxrequire(et_element.find("MATCHING-PARAMETERS"))
-
-        matching_params = [
+        matching_parameters = [
             MatchingParameter.from_et(mp_el, doc_frags)
-            for mp_el in mp_collection_el.iterfind("MATCHING-PARAMETER")
+            for mp_el in et_element.iterfind("MATCHING-PARAMETERS/"
+                                             "MATCHING-PARAMETER")
         ]
 
-        odxassert(len(matching_params) > 0)  # required by ISO 22901-1 Figure 141
-        return EcuVariantPattern(matching_params)
+        odxassert(len(matching_parameters) > 0)  # required by ISO 22901-1 Figure 141
+        return EcuVariantPattern(matching_parameters=matching_parameters)