odxtools 5.3.1__py3-none-any.whl → 6.0.1__py3-none-any.whl

odxtools/dataobjectproperty.py

@@ -15,9 +15,8 @@ from .element import IdentifiableElement
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .odxtypes import odxstr_to_bool
+from .odxtypes import AtomicOdxType, ParameterValue, odxstr_to_bool
 from .physicaltype import PhysicalType
-from .standardlengthtype import StandardLengthType
 from .unit import Unit
 from .utils import dataclass_fields_asdict
 
@@ -65,7 +64,7 @@ class DataObjectProperty(DopBase):
                 sdgs=sdgs,
                 **kwargs)
         else:
-            dtclist: List[Union[DiagnosticTroubleCode, OdxLinkRef]] = list()
+            dtclist: List[Union[DiagnosticTroubleCode, OdxLinkRef]] = []
             if (dtcs_elem := et_element.find("DTCS")) is not None:
                 for dtc_proxy_elem in dtcs_elem:
                     if dtc_proxy_elem.tag == "DTC":
@@ -100,7 +99,7 @@ class DataObjectProperty(DopBase):
         result.update(self.diag_coded_type._build_odxlinks())
         return result
 
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase):
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         """Resolves the reference to the unit"""
         super()._resolve_odxlinks(odxlinks)
 
@@ -119,14 +118,8 @@ class DataObjectProperty(DopBase):
     def unit(self) -> Optional[Unit]:
         return self._unit
 
-    @property
-    def bit_length(self):
-        # TODO: The DiagCodedTypes except StandardLengthType don't have a bit length.
-        #       Should we remove this bit_length property from DOP or return None?
-        if isinstance(self.diag_coded_type, StandardLengthType):
-            return self.diag_coded_type.bit_length
-        else:
-            return None
+    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:
         """
@@ -145,10 +138,7 @@ class DataObjectProperty(DopBase):
         """
         if not self.is_valid_physical_value(physical_value):
             raise EncodeError(f"The value {repr(physical_value)} of type {type(physical_value)}"
-                              f" is not a valid." +
-                              (f" Valid values are {self.compu_method.get_valid_physical_values()}"
-                               if self.compu_method.get_valid_physical_values(
-                               ) else f" Expected type {self.physical_type.base_data_type.value}."))
+                              f" is not a valid.")
 
         internal_val = self.convert_physical_to_internal(physical_value)
         return self.diag_coded_type.convert_internal_to_bytes(
@@ -164,19 +154,16 @@ class DataObjectProperty(DopBase):
         """
         odxassert(0 <= bit_position and bit_position < 8)
 
-        internal, next_byte_position = self.diag_coded_type.convert_bytes_to_internal(
+        internal, cursor_position = self.diag_coded_type.convert_bytes_to_internal(
             decode_state, bit_position=bit_position)
 
         if self.compu_method.is_valid_internal_value(internal):
-            return self.compu_method.convert_internal_to_physical(internal), next_byte_position
+            return self.compu_method.convert_internal_to_physical(internal), cursor_position
         else:
             # TODO: How to prevent this?
             raise DecodeError(
                 f"DOP {self.short_name} could not convert the coded value "
                 f" {repr(internal)} to physical type {self.physical_type.base_data_type}.")
 
-    def is_valid_physical_value(self, physical_value):
-        return self.compu_method.is_valid_physical_value(physical_value)
-
-    def get_valid_physical_values(self):
-        return self.compu_method.get_valid_physical_values()
+    def is_valid_physical_value(self, physical_value: ParameterValue) -> bool:
+        return self.compu_method.is_valid_physical_value(cast(AtomicOdxType, physical_value))

odxtools/decodestate.py

@@ -15,4 +15,4 @@ class DecodeState:
     parameter_values: ParameterValueDict
 
     #: Position of the next parameter if its position is not specified in ODX
-    next_byte_position: int
+    cursor_position: int

odxtools/determinenumberofitems.py

@@ -1,18 +1,47 @@
 from dataclasses import dataclass
-from typing import List
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .odxlink import OdxDocFragment
-from .positioneddataobjectproperty import PositionedDataObjectProperty
-from .utils import dataclass_fields_asdict
+from .dataobjectproperty import DataObjectProperty
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+
+if TYPE_CHECKING:
+    from ..diaglayer import DiagLayer
 
 
 @dataclass
-class DetermineNumberOfItems(PositionedDataObjectProperty):
+class DetermineNumberOfItems:
+    """
+    The object that determines the number of items of dynamic fields
+    """
+    byte_position: int
+    bit_position: Optional[int]
+    dop_ref: OdxLinkRef
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DetermineNumberOfItems":
-        kwargs = dataclass_fields_asdict(
-            PositionedDataObjectProperty.from_et(et_element, doc_frags))
-        return DetermineNumberOfItems(**kwargs)
+        byte_position = int(odxrequire(et_element.findtext("BYTE-POSITION")))
+        bit_position_str = et_element.findtext("BIT-POSITION")
+        bit_position = int(bit_position_str) if bit_position_str is not None else None
+        dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), doc_frags))
+
+        return DetermineNumberOfItems(
+            byte_position=byte_position,
+            bit_position=bit_position,
+            dop_ref=dop_ref,
+        )
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._dop = odxlinks.resolve(self.dop_ref, DataObjectProperty)
+
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        pass
+
+    @property
+    def dop(self) -> DataObjectProperty:
+        return self._dop

odxtools/diagcodedtype.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import abc
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Literal, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Tuple, Union
 
 import bitstruct
 
@@ -9,12 +9,13 @@ from . import exceptions
 from .decodestate import DecodeState
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise
-from .odxlink import OdxLinkDatabase
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, DataType
 
 if TYPE_CHECKING:
     from .diaglayer import DiagLayer
 
+# format specifiers for the data type using the bitstruct module
 ODX_TYPE_TO_FORMAT_LETTER = {
     DataType.A_INT32: "s",
     DataType.A_UINT32: "u",
@@ -26,6 +27,7 @@ ODX_TYPE_TO_FORMAT_LETTER = {
     DataType.A_UTF8STRING: "t",
 }
 
+# Allowed diag-coded types
 DctType = Literal[
     "LEADING-LENGTH-INFO-TYPE",
     "MIN-MAX-LENGTH-TYPE",
@@ -41,17 +43,20 @@ class DiagCodedType(abc.ABC):
     base_type_encoding: Optional[str]
     is_highlow_byte_order_raw: Optional[bool]
 
-    def _build_odxlinks(self):
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:  # noqa: B027
         return {}
 
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:  # noqa: B027
         """Recursively resolve any odxlinks references"""
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:  # noqa: B027
         """Recursively resolve any short-name references"""
         pass
 
+    def get_static_bit_length(self) -> Optional[int]:
+        return None
+
     @property
     @abc.abstractmethod
     def dct_type(self) -> DctType:
@@ -81,8 +86,8 @@ class DiagCodedType(abc.ABC):
         byte_length = (bit_length + bit_position + 7) // 8
         if byte_position + byte_length > len(coded_message):
             raise DecodeError(f"Expected a longer message.")
-        next_byte_position = byte_position + byte_length
-        extracted_bytes = coded_message[byte_position:next_byte_position]
+        cursor_position = byte_position + byte_length
+        extracted_bytes = coded_message[byte_position:cursor_position]
 
         # Apply byteorder
         if not is_highlow_byte_order and base_data_type not in [
@@ -120,7 +125,7 @@ class DiagCodedType(abc.ABC):
             else:
                 internal_value = internal_value.decode("utf-16-le")
 
-        return internal_value, next_byte_position
+        return internal_value, cursor_position
 
     def _to_bytes(
         self,
@@ -159,7 +164,7 @@ class DiagCodedType(abc.ABC):
             ] and base_data_type != 0):
                 raise EncodeError(
                     f"The number {repr(internal_value)} cannot be encoded into {bit_length} bits.")
-            return bytes()
+            return b''
 
         char = ODX_TYPE_TO_FORMAT_LETTER[base_data_type]
 

odxtools/diagdatadictionaryspec.py

@@ -40,17 +40,6 @@ class DiagDataDictionarySpec:
     unit_spec: Optional[UnitSpec]
     sdgs: List[SpecialDataGroup]
 
-    def __post_init__(self):
-        self._all_data_object_properties = NamedItemList(
-            chain(
-                self.data_object_props,
-                self.structures,
-                self.end_of_pdu_fields,
-                self.dynamic_length_fields,
-                self.dtc_dops,
-                self.tables,
-            ),)
-
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagDataDictionarySpec":
@@ -145,19 +134,26 @@ class DiagDataDictionarySpec:
         # note that DataDictionarySpec objects do not exhibit an ODXLINK id.
         odxlinks = {}
 
-        for obj in chain(
-                self.data_object_props,
-                self.dtc_dops,
-                self.env_data_descs,
-                self.env_datas,
-                self.muxs,
-                self.sdgs,
-                self.structures,
-                self.end_of_pdu_fields,
-                self.dynamic_length_fields,
-                self.tables,
-        ):
-            odxlinks.update(obj._build_odxlinks())
+        for data_object_prop in self.data_object_props:
+            odxlinks.update(data_object_prop._build_odxlinks())
+        for dtc_dop in self.dtc_dops:
+            odxlinks.update(dtc_dop._build_odxlinks())
+        for env_data_desc in self.env_data_descs:
+            odxlinks.update(env_data_desc._build_odxlinks())
+        for env_data in self.env_datas:
+            odxlinks.update(env_data._build_odxlinks())
+        for mux in self.muxs:
+            odxlinks.update(mux._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
+        for structure in self.structures:
+            odxlinks.update(structure._build_odxlinks())
+        for dynamic_length_field in self.dynamic_length_fields:
+            odxlinks.update(dynamic_length_field._build_odxlinks())
+        for end_of_pdu_field in self.end_of_pdu_fields:
+            odxlinks.update(end_of_pdu_field._build_odxlinks())
+        for table in self.tables:
+            odxlinks.update(table._build_odxlinks())
 
         if self.unit_spec is not None:
             odxlinks.update(self.unit_spec._build_odxlinks())
@@ -165,24 +161,51 @@ class DiagDataDictionarySpec:
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-
-        for obj in chain(self.data_object_props, self.dtc_dops, self.end_of_pdu_fields,
-                         self.dynamic_length_fields, self.env_data_descs, self.env_datas, self.muxs,
-                         self.sdgs, self.structures, self.tables):
-            obj._resolve_odxlinks(odxlinks)
+        for data_object_prop in self.data_object_props:
+            data_object_prop._resolve_odxlinks(odxlinks)
+        for dtc_dop in self.dtc_dops:
+            dtc_dop._resolve_odxlinks(odxlinks)
+        for dynamic_length_field in self.dynamic_length_fields:
+            dynamic_length_field._resolve_odxlinks(odxlinks)
+        for end_of_pdu_field in self.end_of_pdu_fields:
+            end_of_pdu_field._resolve_odxlinks(odxlinks)
+        for env_data_desc in self.env_data_descs:
+            env_data_desc._resolve_odxlinks(odxlinks)
+        for env_data in self.env_datas:
+            env_data._resolve_odxlinks(odxlinks)
+        for mux in self.muxs:
+            mux._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+        for structure in self.structures:
+            structure._resolve_odxlinks(odxlinks)
+        for table in self.tables:
+            table._resolve_odxlinks(odxlinks)
 
         if self.unit_spec is not None:
             self.unit_spec._resolve_odxlinks(odxlinks)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        for obj in chain(self.data_object_props, self.dtc_dops, self.end_of_pdu_fields,
-                         self.dynamic_length_fields, self.env_data_descs, self.env_datas, self.muxs,
-                         self.sdgs, self.structures, self.tables):
-            obj._resolve_snrefs(diag_layer)
+        for data_object_prop in self.data_object_props:
+            data_object_prop._resolve_snrefs(diag_layer)
+        for dtc_dop in self.dtc_dops:
+            dtc_dop._resolve_snrefs(diag_layer)
+        for dynamic_length_field in self.dynamic_length_fields:
+            dynamic_length_field._resolve_snrefs(diag_layer)
+        for end_of_pdu_field in self.end_of_pdu_fields:
+            end_of_pdu_field._resolve_snrefs(diag_layer)
+        for env_data_desc in self.env_data_descs:
+            env_data_desc._resolve_snrefs(diag_layer)
+        for env_data in self.env_datas:
+            env_data._resolve_snrefs(diag_layer)
+        for mux in self.muxs:
+            mux._resolve_snrefs(diag_layer)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(diag_layer)
+        for structure in self.structures:
+            structure._resolve_snrefs(diag_layer)
+        for table in self.tables:
+            table._resolve_snrefs(diag_layer)
 
         if self.unit_spec is not None:
             self.unit_spec._resolve_snrefs(diag_layer)
-
-    @property
-    def all_data_object_properties(self):
-        return self._all_data_object_properties

odxtools/diaglayer.py

@@ -208,7 +208,8 @@ class DiagLayer:
         # scheme, cf the docstring of
         # _compute_available_commmunication_parameters().
         #####
-        self._communication_parameters = self._compute_available_commmunication_parameters()
+        self._communication_parameters = NamedItemList(
+            self._compute_available_commmunication_parameters())
 
         #####
         # resolve all SNREFs. TODO: We allow SNREFS to objects that
@@ -349,7 +350,7 @@ class DiagLayer:
     #####
     # <value inheritance mechanism helpers>
     #####
-    def _get_parent_refs_sorted_by_priority(self, reverse=False) -> Iterable[ParentRef]:
+    def _get_parent_refs_sorted_by_priority(self, reverse: bool = False) -> Iterable[ParentRef]:
         return sorted(
             self.diag_layer_raw.parent_refs,
             key=lambda pr: pr.layer.variant_type.inheritance_priority,
@@ -443,10 +444,10 @@ class DiagLayer:
     def _compute_available_diag_comms(self, odxlinks: OdxLinkDatabase
                                      ) -> Iterable[Union[DiagService, SingleEcuJob]]:
 
-        def get_local_objects_fn(dl):
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[Union[DiagService, SingleEcuJob]]:
             return dl._get_local_diag_comms(odxlinks)
 
-        def not_inherited_fn(parent_ref):
+        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
             return parent_ref.not_inherited_diag_comms
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
@@ -454,10 +455,10 @@ class DiagLayer:
     def _compute_available_global_neg_responses(self, odxlinks: OdxLinkDatabase) \
             -> Iterable[Response]:
 
-        def get_local_objects_fn(dl):
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[Response]:
             return dl.diag_layer_raw.global_negative_responses
 
-        def not_inherited_fn(parent_ref):
+        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
             return parent_ref.not_inherited_global_neg_responses
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
@@ -468,7 +469,7 @@ class DiagLayer:
         exclude: Callable[["ParentRef"], List[str]],
     ) -> NamedItemList[TNamed]:
 
-        def get_local_objects_fn(dl: "DiagLayer"):
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[TNamed]:
             if dl.diag_layer_raw.diag_data_dictionary_spec is None:
                 return []
             return include(dl.diag_layer_raw.diag_data_dictionary_spec)
@@ -478,40 +479,40 @@ class DiagLayer:
 
     def _compute_available_functional_classes(self) -> Iterable[FunctionalClass]:
 
-        def get_local_objects_fn(dl):
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[FunctionalClass]:
             return dl.diag_layer_raw.functional_classes
 
-        def not_inherited_fn(parent_ref):
+        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
             return []
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
 
     def _compute_available_additional_audiences(self) -> Iterable[AdditionalAudience]:
 
-        def get_local_objects_fn(dl):
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[AdditionalAudience]:
             return dl.diag_layer_raw.additional_audiences
 
-        def not_inherited_fn(parent_ref):
+        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
             return []
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
 
     def _compute_available_state_charts(self) -> Iterable[StateChart]:
 
-        def get_local_objects_fn(dl):
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[StateChart]:
             return dl.diag_layer_raw.state_charts
 
-        def not_inherited_fn(parent_ref):
+        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
             return []
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
 
     def _compute_available_unit_groups(self) -> Iterable[UnitGroup]:
 
-        def get_local_objects_fn(dl):
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[UnitGroup]:
             return dl._get_local_unit_groups()
 
-        def not_inherited_fn(parent_ref):
+        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
             return []
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
@@ -547,7 +548,7 @@ class DiagLayer:
         without a specified protocol are taken as fallbacks...
 
         """
-        com_params_dict: Dict[Tuple[str, Optional[str]], CommunicationParameterRef] = dict()
+        com_params_dict: Dict[Tuple[str, Optional[str]], CommunicationParameterRef] = {}
 
         # Look in parent refs for inherited communication
         # parameters. First fetch the communication parameters from
@@ -563,7 +564,7 @@ class DiagLayer:
         return list(com_params_dict.values())
 
     @property
-    def communication_parameters(self) -> List[CommunicationParameterRef]:
+    def communication_parameters(self) -> NamedItemList[CommunicationParameterRef]:
         """All communication parameters applicable to this DiagLayer
 
         Note that, although communication parameters use inheritance,
@@ -579,7 +580,7 @@ class DiagLayer:
         Note that protocols are *not* explicitly inherited objects,
         but the parent diagnostic layers of variant type "PROTOCOL".
         """
-        result_dict: Dict[str, DiagLayer] = dict()
+        result_dict: Dict[str, DiagLayer] = {}
 
         for parent_ref in self._get_parent_refs_sorted_by_priority():
             for prot in parent_ref.layer.protocols:
@@ -613,6 +614,7 @@ class DiagLayer:
                 f"Communication parameter `{cp_short_name}` specified more "
                 f"than once. Using first occurence.",
                 OdxWarning,
+                stacklevel=1,
             )
         elif len(cps) == 0:
             return None
@@ -897,7 +899,9 @@ class DiagLayer:
             # global negative responses. (I.e., one for each
             # service. This can be avoided by specifying the
             # corresponding request for `decode_response()`.)
-            request_prefix = s.request.coded_const_prefix()
+            request_prefix = b''
+            if s.request is not None:
+                request_prefix = s.request.coded_const_prefix()
             prefixes = [request_prefix]
             prefixes += [
                 x.coded_const_prefix(request_prefix=request_prefix) for x in chain(
@@ -954,11 +958,16 @@ class DiagLayer:
                 for gnr in self.global_negative_responses:
                     try:
                         decoded_gnr = gnr.decode(message)
+                        if not isinstance(decoded_gnr, dict):
+                            raise DecodeError(f"Expected the decoded value of a global "
+                                              f"negative response to be a dictionary, "
+                                              f"got {type(decoded_gnr)} for {self.short_name}")
+
                         decoded_messages.append(
                             Message(
                                 coded_message=message,
                                 service=service,
-                                structure=gnr,
+                                coding_object=gnr,
                                 param_dict=decoded_gnr))
                     except DecodeError:
                         pass
@@ -974,7 +983,7 @@ class DiagLayer:
 
         return self._decode(message, candidate_services)
 
-    def decode_response(self, response: bytes, request: Union[bytes, Message]) -> Iterable[Message]:
+    def decode_response(self, response: bytes, request: Union[bytes, Message]) -> List[Message]:
         if isinstance(request, Message):
             candidate_services = [request.service]
         else:

odxtools/diaglayercontainer.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -12,7 +12,7 @@ from .diaglayer import DiagLayer
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
@@ -82,62 +82,62 @@ class DiagLayerContainer(IdentifiableElement):
             sdgs=sdgs,
             **kwargs)
 
-    def _build_odxlinks(self):
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         if self.admin_data is not None:
             result.update(self.admin_data._build_odxlinks())
-
-        if self.company_datas is not None:
-            for cd in self.company_datas:
-                result.update(cd._build_odxlinks())
-
-        for dl in chain(
-                self.ecu_shared_datas,
-                self.protocols,
-                self.functional_groups,
-                self.base_variants,
-                self.ecu_variants,
-        ):
-            result.update(dl._build_odxlinks())
-
+        for cd in self.company_datas:
+            result.update(cd._build_odxlinks())
         for sdg in self.sdgs:
             result.update(sdg._build_odxlinks())
 
+        for ecu_shared_data in self.ecu_shared_datas:
+            result.update(ecu_shared_data._build_odxlinks())
+        for protocol in self.protocols:
+            result.update(protocol._build_odxlinks())
+        for functional_group in self.functional_groups:
+            result.update(functional_group._build_odxlinks())
+        for base_variant in self.base_variants:
+            result.update(base_variant._build_odxlinks())
+        for ecu_variant in self.ecu_variants:
+            result.update(ecu_variant._build_odxlinks())
+
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         if self.admin_data is not None:
             self.admin_data._resolve_odxlinks(odxlinks)
-
-        if self.company_datas is not None:
-            for cd in self.company_datas:
-                cd._resolve_odxlinks(odxlinks)
-
-        for dl in chain(
-                self.ecu_shared_datas,
-                self.protocols,
-                self.functional_groups,
-                self.base_variants,
-                self.ecu_variants,
-        ):
-            dl._resolve_odxlinks(odxlinks)
-
+        for cd in self.company_datas:
+            cd._resolve_odxlinks(odxlinks)
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
+        for ecu_shared_data in self.ecu_shared_datas:
+            ecu_shared_data._resolve_odxlinks(odxlinks)
+        for protocol in self.protocols:
+            protocol._resolve_odxlinks(odxlinks)
+        for functional_group in self.functional_groups:
+            functional_group._resolve_odxlinks(odxlinks)
+        for base_variant in self.base_variants:
+            base_variant._resolve_odxlinks(odxlinks)
+        for ecu_variant in self.ecu_variants:
+            ecu_variant._resolve_odxlinks(odxlinks)
+
     def _finalize_init(self, odxlinks: OdxLinkDatabase) -> None:
-        for dl in chain(
-                self.ecu_shared_datas,
-                self.protocols,
-                self.functional_groups,
-                self.base_variants,
-                self.ecu_variants,
-        ):
-            dl._finalize_init(odxlinks)
+        for ecu_shared_data in self.ecu_shared_datas:
+            ecu_shared_data._finalize_init(odxlinks)
+        for protocol in self.protocols:
+            protocol._finalize_init(odxlinks)
+        for functional_group in self.functional_groups:
+            functional_group._finalize_init(odxlinks)
+        for base_variant in self.base_variants:
+            base_variant._finalize_init(odxlinks)
+        for ecu_variant in self.ecu_variants:
+            ecu_variant._finalize_init(odxlinks)
 
     @property
-    def diag_layers(self):
+    def diag_layers(self) -> NamedItemList[DiagLayer]:
         return self._diag_layers
 
     def __getitem__(self, key: Union[int, str]) -> DiagLayer: