odxtools 6.7.0__py3-none-any.whl → 9.3.0__py3-none-any.whl

odxtools/dataobjectproperty.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from .compumethods.compumethod import CompuMethod
@@ -10,17 +10,15 @@ from .decodestate import DecodeState
 from .diagcodedtype import DiagCodedType
 from .dopbase import DopBase
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxassert, odxrequire
+from .exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from .internalconstr import InternalConstr
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, ParameterValue
 from .physicaltype import PhysicalType
+from .snrefcontext import SnRefContext
 from .unit import Unit
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DataObjectProperty(DopBase):
@@ -86,6 +84,7 @@ class DataObjectProperty(DopBase):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
         result.update(self.diag_coded_type._build_odxlinks())
+        result.update(self.compu_method._build_odxlinks())
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -93,15 +92,17 @@ class DataObjectProperty(DopBase):
         super()._resolve_odxlinks(odxlinks)
 
         self.diag_coded_type._resolve_odxlinks(odxlinks)
+        self.compu_method._resolve_odxlinks(odxlinks)
 
         self._unit: Optional[Unit] = None
         if self.unit_ref:
             self._unit = odxlinks.resolve(self.unit_ref, Unit)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
-        self.diag_coded_type._resolve_snrefs(diag_layer)
+        self.diag_coded_type._resolve_snrefs(context)
+        self.compu_method._resolve_snrefs(context)
 
     @property
     def unit(self) -> Optional[Unit]:
@@ -110,20 +111,7 @@ class DataObjectProperty(DopBase):
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
 
-    def convert_physical_to_internal(self, physical_value: Any) -> Any:
-        """
-        Convert a physical representation of a parameter to its internal counterpart
-        """
-        odxassert(
-            self.physical_type.base_data_type.isinstance(physical_value),
-            f"Expected {self.physical_type.base_data_type.value}, got {type(physical_value)}")
-
-        return self.compu_method.convert_physical_to_internal(physical_value)
-
-    def convert_physical_to_bytes(self,
-                                  physical_value: Any,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
         """
         Convert a physical representation of a parameter to a string bytes that can be send over the wire
         """
@@ -132,9 +120,11 @@ class DataObjectProperty(DopBase):
                 f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
                 f" is not a valid.")
 
-        internal_val = self.convert_physical_to_internal(physical_value)
-        return self.diag_coded_type.convert_internal_to_bytes(
-            internal_val, encode_state, bit_position=bit_position)
+        if not isinstance(physical_value, (int, float, str, bytes, bytearray)):
+            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)
+        self.diag_coded_type.encode_into_pdu(internal_value, encode_state)
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         """

odxtools/decodestate.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, cast
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, cast
 
 import odxtools.exceptions as exceptions
 
 from .exceptions import DecodeError
-from .odxtypes import AtomicOdxType, DataType
+from .odxtypes import AtomicOdxType, DataType, ParameterValue
 
 try:
     import bitstruct.c as bitstruct
@@ -13,20 +13,9 @@ except ImportError:
     import bitstruct
 
 if TYPE_CHECKING:
+    from .parameters.parameter import Parameter
     from .tablerow import TableRow
 
-# format specifiers for the data type using the bitstruct module
-ODX_TYPE_TO_FORMAT_LETTER = {
-    DataType.A_INT32: "s",
-    DataType.A_UINT32: "u",
-    DataType.A_FLOAT32: "f",
-    DataType.A_FLOAT64: "f",
-    DataType.A_BYTEFIELD: "r",
-    DataType.A_UNICODE2STRING: "r",  # UTF-16 strings must be converted explicitly
-    DataType.A_ASCIISTRING: "r",
-    DataType.A_UTF8STRING: "r",
-}
-
 
 @dataclass
 class DecodeState:
@@ -58,6 +47,11 @@ class DecodeState:
     #: values of the table key parameters decoded so far
     table_keys: Dict[str, "TableRow"] = field(default_factory=dict)
 
+    #: List of parameters that have been decoded so far. The journal
+    #: is used by some types of parameters which depend on the values of
+    #: other parameters; i.e., environment data description parameters
+    journal: List[Tuple["Parameter", Optional[ParameterValue]]] = field(default_factory=list)
+
     def extract_atomic_value(
         self,
         bit_length: int,
@@ -94,7 +88,7 @@ class DecodeState:
 
         padding = (8 - (bit_length + self.cursor_bit_position) % 8) % 8
         internal_value, = bitstruct.unpack_from(
-            f"{ODX_TYPE_TO_FORMAT_LETTER[base_data_type]}{bit_length}",
+            f"{base_data_type.bitstruct_format_letter}{bit_length}",
             extracted_bytes,
             offset=padding)
 

odxtools/description.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment
+
+
+@dataclass
+class Description:
+    text: str
+    external_docs: List[str]
+    text_identifier: Optional[str]
+
+    @staticmethod
+    def from_et(et_element: Optional[ElementTree.Element],
+                doc_frags: List[OdxDocFragment]) -> Optional["Description"]:
+        if et_element is None:
+            return None
+
+        # Extract the contents of the tag as a XHTML string.
+        raw_string = et_element.text or ""
+        for e in et_element:
+            if e.tag == "EXTERNAL-DOCS":
+                break
+            raw_string += ElementTree.tostring(e, encoding="unicode")
+
+        # remove white spaces at the beginning and at the end of all
+        # extracted lines
+        stripped_lines = [x.strip() for x in raw_string.split("\n")]
+
+        text = "\n".join(stripped_lines).strip()
+
+        text_identifier = et_element.get("TI")
+
+        external_docs = \
+            [
+                odxrequire(ed.get("HREF")) for ed in et_element.iterfind("EXTERNAL-DOCS/EXTERNAL-DOC")
+            ]
+        return Description(text=text, text_identifier=text_identifier, external_docs=external_docs)
+
+    @staticmethod
+    def from_string(text: str) -> "Description":
+        return Description(text=text, external_docs=[], text_identifier=None)
+
+    def __str__(self) -> str:
+        return self.text

odxtools/determinenumberofitems.py

@@ -1,13 +1,12 @@
+# SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .dataobjectproperty import DataObjectProperty
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -39,7 +38,7 @@ class DetermineNumberOfItems:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop = odxlinks.resolve(self.dop_ref, DataObjectProperty)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/diagcodedtype.py

@@ -1,21 +1,14 @@
 # SPDX-License-Identifier: MIT
-import abc
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union, cast
+from typing import Any, Dict, List, Literal, Optional, Union, cast
+from xml.etree import ElementTree
 
-from .decodestate import ODX_TYPE_TO_FORMAT_LETTER, DecodeState
+from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import EncodeError, odxassert, odxraise
-from .odxlink import OdxLinkDatabase, OdxLinkId
-from .odxtypes import AtomicOdxType, DataType
-
-try:
-    import bitstruct.c as bitstruct
-except ImportError:
-    import bitstruct
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .exceptions import odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import AtomicOdxType, DataType, odxstr_to_bool
+from .snrefcontext import SnRefContext
 
 # Allowed diag-coded types
 DctType = Literal[
@@ -27,12 +20,30 @@ DctType = Literal[
 
 
 @dataclass
-class DiagCodedType(abc.ABC):
+class DiagCodedType:
 
     base_data_type: DataType
     base_type_encoding: Optional[str]
     is_highlow_byte_order_raw: Optional[bool]
 
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DiagCodedType":
+        base_data_type_str = odxrequire(et_element.get("BASE-DATA-TYPE"))
+        try:
+            base_data_type = DataType(base_data_type_str)
+        except ValueError:
+            odxraise(f"Unknown base data type {base_data_type_str}")
+            base_data_type = cast(DataType, None)
+
+        base_type_encoding = et_element.get("BASE-TYPE-ENCODING")
+        is_highlow_byte_order_raw = odxstr_to_bool(et_element.get("IS-HIGHLOW-BYTE-ORDER"))
+
+        return DiagCodedType(
+            base_data_type=base_data_type,
+            base_type_encoding=base_type_encoding,
+            is_highlow_byte_order_raw=is_highlow_byte_order_raw)
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:  # noqa: B027
         return {}
 
@@ -40,7 +51,7 @@ class DiagCodedType(abc.ABC):
         """Recursively resolve any odxlinks references"""
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:  # noqa: B027
+    def _resolve_snrefs(self, context: SnRefContext) -> None:  # noqa: B027
         """Recursively resolve any short-name references"""
         pass
 
@@ -48,96 +59,15 @@ class DiagCodedType(abc.ABC):
         return None
 
     @property
-    @abc.abstractmethod
     def dct_type(self) -> DctType:
-        pass
+        odxraise(f"Class {type(self).__name__} does not override required method "
+                 f"dct_type()", NotImplementedError)
+        return cast(DctType, None)
 
     @property
     def is_highlow_byte_order(self) -> bool:
         return self.is_highlow_byte_order_raw in [None, True]
 
-    @staticmethod
-    def _encode_internal_value(
-        internal_value: AtomicOdxType,
-        bit_position: int,
-        bit_length: int,
-        base_data_type: DataType,
-        is_highlow_byte_order: bool,
-    ) -> bytes:
-        """Convert the internal_value to bytes."""
-        # Check that bytes and strings actually fit into the bit length
-        if base_data_type == DataType.A_BYTEFIELD:
-            if isinstance(internal_value, bytearray):
-                internal_value = bytes(internal_value)
-            if not isinstance(internal_value, bytes):
-                odxraise()
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The bytefield {internal_value.hex()} is too large "
-                                  f"({len(internal_value)} bytes)."
-                                  f" The maximum length is {bit_length//8}.")
-        if base_data_type == DataType.A_ASCIISTRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            # The spec says ASCII, meaning only byte values 0-127.
-            # But in practice, vendors use iso-8859-1, aka latin-1
-            # reason being iso-8859-1 never fails since it has a valid
-            # character mapping for every possible byte sequence.
-            internal_value = internal_value.encode("iso-8859-1")
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of characters is {bit_length//8}.")
-        elif base_data_type == DataType.A_UTF8STRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            internal_value = internal_value.encode("utf-8")
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of bytes is {bit_length//8}.")
-
-        elif base_data_type == DataType.A_UNICODE2STRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            text_encoding = "utf-16-be" if is_highlow_byte_order else "utf-16-le"
-            internal_value = internal_value.encode(text_encoding)
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of characters is {bit_length//16}.")
-
-        # If the bit length is zero, return empty bytes
-        if bit_length == 0:
-            if (base_data_type.value in [
-                    DataType.A_INT32, DataType.A_UINT32, DataType.A_FLOAT32, DataType.A_FLOAT64
-            ] and base_data_type.value != 0):
-                raise EncodeError(
-                    f"The number {repr(internal_value)} cannot be encoded into {bit_length} bits.")
-            return b''
-
-        char = ODX_TYPE_TO_FORMAT_LETTER[base_data_type]
-        padding = (8 - ((bit_length + bit_position) % 8)) % 8
-        odxassert((0 <= padding and padding < 8 and (padding + bit_length + bit_position) % 8 == 0),
-                  f"Incorrect padding {padding}")
-        left_pad = f"p{padding}" if padding > 0 else ""
-
-        # actually encode the value
-        coded = bitstruct.pack(f"{left_pad}{char}{bit_length}", internal_value)
-
-        # apply byte order for numeric objects
-        if not is_highlow_byte_order and base_data_type in [
-                DataType.A_INT32,
-                DataType.A_UINT32,
-                DataType.A_FLOAT32,
-                DataType.A_FLOAT64,
-        ]:
-            coded = coded[::-1]
-
-        return cast(bytes, coded)
-
     def _minimal_byte_length_of(self, internal_value: Union[bytes, str]) -> int:
         """Helper method to get the minimal byte length.
         (needed for LeadingLength- and MinMaxLengthType)
@@ -160,11 +90,10 @@ class DiagCodedType(abc.ABC):
             odxassert(
                 byte_length % 2 == 0, f"The bit length of A_UNICODE2STRING must"
                 f" be a multiple of 16 but is {8*byte_length}")
+
         return byte_length
 
-    @abc.abstractmethod
-    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
         """Encode the internal value.
 
         Parameters
@@ -177,9 +106,9 @@ class DiagCodedType(abc.ABC):
             mapping from ID (of the length key) to bit length
             (only needed for ParamLengthInfoType)
         """
-        pass
+        raise NotImplementedError(
+            f".encode_into_pdu() is not implemented by the class {type(self).__name__}")
 
-    @abc.abstractmethod
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         """Decode the parameter value from the coded message.
 
@@ -195,4 +124,5 @@ class DiagCodedType(abc.ABC):
         int
             the next byte position after the extracted parameter
         """
-        pass
+        raise NotImplementedError(
+            f".decode_from_pdu() is not implemented by the class {type(self).__name__}")

odxtools/diagcomm.py

@@ -6,20 +6,20 @@ from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .audience import Audience
-from .createsdgs import create_sdgs_from_et
 from .element import IdentifiableElement
 from .exceptions import 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 .odxtypes import odxstr_to_bool
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .state import State
 from .statetransition import StateTransition
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+    from .diaglayers.protocol import Protocol
 
 
 class DiagClassType(Enum):
@@ -76,7 +76,9 @@ class DiagComm(IdentifiableElement):
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         functional_class_refs = [
             odxrequire(OdxLinkRef.from_et(el, doc_frags))
@@ -141,7 +143,7 @@ class DiagComm(IdentifiableElement):
         return self._functional_classes
 
     @property
-    def protocols(self) -> NamedItemList["DiagLayer"]:
+    def protocols(self) -> NamedItemList["Protocol"]:
         return self._protocols
 
     @property
@@ -201,15 +203,25 @@ class DiagComm(IdentifiableElement):
         self._state_transitions = NamedItemList(
             [odxlinks.resolve(stt_ref, StateTransition) for stt_ref in self.state_transition_refs])
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.admin_data:
-            self.admin_data._resolve_snrefs(diag_layer)
+            self.admin_data._resolve_snrefs(context)
 
         if self.audience:
-            self.audience._resolve_snrefs(diag_layer)
+            self.audience._resolve_snrefs(context)
 
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
-
-        self._protocols = NamedItemList(
-            [diag_layer.protocols[prot_snref] for prot_snref in self.protocol_snrefs])
+            sdg._resolve_snrefs(context)
+
+        if TYPE_CHECKING:
+            diag_layer = odxrequire(context.diag_layer)
+            self._protocols = NamedItemList([
+                resolve_snref(prot_snref, getattr(diag_layer, "protocols", []), Protocol)
+                for prot_snref in self.protocol_snrefs
+            ])
+        else:
+            diag_layer = odxrequire(context.diag_layer)
+            self._protocols = NamedItemList([
+                resolve_snref(prot_snref, getattr(diag_layer, "protocols", []))
+                for prot_snref in self.protocol_snrefs
+            ])

odxtools/diagdatadictionaryspec.py

@@ -1,15 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .basicstructure import BasicStructure
-from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .dopbase import DopBase
 from .dtcdop import DtcDop
+from .dynamicendmarkerfield import DynamicEndmarkerField
 from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
 from .environmentdata import EnvironmentData
@@ -18,15 +18,13 @@ from .exceptions import odxraise
 from .multiplexer import Multiplexer
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .staticfield import StaticField
 from .structure import Structure
 from .table import Table
 from .unitspec import UnitSpec
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DiagDataDictionarySpec:
@@ -37,7 +35,7 @@ class DiagDataDictionarySpec:
     structures: NamedItemList[BasicStructure]
     static_fields: NamedItemList[StaticField]
     dynamic_length_fields: NamedItemList[DynamicLengthField]
-    #dynamic_endmarker_fields: NamedItemList[DynamicEndmarkerField]
+    dynamic_endmarker_fields: NamedItemList[DynamicEndmarkerField]
     end_of_pdu_fields: NamedItemList[EndOfPduField]
     muxs: NamedItemList[Multiplexer]
     env_datas: NamedItemList[EnvironmentData]
@@ -54,7 +52,7 @@ class DiagDataDictionarySpec:
                 self.structures,
                 self.static_fields,
                 self.dynamic_length_fields,
-                #self.dynamic_endmarker_fields,
+                self.dynamic_endmarker_fields,
                 self.end_of_pdu_fields,
                 self.muxs,
                 self.env_datas,
@@ -99,11 +97,10 @@ class DiagDataDictionarySpec:
             for dl_element in et_element.iterfind("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD")
         ]
 
-        # TODO: dynamic endmarker fields
-        #dynamic_endmarker_fields = [
-        #    DynamicEndmarkerField.from_et(dl_element, doc_frags)
-        #    for dl_element in et_element.iterfind("DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD")
-        #]
+        dynamic_endmarker_fields = [
+            DynamicEndmarkerField.from_et(dl_element, doc_frags) for dl_element in
+            et_element.iterfind("DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD")
+        ]
 
         end_of_pdu_fields = [
             EndOfPduField.from_et(eofp_element, doc_frags)
@@ -135,7 +132,9 @@ class DiagDataDictionarySpec:
             for table_element in et_element.iterfind("TABLES/TABLE")
         ]
 
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         return DiagDataDictionarySpec(
             admin_data=admin_data,
@@ -145,7 +144,7 @@ class DiagDataDictionarySpec:
             structures=NamedItemList(structures),
             static_fields=NamedItemList(static_fields),
             dynamic_length_fields=NamedItemList(dynamic_length_fields),
-            #dynamic_endmarker_fields=NamedItemList(dynamic_endmarker_fields),
+            dynamic_endmarker_fields=NamedItemList(dynamic_endmarker_fields),
             end_of_pdu_fields=NamedItemList(end_of_pdu_fields),
             muxs=NamedItemList(muxs),
             env_datas=NamedItemList(env_datas),
@@ -172,8 +171,8 @@ class DiagDataDictionarySpec:
             odxlinks.update(static_field._build_odxlinks())
         for dynamic_length_field in self.dynamic_length_fields:
             odxlinks.update(dynamic_length_field._build_odxlinks())
-        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
-        #    odxlinks.update(dynamic_endmarker_field._build_odxlinks())
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            odxlinks.update(dynamic_endmarker_field._build_odxlinks())
         for end_of_pdu_field in self.end_of_pdu_fields:
             odxlinks.update(end_of_pdu_field._build_odxlinks())
         for mux in self.muxs:
@@ -204,8 +203,8 @@ class DiagDataDictionarySpec:
             static_field._resolve_odxlinks(odxlinks)
         for dynamic_length_field in self.dynamic_length_fields:
             dynamic_length_field._resolve_odxlinks(odxlinks)
-        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
-        #    dynamic_endmarker_field._resolve_odxlinks(odxlinks)
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            dynamic_endmarker_field._resolve_odxlinks(odxlinks)
         for end_of_pdu_field in self.end_of_pdu_fields:
             end_of_pdu_field._resolve_odxlinks(odxlinks)
         for mux in self.muxs:
@@ -219,35 +218,35 @@ class DiagDataDictionarySpec:
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.admin_data is not None:
-            self.admin_data._resolve_snrefs(diag_layer)
+            self.admin_data._resolve_snrefs(context)
         for dtc_dop in self.dtc_dops:
-            dtc_dop._resolve_snrefs(diag_layer)
+            dtc_dop._resolve_snrefs(context)
         for env_data_desc in self.env_data_descs:
-            env_data_desc._resolve_snrefs(diag_layer)
+            env_data_desc._resolve_snrefs(context)
         for data_object_prop in self.data_object_props:
-            data_object_prop._resolve_snrefs(diag_layer)
+            data_object_prop._resolve_snrefs(context)
         for structure in self.structures:
-            structure._resolve_snrefs(diag_layer)
+            structure._resolve_snrefs(context)
         for static_field in self.static_fields:
-            static_field._resolve_snrefs(diag_layer)
+            static_field._resolve_snrefs(context)
         for dynamic_length_field in self.dynamic_length_fields:
-            dynamic_length_field._resolve_snrefs(diag_layer)
-        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
-        #    dynamic_endmarker_field._resolve_snrefs(diag_layer)
+            dynamic_length_field._resolve_snrefs(context)
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            dynamic_endmarker_field._resolve_snrefs(context)
         for end_of_pdu_field in self.end_of_pdu_fields:
-            end_of_pdu_field._resolve_snrefs(diag_layer)
+            end_of_pdu_field._resolve_snrefs(context)
         for mux in self.muxs:
-            mux._resolve_snrefs(diag_layer)
+            mux._resolve_snrefs(context)
         for env_data in self.env_datas:
-            env_data._resolve_snrefs(diag_layer)
+            env_data._resolve_snrefs(context)
         if self.unit_spec is not None:
-            self.unit_spec._resolve_snrefs(diag_layer)
+            self.unit_spec._resolve_snrefs(context)
         for table in self.tables:
-            table._resolve_snrefs(diag_layer)
+            table._resolve_snrefs(context)
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
 
     @property
     def all_data_object_properties(self) -> NamedItemList[DopBase]: