odxtools 6.7.1__py3-none-any.whl → 7.1.0__py3-none-any.whl

odxtools/diaglayer.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 import re
 import warnings
+from copy import copy
 from dataclasses import dataclass
 from functools import cached_property
 from itertools import chain
@@ -14,6 +15,7 @@ from .admindata import AdminData
 from .companydata import CompanyData
 from .comparaminstance import ComparamInstance
 from .comparamspec import ComparamSpec
+from .comparamsubset import ComparamSubset
 from .diagcomm import DiagComm
 from .diagdatadictionaryspec import DiagDataDictionarySpec
 from .diaglayerraw import DiagLayerRaw
@@ -76,6 +78,50 @@ class DiagLayer:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         """Recursively resolve all references."""
 
+        # deal with the import references: these basically extend the
+        # pool of objects that are referenceable without having to
+        # explicitly specify the DOCREF attribute in the
+        # reference. This mechanism can thus be seen as a kind of
+        # "poor man's inheritance".
+        if self.import_refs:
+            imported_links: Dict[OdxLinkId, Any] = {}
+            for import_ref in self.import_refs:
+                imported_dl = odxlinks.resolve(import_ref, DiagLayer)
+
+                odxassert(
+                    imported_dl.variant_type == DiagLayerType.ECU_SHARED_DATA,
+                    f"Tried to import references from diagnostic layer "
+                    f"'{imported_dl.short_name}' of type {imported_dl.variant_type.value}. "
+                    f"Only ECU-SHARED-DATA layers may be referenced using the "
+                    f"IMPORT-REF mechanism")
+
+                # TODO: ensure that the imported diagnostic layer has
+                # not been referenced in any PARENT-REF of the current
+                # layer or any of its parents.
+
+                # TODO: detect and complain about cyclic IMPORT-REFs
+
+                # TODO (?): detect conflicts with locally-defined
+                # objects
+
+                imported_dl_links = imported_dl._build_odxlinks()
+                for link_id, obj in imported_dl_links.items():
+                    # the imported objects shall behave as if they
+                    # were defined by the importing layer. IOW, they
+                    # must be visible in the same document fragments.
+                    link_id = OdxLinkId(link_id.local_id, self.odx_id.doc_fragments)
+                    imported_links[link_id] = obj
+
+            # We need to copy the odxlink database here since this
+            # function must not modify its argument because the
+            # imported references only apply within this specific
+            # diagnostic layer
+            extended_odxlinks = copy(odxlinks)
+            extended_odxlinks.update(imported_links)
+
+            self.diag_layer_raw._resolve_odxlinks(extended_odxlinks)
+            return
+
         self.diag_layer_raw._resolve_odxlinks(odxlinks)
 
     def _finalize_init(self, odxlinks: OdxLinkDatabase) -> None:
@@ -171,6 +217,10 @@ class DiagLayer:
             lambda ddd_spec: ddd_spec.end_of_pdu_fields,
             lambda parent_ref: parent_ref.not_inherited_dops,
         )
+        dynamic_endmarker_fields = self._compute_available_ddd_spec_items(
+            lambda ddd_spec: ddd_spec.dynamic_endmarker_fields,
+            lambda parent_ref: parent_ref.not_inherited_dops,
+        )
         dynamic_length_fields = self._compute_available_ddd_spec_items(
             lambda ddd_spec: ddd_spec.dynamic_length_fields,
             lambda parent_ref: parent_ref.not_inherited_dops,
@@ -201,6 +251,7 @@ class DiagLayer:
             structures=structures,
             static_fields=NamedItemList(),
             end_of_pdu_fields=end_of_pdu_fields,
+            dynamic_endmarker_fields=dynamic_endmarker_fields,
             dynamic_length_fields=dynamic_length_fields,
             tables=tables,
             env_data_descs=env_data_descs,
@@ -306,7 +357,7 @@ class DiagLayer:
         return self.diag_layer_raw.prot_stack_snref
 
     @property
-    def comparam_spec(self) -> Optional[ComparamSpec]:
+    def comparam_spec(self) -> Optional[Union[ComparamSpec, ComparamSubset]]:
         return self.diag_layer_raw.comparam_spec
 
     @property

odxtools/diaglayerraw.py

@@ -9,6 +9,7 @@ from .admindata import AdminData
 from .companydata import CompanyData
 from .comparaminstance import ComparamInstance
 from .comparamspec import ComparamSpec
+from .comparamsubset import ComparamSubset
 from .createsdgs import create_sdgs_from_et
 from .diagcomm import DiagComm
 from .diagdatadictionaryspec import DiagDataDictionarySpec
@@ -19,7 +20,7 @@ from .element import IdentifiableElement
 from .exceptions import odxassert, odxraise, odxrequire
 from .functionalclass import FunctionalClass
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .parentref import ParentRef
 from .protstack import ProtStack
 from .request import Request
@@ -243,7 +244,10 @@ class DiagLayerRaw(IdentifiableElement):
         """Recursively resolve all references."""
 
         if self.comparam_spec_ref is not None:
-            self._comparam_spec = odxlinks.resolve(self.comparam_spec_ref, ComparamSpec)
+            spec = odxlinks.resolve(self.comparam_spec_ref)
+            if not isinstance(spec, (ComparamSubset, ComparamSpec)):
+                odxraise(f"Type {type(spec).__name__} is not allowed for comparam specs")
+            self._comparam_spec = spec
 
         # do ODXLINK reference resolution
         if self.admin_data is not None:
@@ -281,8 +285,10 @@ class DiagLayerRaw(IdentifiableElement):
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         self._prot_stack: Optional[ProtStack] = None
         if self.prot_stack_snref is not None:
-            self._prot_stack = odxrequire(
-                odxrequire(self.comparam_spec).prot_stacks.get(self.prot_stack_snref))
+            cp_spec = self.comparam_spec
+            if isinstance(cp_spec, ComparamSpec):
+                self._prot_stack = resolve_snref(self.prot_stack_snref, cp_spec.prot_stacks,
+                                                 ProtStack)
 
         # do short-name reference resolution
         if self.admin_data is not None:
@@ -292,8 +298,8 @@ class DiagLayerRaw(IdentifiableElement):
 
         for company_data in self.company_datas:
             company_data._resolve_snrefs(diag_layer)
-        for functional_classe in self.functional_classes:
-            functional_classe._resolve_snrefs(diag_layer)
+        for functional_class in self.functional_classes:
+            functional_class._resolve_snrefs(diag_layer)
         for diag_comm in self.diag_comms:
             if isinstance(diag_comm, OdxLinkRef):
                 continue
@@ -318,7 +324,7 @@ class DiagLayerRaw(IdentifiableElement):
             comparam._resolve_snrefs(diag_layer)
 
     @property
-    def comparam_spec(self) -> Optional[ComparamSpec]:
+    def comparam_spec(self) -> Optional[Union[ComparamSpec, ComparamSubset]]:
         return self._comparam_spec
 
     @property

odxtools/diagservice.py

@@ -215,13 +215,9 @@ class DiagService(DiagComm):
             coding_object=coding_object,
             param_dict=param_dict)
 
-    def encode_request(self, **params: ParameterValue) -> bytes:
+    def encode_request(self, **kwargs: ParameterValue) -> bytes:
         """
-        Composes an UDS request as list of bytes for this service.
-        Parameters:
-        ----------
-        params: dict
-            Parameters of the RPC as mapping from SHORT-NAME of the parameter to the physical value
+        Composes an UDS request an array of bytes for this service.
         """
         # make sure that all parameters which are required for
         # encoding are specified (parameters which have a default are
@@ -230,31 +226,31 @@ class DiagService(DiagComm):
             return b''
 
         missing_params = {x.short_name
-                          for x in self.request.required_parameters}.difference(params.keys())
+                          for x in self.request.required_parameters}.difference(kwargs.keys())
         odxassert(
             len(missing_params) == 0, f"The parameters {missing_params} are required but missing!")
 
         # make sure that no unknown parameters are specified
         rq_all_param_names = {x.short_name for x in self.request.parameters}
         odxassert(
-            set(params.keys()).issubset(rq_all_param_names),
-            f"Unknown parameters specified for encoding: {params.keys()}, "
+            set(kwargs.keys()).issubset(rq_all_param_names),
+            f"Unknown parameters specified for encoding: {kwargs.keys()}, "
             f"known parameters are: {rq_all_param_names}")
-        return self.request.encode(coded_request=None, **params)
+        return self.request.encode(**kwargs)
 
     def encode_positive_response(self,
                                  coded_request: bytes,
                                  response_index: int = 0,
-                                 **params: ParameterValue) -> bytes:
+                                 **kwargs: ParameterValue) -> bytes:
         # TODO: Should the user decide the positive response or what are the differences?
-        return self.positive_responses[response_index].encode(coded_request, **params)
+        return self.positive_responses[response_index].encode(coded_request, **kwargs)
 
     def encode_negative_response(self,
                                  coded_request: bytes,
                                  response_index: int = 0,
-                                 **params: ParameterValue) -> bytes:
-        return self.negative_responses[response_index].encode(coded_request, **params)
+                                 **kwargs: ParameterValue) -> bytes:
+        return self.negative_responses[response_index].encode(coded_request, **kwargs)
 
-    def __call__(self, **params: ParameterValue) -> bytes:
+    def __call__(self, **kwargs: ParameterValue) -> bytes:
         """Encode a request."""
-        return self.encode_request(**params)
+        return self.encode_request(**kwargs)

odxtools/dopbase.py

@@ -21,7 +21,8 @@ if TYPE_CHECKING:
 class DopBase(IdentifiableElement):
     """Base class for all DOPs.
 
-    Any class that a parameter can reference via a DOP-REF should inherit from this class.
+    Any class that a parameter can reference via a DOP-REF should
+    inherit from this class.
     """
 
     admin_data: Optional[AdminData]
@@ -60,15 +61,11 @@ class DopBase(IdentifiableElement):
         return None
 
     def is_valid_physical_value(self, physical_value: ParameterValue) -> bool:
-        """Determine if a phyical value can be handled by the DOP
-        """
+        """Determine if a phyical value can be handled by the DOP"""
         raise NotImplementedError
 
-    def convert_physical_to_bytes(self,
-                                  physical_value: ParameterValue,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
-        """Convert the physical value into bytes."""
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
+        """Convert the physical value to bytes and emplace them into a PDU."""
         raise NotImplementedError
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/dtcdop.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, cast
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .compumethods.compumethod import CompuMethod
 from .compumethods.createanycompumethod import create_any_compu_method_from_et
 from .createanydiagcodedtype import create_any_diag_coded_type_from_et
@@ -12,7 +14,7 @@ from .diagcodedtype import DiagCodedType
 from .diagnostictroublecode import DiagnosticTroubleCode
 from .dopbase import DopBase
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxassert, odxrequire
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValue, odxstr_to_bool
@@ -87,17 +89,20 @@ class DtcDop(DopBase):
     def linked_dtc_dops(self) -> NamedItemList["DtcDop"]:
         return self._linked_dtc_dops
 
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
 
         int_trouble_code = self.diag_coded_type.decode_from_pdu(decode_state)
 
-        if self.compu_method.is_valid_internal_value(int_trouble_code):
-            trouble_code = self.compu_method.convert_internal_to_physical(int_trouble_code)
-        else:
+        if not self.compu_method.is_valid_internal_value(int_trouble_code):
             # TODO: How to prevent this?
-            raise DecodeError(
+            odxraise(
                 f"DTC-DOP {self.short_name} could not convert the coded value "
-                f" {repr(int_trouble_code)} to physical type {self.physical_type.base_data_type}.")
+                f" {repr(int_trouble_code)} to physical type {self.physical_type.base_data_type}.",
+                DecodeError)
+            return
+
+        trouble_code = self.compu_method.convert_internal_to_physical(int_trouble_code)
 
         assert isinstance(trouble_code, int)
 
@@ -110,10 +115,12 @@ class DtcDop(DopBase):
             return dtcs[0]
 
         # the DTC was not specified. This probably means that the
-        # diagnostic description file is incomplete. We do not bail
-        # out but we cannot provide an interpretation for it out of the
-        # box...
-        dtc = DiagnosticTroubleCode(
+        # diagnostic description file is incomplete.
+        odxraise(
+            f"Encountered DTC 0x{trouble_code:06x} which has not been defined "
+            f"by the database", DecodeError)
+
+        return DiagnosticTroubleCode(
             trouble_code=trouble_code,
             odx_id=cast(OdxLinkId, None),
             short_name=f'DTC_{trouble_code:06x}',
@@ -126,12 +133,9 @@ class DtcDop(DopBase):
             sdgs=[],
         )
 
-        return dtc
-
-    def convert_physical_to_bytes(self,
-                                  physical_value: ParameterValue,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
+    @override
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
         if isinstance(physical_value, DiagnosticTroubleCode):
             trouble_code = physical_value.trouble_code
         elif isinstance(physical_value, int):
@@ -147,9 +151,7 @@ class DtcDop(DopBase):
                               f" DiagnosticTroubleCode but got {physical_value!r}.")
 
         internal_trouble_code = self.compu_method.convert_physical_to_internal(trouble_code)
-
-        return self.diag_coded_type.convert_internal_to_bytes(
-            internal_trouble_code, encode_state=encode_state, bit_position=bit_position)
+        self.diag_coded_type.encode_into_pdu(internal_trouble_code, encode_state)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()

odxtools/dynamicendmarkerfield.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List, Sequence
+from xml.etree import ElementTree
+
+from typing_extensions import override
+
+from .dataobjectproperty import DataObjectProperty
+from .decodestate import DecodeState
+from .dynenddopref import DynEndDopRef
+from .encodestate import EncodeState
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from .field import Field
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import AtomicOdxType, ParameterValue
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .diaglayer import DiagLayer
+
+
+@dataclass
+class DynamicEndmarkerField(Field):
+    """Array of a structure with variable length determined by a termination sequence"""
+
+    dyn_end_dop_ref: DynEndDopRef
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynamicEndmarkerField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+
+        dyn_end_dop_ref = DynEndDopRef.from_et(
+            odxrequire(et_element.find("DYN-END-DOP-REF")), doc_frags)
+
+        return DynamicEndmarkerField(dyn_end_dop_ref=dyn_end_dop_ref, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        self._dyn_end_dop = odxlinks.resolve(self.dyn_end_dop_ref, DataObjectProperty)
+
+        tv_string = self.dyn_end_dop_ref.termination_value_raw
+        tv_physical = self._dyn_end_dop.diag_coded_type.base_data_type.from_string(tv_string)
+
+        self._termination_value = tv_physical
+
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        super()._resolve_snrefs(diag_layer)
+
+    @property
+    def dyn_end_dop(self) -> DataObjectProperty:
+        return self._dyn_end_dop
+
+    @property
+    def termination_value(self) -> AtomicOdxType:
+        return self._termination_value
+
+    @override
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
+
+        odxassert(encode_state.cursor_bit_position == 0,
+                  "No bit position can be specified for dynamic endmarker fields!")
+        if not isinstance(physical_value, Sequence):
+            odxraise(
+                f"Expected a sequence of values for dynamic endmarker field {self.short_name}, "
+                f"got {type(physical_value).__name__}", EncodeError)
+            return
+
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
+        for i, item in enumerate(physical_value):
+            if i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+            self.structure.encode_into_pdu(item, encode_state)
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+        if not encode_state.is_end_of_pdu:
+            # only add an endmarker if we are not at the end of the PDU
+            self.dyn_end_dop.encode_into_pdu(self.termination_value, encode_state)
+
+    @override
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+
+        odxassert(decode_state.cursor_bit_position == 0,
+                  "No bit position can be specified for dynamic endmarker fields!")
+
+        orig_origin = decode_state.origin_byte_position
+        orig_cursor = decode_state.cursor_byte_position
+        decode_state.origin_byte_position = decode_state.cursor_byte_position
+
+        result: List[ParameterValue] = []
+        while True:
+            # check if we're at the end of the PDU
+            if decode_state.cursor_byte_position == len(decode_state.coded_message):
+                break
+
+            # check if the cursor currently points to a termination
+            # value
+            tmp_cursor = decode_state.cursor_byte_position
+            try:
+                tv_candidate = self.dyn_end_dop.decode_from_pdu(decode_state)
+                if tv_candidate == self.termination_value:
+                    break
+            except DecodeError:
+                pass
+            decode_state.cursor_byte_position = tmp_cursor
+
+            result.append(self.structure.decode_from_pdu(decode_state))
+
+        decode_state.origin_byte_position = orig_origin
+        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
+
+        return result

odxtools/dynamiclengthfield.py

@@ -1,8 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Sequence
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .decodestate import DecodeState
 from .determinenumberofitems import DetermineNumberOfItems
 from .encodestate import EncodeState
@@ -47,44 +49,52 @@ class DynamicLengthField(Field):
         super()._resolve_snrefs(diag_layer)
         self.determine_number_of_items._resolve_snrefs(diag_layer)
 
-    def convert_physical_to_bytes(
-        self,
-        physical_value: ParameterValue,
-        encode_state: EncodeState,
-        bit_position: int = 0,
-    ) -> bytes:
+    @override
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
+
+        odxassert(encode_state.cursor_bit_position == 0,
+                  "No bit position can be specified for dynamic length fields!")
 
-        odxassert(bit_position == 0, "No bit position can be specified for dynamic length fields!")
-        if not isinstance(physical_value, list):
+        if not isinstance(physical_value, Sequence):
             odxraise(
                 f"Expected a list of values for dynamic length field {self.short_name}, "
                 f"got {type(physical_value)}", EncodeError)
 
+        # move the origin to the cursor position
+        orig_cursor = encode_state.cursor_byte_position
+        orig_origin = encode_state.origin_byte_position
+        encode_state.origin_byte_position = encode_state.cursor_byte_position
+
         det_num_items = self.determine_number_of_items
-        field_len = det_num_items.dop.convert_physical_to_bytes(
-            len(physical_value), encode_state, det_num_items.bit_position or 0)
-
-        # hack to emplace the length specifier at the correct location
-        tmp = encode_state.coded_message
-        encode_state.coded_message = bytearray()
-        encode_state.emplace_atomic_value(field_len, self.short_name + ".num_items",
-                                          det_num_items.byte_position)
-        result = encode_state.coded_message
-        encode_state.coded_message = tmp
-
-        # if required, add padding between the length specifier and
-        # the first item
-        if len(result) < self.offset:
-            result.extend([0] * (self.offset - len(result)))
-        elif len(result) > self.offset:
+        encode_state.cursor_bit_position = self.determine_number_of_items.bit_position or 0
+        encode_state.cursor_byte_position = encode_state.origin_byte_position + det_num_items.byte_position
+        det_num_items.dop.encode_into_pdu(len(physical_value), encode_state)
+
+        if encode_state.cursor_byte_position - encode_state.origin_byte_position > self.offset:
             odxraise(f"The length specifier of field {self.short_name} overlaps "
-                     f"with the first item!")
+                     f"with its first item!")
 
-        for value in physical_value:
-            result += self.structure.convert_physical_to_bytes(value, encode_state)
+        encode_state.cursor_byte_position = encode_state.origin_byte_position + self.offset
+        encode_state.cursor_bit_position = 0
 
-        return result
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
+        for i, value in enumerate(physical_value):
+            if i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+            self.structure.encode_into_pdu(value, encode_state)
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+        # ensure the correct message size if the field is empty
+        if len(physical_value) == 0:
+            encode_state.emplace_bytes(b"")
+
+        # move cursor and origin positions
+        encode_state.origin_byte_position = orig_origin
+        encode_state.cursor_byte_position = max(orig_cursor, encode_state.cursor_byte_position)
 
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
 
         odxassert(decode_state.cursor_bit_position == 0,

odxtools/dynenddopref.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional, overload
+from xml.etree import ElementTree
+
+from .exceptions import odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkRef
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class DynEndDopRef(OdxLinkRef):
+    termination_value_raw: str
+
+    @staticmethod
+    @overload
+    def from_et(et_element: None, source_doc_frags: List[OdxDocFragment]) -> None:
+        ...
+
+    @staticmethod
+    @overload
+    def from_et(et_element: ElementTree.Element,
+                source_doc_frags: List[OdxDocFragment]) -> "DynEndDopRef":
+        ...
+
+    @staticmethod
+    def from_et(et_element: Optional[ElementTree.Element],
+                source_doc_frags: List[OdxDocFragment]) -> Optional["DynEndDopRef"]:
+
+        if et_element is None:
+            odxraise("Mandatory DYN-END-DOP-REF tag is missing")
+            return None
+
+        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, source_doc_frags))
+
+        termination_value_raw = odxrequire(et_element.findtext("TERMINATION-VALUE"))
+
+        return DynEndDopRef(termination_value_raw=termination_value_raw, **kwargs)