odxtools 9.4.1__py3-none-any.whl → 9.5.0__py3-none-any.whl

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/dataobjectproperty.py

@@ -17,7 +17,7 @@ from .odxtypes import AtomicOdxType, ParameterValue
 from .physicaltype import PhysicalType
 from .snrefcontext import SnRefContext
 from .unit import Unit
-from .utils import dataclass_fields_asdict
+from .utils import BytesTypes, dataclass_fields_asdict
 
 
 @dataclass
@@ -120,7 +120,7 @@ class DataObjectProperty(DopBase):
                 f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
                 f" is not a valid.")
 
-        if not isinstance(physical_value, (int, float, str, bytes, bytearray)):
+        if not isinstance(physical_value, (int, float, str, BytesTypes)):
             odxraise(f"Invalid type '{type(physical_value).__name__}' for physical value. "
                      f"(Expect atomic type!)")
         internal_value = self.compu_method.convert_physical_to_internal(physical_value)

odxtools/diaglayers/basevariant.py

@@ -6,6 +6,7 @@ from xml.etree import ElementTree
 
 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 @@ class BaseVariant(HierarchyElement):
     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/basevariantraw.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 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 @@ class BaseVariantRaw(HierarchyElementRaw):
         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 @@ class BaseVariantRaw(HierarchyElementRaw):
             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/ecuvariant.py

@@ -14,6 +14,7 @@ from ..nameditemlist import NamedItemList
 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 @@ class EcuVariant(HierarchyElement):
     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/ecuvariantpattern.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)

odxtools/encodestate.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, List, Optional, SupportsBytes, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from .encoding import Encoding, get_string_encoding
 from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
 from .odxtypes import AtomicOdxType, DataType, ParameterValue
+from .utils import BytesTypes
 
 try:
     import bitstruct.c as bitstruct
@@ -97,7 +98,7 @@ class EncodeState:
 
         # Deal with raw byte fields, ...
         if base_data_type == DataType.A_BYTEFIELD:
-            if not isinstance(internal_value, (bytes, bytearray, SupportsBytes)):
+            if not isinstance(internal_value, BytesTypes):
                 odxraise(f"{internal_value!r} is not a bytefield", EncodeError)
                 return
 

odxtools/matchingbasevariantparameter.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .matchingparameter import MatchingParameter
+from .odxlink import OdxDocFragment
+from .odxtypes import odxstr_to_bool
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class MatchingBaseVariantParameter(MatchingParameter):
+    """A description of a parameter used for base variant matching.
+
+    This is very similar to `MatchingParameter` for ECU variant
+    matching, but `MatchingBaseVariantParameter` features the
+    additional subtag `USE-PHYSICAL-ADDRESSING`.
+    """
+
+    use_physical_addressing_raw: Optional[bool]
+
+    @property
+    def use_physical_addressing(self) -> bool:
+        return self.use_physical_addressing_raw in [None, True]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "MatchingBaseVariantParameter":
+
+        kwargs = dataclass_fields_asdict(MatchingParameter.from_et(et_element, doc_frags))
+
+        use_physical_addressing_raw = odxstr_to_bool(et_element.findtext("USE-PHYSICAL-ADDRESSING"))
+
+        return MatchingBaseVariantParameter(
+            use_physical_addressing_raw=use_physical_addressing_raw,
+            **kwargs,
+        )

odxtools/matchingparameter.py

@@ -1,58 +1,139 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
-from .exceptions import odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment
-from .utils import is_short_name, is_short_name_path
+from .diaglayers.diaglayer import DiagLayer
+from .diagnostictroublecode import DiagnosticTroubleCode
+from .diagservice import DiagService
+from .exceptions import odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .odxtypes import ParameterValue, ParameterValueDict
+from .snrefcontext import SnRefContext
+from .utils import BytesTypes
 
 
 @dataclass
 class MatchingParameter:
-    """According to ISO 22901, a MatchingParameter contains a string value identifying
-    the active ECU variant. Moreover, it references a DIAG-COMM via snref and one of its
-    positive response's OUT-PARAM-IF via snref or snpathref.
+    """According to ISO 22901, a MatchingParameter contains a string
+    value identifying the active ECU or base variant. Moreover, it
+    references a DIAG-COMM via snref and one of its positive
+    response's OUT-PARAM-IF via snref or snpathref.
+
+    Unlike other parameters defined in the `parameters` package, a
+    MatchingParameter is not transferred over the network.
 
-    Unlike other parameters defined in the `parameters` package, a MatchingParameter is
-    not transferred over the network.
     """
 
-    # datatype according to ISO 22901-1 Figure 141
     expected_value: str
     diag_comm_snref: str
-    out_param_if: str
 
-    def __post_init__(self) -> None:
-        odxassert(is_short_name(self.diag_comm_snref))
-        odxassert(is_short_name_path(self.out_param_if))
+    # be aware that the checker rules 23 and 110 contradict each other
+    # here: the first specifies that the referenced parameter must be
+    # present in *all* positive responses of the referenced service,
+    # whilst the latter mandates it to be present least one positive
+    # or negative response. What it probably actually wants to say is
+    # that any response that can possibly be received shall exhibit
+    # the referenced parameter.
+    out_param_if_snref: Optional[str]
+    out_param_if_snpathref: Optional[str]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MatchingParameter":
 
         expected_value = odxrequire(et_element.findtext("EXPECTED-VALUE"))
-        diag_comm_snref_el = odxrequire(et_element.find("DIAG-COMM-SNREF"))
-        diag_comm_snref = odxrequire(diag_comm_snref_el.get("SHORT-NAME"))
-        out_param_snref_el = et_element.find("OUT-PARAM-IF-SNREF")
-        out_param_snpathref_el = et_element.find("OUT-PARAM-IF-SNPATHREF")
-        out_param_if = None
-        if out_param_snref_el is not None:
-            out_param_if = out_param_snref_el.get("SHORT-NAME")
-        elif out_param_snpathref_el is not None:
-            out_param_if = out_param_snpathref_el.get("SHORT-NAME-PATH")
-        if out_param_if is None:
+        diag_comm_snref = odxrequire(
+            odxrequire(et_element.find("DIAG-COMM-SNREF")).get("SHORT-NAME"))
+
+        out_param_if_snref = None
+        out_param_if_snpathref = None
+        if (out_param_snref_el := et_element.find("OUT-PARAM-IF-SNREF")) is not None:
+            out_param_if_snref = odxrequire(out_param_snref_el.get("SHORT-NAME"))
+        elif (out_param_snpathref_el := et_element.find("OUT-PARAM-IF-SNPATHREF")) is not None:
+            out_param_if_snpathref = odxrequire(out_param_snpathref_el.get("SHORT-NAME-PATH"))
+        else:
             odxraise("Output parameter must not left unspecified")
 
         return MatchingParameter(
             expected_value=expected_value,
             diag_comm_snref=diag_comm_snref,
-            out_param_if=out_param_if,
+            out_param_if_snref=out_param_if_snref,
+            out_param_if_snpathref=out_param_if_snpathref,
         )
 
-    def is_match(self, ident_value: str) -> bool:
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # note that we do not resolve the SNREF to the diag layer here
+        # because it is a component which changes depending on the
+        # execution context and for variant patterns the execution
+        # context is highly volatile w.r.t. the diag layer in question
+        pass
+
+    def get_ident_service(self, diag_layer: DiagLayer) -> DiagService:
+        return resolve_snref(self.diag_comm_snref, diag_layer.services, DiagService)
+
+    def matches(self, param_dict: ParameterValueDict) -> bool:
         """
         Returns true iff the provided identification value matches this MatchingParameter's
         expected value.
         """
-        return self.expected_value == ident_value
+
+        if self.out_param_if_snref is not None:
+            snpath_chunks = [self.out_param_if_snref]
+        elif self.out_param_if_snpathref is not None:
+            snpath_chunks = self.out_param_if_snpathref.split(".")
+        else:
+            odxraise("no out_param_if specified")
+            return False
+
+        return self.__matches(param_dict, snpath_chunks)
+
+    def __matches(self, param_dict: ParameterValue, snpath_chunks: List[str]) -> bool:
+        if len(snpath_chunks) == 0:
+            parameter_value = param_dict
+            if isinstance(parameter_value, dict):
+                odxraise(f"Parameter must not be a structure")
+                return False
+
+            if isinstance(parameter_value, float):
+                # allow a slight tolerance if the expected value is
+                # floating point
+                return abs(float(self.expected_value) - parameter_value) < 1e-8
+            elif isinstance(parameter_value, BytesTypes):
+                return parameter_value.hex().upper() == self.expected_value.upper()
+            elif isinstance(parameter_value, DiagnosticTroubleCode):
+                # TODO: what happens if non-numerical DTCs like
+                # "U123456" are specified? Is specifying DTCs even
+                # allowed in variant patterns?
+                return hex(parameter_value.trouble_code).upper() == self.expected_value.upper()
+            else:
+                return self.expected_value == str(parameter_value)
+
+        if not isinstance(param_dict, dict):
+            odxraise(f"Parameter {snpath_chunks[0]} must be a structure")
+            return False
+
+        sub_value = param_dict.get(snpath_chunks[0])
+        if sub_value is None:
+            return False
+
+        if isinstance(sub_value, tuple) and len(sub_value) == 2:
+            # table struct parameter
+            sub_value = sub_value[1]
+
+        if isinstance(sub_value, list):
+            # the spec mandates that if any item of a field matches,
+            # the parameter as a whole matches
+            for x in sub_value:
+                if self.__matches(x, snpath_chunks[1:]):
+                    return True
+
+            return False
+
+        return self.__matches(cast(ParameterValue, sub_value), snpath_chunks[1:])

odxtools/minmaxlengthtype.py

@@ -10,10 +10,10 @@ from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .encoding import get_string_encoding
-from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from .exceptions import (DecodeError, EncodeError, odxassert, odxraise, odxrequire)
 from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, DataType
-from .utils import dataclass_fields_asdict
+from .utils import BytesTypes, dataclass_fields_asdict
 
 
 class Termination(Enum):
@@ -83,7 +83,7 @@ class MinMaxLengthType(DiagCodedType):
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 
-        if not isinstance(internal_value, (bytes, str, bytearray)):
+        if not isinstance(internal_value, (str, BytesTypes)):
             odxraise("MinMaxLengthType is currently only implemented for strings and byte arrays",
                      EncodeError)
 

odxtools/odxtypes.py

@@ -5,6 +5,7 @@ from typing import (TYPE_CHECKING, Any, Callable, Dict, Iterable, Optional, Tupl
 from xml.etree import ElementTree
 
 from .exceptions import odxassert, odxraise, odxrequire
+from .utils import BytesTypes
 
 if TYPE_CHECKING:
     from odxtools.diagnostictroublecode import DiagnosticTroubleCode
@@ -135,8 +136,8 @@ def compare_odx_values(a: AtomicOdxType, b: AtomicOdxType) -> int:
 
     # bytefields are treated like long integers: to pad the shorter
     # object with zeros and treat the results like strings.
-    if isinstance(a, (bytes, bytearray)):
-        if not isinstance(b, (bytes, bytearray)):
+    if isinstance(a, BytesTypes):
+        if not isinstance(b, BytesTypes):
             odxraise()
 
         obj_len = max(len(a), len(b))
@@ -237,7 +238,7 @@ class DataType(Enum):
             return True
         elif expected_type is float and isinstance(value, (int, float)):
             return True
-        elif self == DataType.A_BYTEFIELD and isinstance(value, (bytearray, bytes)):
+        elif self == DataType.A_BYTEFIELD and isinstance(value, BytesTypes):
             return True
         else:
             return False

odxtools/standardlengthtype.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from typing import List, Literal, Optional
 from xml.etree import ElementTree
 
-from typing_extensions import SupportsBytes, override
+from typing_extensions import override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
@@ -11,7 +11,7 @@ from .encodestate import EncodeState
 from .exceptions import odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, DataType, odxstr_to_bool
-from .utils import dataclass_fields_asdict
+from .utils import BytesTypes, dataclass_fields_asdict
 
 
 @dataclass
@@ -91,7 +91,7 @@ class StandardLengthType(DiagCodedType):
             return used_mask.to_bytes((bit_sz + 7) // 8, endianness)
 
         sz: int
-        if isinstance(internal_value, (bytearray, SupportsBytes)):
+        if isinstance(internal_value, BytesTypes):
             sz = len(bytes(internal_value))
         else:
             sz = (odxrequire(self.get_static_bit_length()) + 7) // 8
@@ -107,7 +107,7 @@ class StandardLengthType(DiagCodedType):
 
         if self.is_condensed:
             int_value: int
-            if isinstance(internal_value, (bytearray, SupportsBytes)):
+            if isinstance(internal_value, BytesTypes):
                 int_value = int.from_bytes(internal_value, 'big')
             elif isinstance(internal_value, int):
                 int_value = internal_value
@@ -126,14 +126,14 @@ class StandardLengthType(DiagCodedType):
 
                 mask_bit += 1
 
-            if isinstance(internal_value, (bytearray, SupportsBytes)):
+            if isinstance(internal_value, BytesTypes):
                 return result.to_bytes(len(internal_value), 'big')
 
             return result
 
         if isinstance(internal_value, int):
             return internal_value & self.bit_mask
-        if isinstance(internal_value, (bytearray, SupportsBytes)):
+        if isinstance(internal_value, BytesTypes):
             int_value = int.from_bytes(internal_value, 'big')
             int_value &= self.bit_mask
             return int_value.to_bytes(len(bytes(internal_value)), 'big')
@@ -146,7 +146,7 @@ class StandardLengthType(DiagCodedType):
             return raw_value
         if self.is_condensed:
             int_value: int
-            if isinstance(raw_value, (bytearray, SupportsBytes)):
+            if isinstance(raw_value, BytesTypes):
                 int_value = int.from_bytes(raw_value, 'big')
             elif isinstance(raw_value, int):
                 int_value = raw_value
@@ -164,16 +164,16 @@ class StandardLengthType(DiagCodedType):
 
                 mask_bit += 1
 
-            if isinstance(raw_value, (bytearray, SupportsBytes)):
+            if isinstance(raw_value, BytesTypes):
                 return result.to_bytes(len(raw_value), 'big')
 
             return result
         if isinstance(raw_value, int):
             return raw_value & self.bit_mask
-        if isinstance(raw_value, (bytearray, SupportsBytes)):
+        if isinstance(raw_value, BytesTypes):
             int_value = int.from_bytes(raw_value, 'big')
             int_value &= self.bit_mask
-            return int_value
+            return int_value.to_bytes(len(raw_value), 'big')
 
         odxraise(f'Can not apply a bit_mask on a value of type {type(raw_value)}')
         return raw_value

odxtools/subcomponent.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .diagnostictroublecode import DiagnosticTroubleCode
@@ -10,7 +10,6 @@ from .element import IdentifiableElement, NamedElement
 from .environmentdata import EnvironmentData
 from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxraise, odxrequire
-from .matchingparameter import MatchingParameter
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .parameters.parameter import Parameter
@@ -19,14 +18,18 @@ from .table import Table
 from .tablerow import TableRow
 from .utils import dataclass_fields_asdict
 
+if TYPE_CHECKING:
+    from .matchingparameter import MatchingParameter
+
 
 @dataclass
 class SubComponentPattern:
-    matching_parameters: List[MatchingParameter]
+    matching_parameters: List["MatchingParameter"]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "SubComponentPattern":
+        from .matchingparameter import MatchingParameter
 
         matching_parameters = [
             MatchingParameter.from_et(el, doc_frags)

odxtools/templates/macros/printBaseVariant.xml.jinja2

@@ -6,6 +6,7 @@
 {%- import('macros/printHierarchyElement.xml.jinja2') as phe %}
 {%- import('macros/printComparamRef.xml.jinja2') as pcom %}
 {%- import('macros/printParentRef.xml.jinja2') as pparref %}
+{%- import('macros/printBaseVariantPattern.xml.jinja2') as pbvp %}
 
 {%- macro printBaseVariant(base_variant) -%}
 <BASE-VARIANT {{- phe.printHierarchyElementAttribs(base_variant) -}}>
@@ -29,18 +30,12 @@
   {%- endif %}
 
   {%- if dlr.dyn_defined_spec %}
-  {{ pdynspec.printPrintDefinedSpec(dlr.dyn_defined_spec)|indent(4) }}
+  {{ pdynspec.printPrintDefinedSpec(dlr.dyn_defined_spec)|indent(2) }}
   {%- endif %}
 
-{#
-  {%- if dlr.base_variant_patterns %}
-  <BASE-VARIANT-PATTERNS>
-    {%- for vp in dlr.base_variant_patterns -%}
-    {{ pvpat.printBaseVariantPattern(vp)|indent(4) }}
-    {%- endfor -%}
-  </BASE-VARIANT-PATTERNS>
+  {%- if dlr.base_variant_pattern is not none %}
+  {{ pbvp.printBaseVariantPattern(dlr.base_variant_pattern)|indent(2) }}
   {%- endif %}
-#}
 
   {%- if dlr.parent_refs %}
   <PARENT-REFS>

odxtools/templates/macros/printBaseVariantPattern.xml.jinja2

@@ -0,0 +1,32 @@
+{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- macro printMatchingBaseVariantParameter(mbvp) -%}
+<MATCHING-BASE-VARIANT-PARAMETER>
+  <EXPECTED-VALUE>{{mbvp.expected_value | e}}</EXPECTED-VALUE>
+  {%- if mbvp.use_physical_addressing_raw is true %}
+  <USE-PHYSICAL-ADDRESSING>true</USE-PHYSICAL-ADDRESSING>
+  {%- elif mbvp.use_physical_addressing_raw is false %}
+  <USE-PHYSICAL-ADDRESSING>false</USE-PHYSICAL-ADDRESSING>
+  {%- endif %}
+  <DIAG-COMM-SNREF SHORT-NAME="{{mbvp.diag_comm_snref}}" />
+  {%- if mbvp.out_param_if_snref is not none %}
+  <OUT-PARAM-IF-SNREF SHORT-NAME="{{mbvp.out_param_if_snref}}" />
+  {%- endif %}
+  {%- if mbvp.out_param_if_snpathref is not none %}
+  <OUT-PARAM-IF-SNPATHREF SHORT-NAME-PATH="{{mbvp.out_param_if_snpathref}}" />
+  {%- endif %}
+</MATCHING-BASE-VARIANT-PARAMETER>
+{%- endmacro -%}
+
+{%- macro printBaseVariantPattern(vp) -%}
+<BASE-VARIANT-PATTERN>
+ <MATCHING-BASE-VARIANT-PARAMETERS>
+  {%- for mbvp in vp.matching_base_variant_parameters %}
+  {{ printMatchingBaseVariantParameter(mbvp) | indent(2) }}
+  {%- endfor %}
+ </MATCHING-BASE-VARIANT-PARAMETERS>
+</BASE-VARIANT-PATTERN>
+{%- endmacro -%}