odxtools 9.6.1__py3-none-any.whl → 10.0.0__py3-none-any.whl

odxtools/dataobjectproperty.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from .compumethods.compumethod import CompuMethod
@@ -37,20 +37,20 @@ class DataObjectProperty(DopBase):
     #: The type of the value in the physical world
     physical_type: PhysicalType
 
-    internal_constr: Optional[InternalConstr]
+    internal_constr: InternalConstr | None
 
     #: The unit associated with physical values (e.g. 'm/s^2')
-    unit_ref: Optional[OdxLinkRef]
+    unit_ref: OdxLinkRef | None
 
-    physical_constr: Optional[InternalConstr]
+    physical_constr: InternalConstr | None
 
     @property
-    def unit(self) -> Optional[Unit]:
+    def unit(self) -> Unit | None:
         return self._unit
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DataObjectProperty":
+                doc_frags: list[OdxDocFragment]) -> "DataObjectProperty":
         """Reads a DATA-OBJECT-PROP."""
         kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, doc_frags))
 
@@ -83,7 +83,7 @@ class DataObjectProperty(DopBase):
             physical_constr=physical_constr,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
         result.update(self.compu_method._build_odxlinks())
         result.update(self.diag_coded_type._build_odxlinks())
@@ -96,7 +96,7 @@ class DataObjectProperty(DopBase):
         self.compu_method._resolve_odxlinks(odxlinks)
         self.diag_coded_type._resolve_odxlinks(odxlinks)
 
-        self._unit: Optional[Unit] = None
+        self._unit: Unit | None = None
         if self.unit_ref:
             self._unit = odxlinks.resolve(self.unit_ref, Unit)
 
@@ -106,7 +106,7 @@ class DataObjectProperty(DopBase):
         self.compu_method._resolve_snrefs(context)
         self.diag_coded_type._resolve_snrefs(context)
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return self.diag_coded_type.get_static_bit_length()
 
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
@@ -118,7 +118,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, BytesTypes)):
+        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/decodestate.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING
 
 from .encoding import Encoding, get_string_encoding
 from .exceptions import DecodeError, odxassert, odxraise, strict_mode
@@ -41,22 +41,22 @@ class DecodeState:
     cursor_bit_position: int = 0
 
     #: values of the length key parameters decoded so far
-    length_keys: Dict[str, int] = field(default_factory=dict)
+    length_keys: dict[str, int] = field(default_factory=dict)
 
     #: values of the table key parameters decoded so far
-    table_keys: Dict[str, "TableRow"] = field(default_factory=dict)
+    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)
+    journal: list[tuple["Parameter", ParameterValue | None]] = field(default_factory=list)
 
     def extract_atomic_value(
         self,
         *,
         bit_length: int,
         base_data_type: DataType,
-        base_type_encoding: Optional[Encoding],
+        base_type_encoding: Encoding | None,
         is_highlow_byte_order: bool,
     ) -> AtomicOdxType:
         """Extract an internal value from a blob of raw bytes.

odxtools/description.py

@@ -1,38 +1,22 @@
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
+from .externaldoc import ExternalDoc
 from .odxlink import OdxDocFragment
 
 
-@dataclass
-class ExternalDoc:
-    description: Optional[str]
-    href: str
-
-    @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element],
-                doc_frags: List[OdxDocFragment]) -> Optional["ExternalDoc"]:
-        if et_element is None:
-            return None
-
-        description = et_element.text
-        href = odxrequire(et_element.get("HREF"))
-
-        return ExternalDoc(description=description, href=href)
-
-
 @dataclass
 class Description:
     text: str
-    external_docs: List[ExternalDoc]
+    external_docs: list[ExternalDoc]
 
-    text_identifier: Optional[str]
+    text_identifier: str | None
 
     @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element],
-                doc_frags: List[OdxDocFragment]) -> Optional["Description"]:
+    def from_et(et_element: ElementTree.Element | None,
+                doc_frags: list[OdxDocFragment]) -> Optional["Description"]:
         if et_element is None:
             return None
 

odxtools/determinenumberofitems.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from .dataobjectproperty import DataObjectProperty
@@ -15,7 +15,7 @@ class DetermineNumberOfItems:
     The object that determines the number of items of dynamic fields
     """
     byte_position: int
-    bit_position: Optional[int]
+    bit_position: int | None
     dop_ref: OdxLinkRef
 
     @property
@@ -24,7 +24,7 @@ class DetermineNumberOfItems:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DetermineNumberOfItems":
+                doc_frags: list[OdxDocFragment]) -> "DetermineNumberOfItems":
         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
@@ -36,7 +36,7 @@ class DetermineNumberOfItems:
             dop_ref=dop_ref,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/diagclasstype.py

@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class DiagClassType(Enum):
+    STARTCOMM = "STARTCOMM"
+    STOPCOMM = "STOPCOMM"
+    VARIANTIDENTIFICATION = "VARIANTIDENTIFICATION"
+    READ_DYN_DEFINED_MESSAGE = "READ-DYN-DEFINED-MESSAGE"
+    DYN_DEF_MESSAGE = "DYN-DEF-MESSAGE"
+    CLEAR_DYN_DEF_MESSAGE = "CLEAR-DYN-DEF-MESSAGE"

odxtools/diagcodedtype.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Literal, Optional, Union, cast
+from typing import Any, Literal, cast
 from xml.etree import ElementTree
 
 from .decodestate import DecodeState
@@ -22,10 +22,10 @@ DctType = Literal[
 
 @dataclass
 class DiagCodedType:
-    base_type_encoding: Optional[Encoding]
+    base_type_encoding: Encoding | None
     base_data_type: DataType
 
-    is_highlow_byte_order_raw: Optional[bool]
+    is_highlow_byte_order_raw: bool | None
 
     @property
     def dct_type(self) -> DctType:
@@ -39,7 +39,7 @@ class DiagCodedType:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DiagCodedType":
+                doc_frags: list[OdxDocFragment]) -> "DiagCodedType":
         base_type_encoding = None
         if (base_type_encoding_str := et_element.get("BASE-TYPE-ENCODING")) is not None:
             try:
@@ -61,7 +61,7 @@ class DiagCodedType:
             base_data_type=base_data_type,
             is_highlow_byte_order_raw=is_highlow_byte_order_raw)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:  # noqa: B027
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:  # noqa: B027
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:  # noqa: B027
@@ -72,10 +72,10 @@ class DiagCodedType:
         """Recursively resolve any short-name references"""
         pass
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return None
 
-    def _minimal_byte_length_of(self, internal_value: Union[bytes, str]) -> int:
+    def _minimal_byte_length_of(self, internal_value: bytes | str) -> int:
         """Helper method to get the minimal byte length.
         (needed for LeadingLength- and MinMaxLengthType)
         """

odxtools/diagcomm.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .audience import Audience
+from .diagclasstype import DiagClassType
 from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
 from .functionalclass import FunctionalClass
@@ -13,6 +13,7 @@ from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
 from .preconditionstateref import PreConditionStateRef
+from .relateddiagcommref import RelatedDiagCommRef
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .state import State
@@ -24,30 +25,6 @@ if TYPE_CHECKING:
     from .diaglayers.protocol import Protocol
 
 
-class DiagClassType(Enum):
-    STARTCOMM = "STARTCOMM"
-    STOPCOMM = "STOPCOMM"
-    VARIANTIDENTIFICATION = "VARIANTIDENTIFICATION"
-    READ_DYN_DEFINED_MESSAGE = "READ-DYN-DEFINED-MESSAGE"
-    DYN_DEF_MESSAGE = "DYN-DEF-MESSAGE"
-    CLEAR_DYN_DEF_MESSAGE = "CLEAR-DYN-DEF-MESSAGE"
-
-
-@dataclass
-class RelatedDiagCommRef(OdxLinkRef):
-    relation_type: str
-
-    @staticmethod
-    def from_et(  # type: ignore[override]
-            et_element: ElementTree.Element,
-            doc_frags: List[OdxDocFragment]) -> "RelatedDiagCommRef":
-        kwargs = dataclass_fields_asdict(odxrequire(OdxLinkRef.from_et(et_element, doc_frags)))
-
-        relation_type = odxrequire(et_element.findtext("RELATION-TYPE"))
-
-        return RelatedDiagCommRef(relation_type=relation_type, **kwargs)
-
-
 @dataclass
 class DiagComm(IdentifiableElement):
     """Representation of a diagnostic communication object.
@@ -57,21 +34,21 @@ class DiagComm(IdentifiableElement):
 
     """
 
-    admin_data: Optional[AdminData]
-    sdgs: List[SpecialDataGroup]
-    functional_class_refs: List[OdxLinkRef]
-    audience: Optional[Audience]
-    protocol_snrefs: List[str]
-    related_diag_comm_refs: List[RelatedDiagCommRef]
-    pre_condition_state_refs: List[PreConditionStateRef]
-    state_transition_refs: List[StateTransitionRef]
+    admin_data: AdminData | None
+    sdgs: list[SpecialDataGroup]
+    functional_class_refs: list[OdxLinkRef]
+    audience: Audience | None
+    protocol_snrefs: list[str]
+    related_diag_comm_refs: list[RelatedDiagCommRef]
+    pre_condition_state_refs: list[PreConditionStateRef]
+    state_transition_refs: list[StateTransitionRef]
 
     # attributes
-    semantic: Optional[str]
-    diagnostic_class: Optional[DiagClassType]
-    is_mandatory_raw: Optional[bool]
-    is_executable_raw: Optional[bool]
-    is_final_raw: Optional[bool]
+    semantic: str | None
+    diagnostic_class: DiagClassType | None
+    is_mandatory_raw: bool | None
+    is_executable_raw: bool | None
+    is_final_raw: bool | None
 
     @property
     def functional_classes(self) -> NamedItemList[FunctionalClass]:
@@ -106,7 +83,7 @@ class DiagComm(IdentifiableElement):
         return self.is_final_raw is True
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagComm":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DiagComm":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
@@ -145,7 +122,7 @@ class DiagComm(IdentifiableElement):
 
         semantic = et_element.attrib.get("SEMANTIC")
 
-        diagnostic_class: Optional[DiagClassType] = None
+        diagnostic_class: DiagClassType | None = None
         if (diagnostic_class_str := et_element.attrib.get("DIAGNOSTIC-CLASS")) is not None:
             try:
                 diagnostic_class = DiagClassType(diagnostic_class_str)
@@ -172,7 +149,7 @@ class DiagComm(IdentifiableElement):
             is_final_raw=is_final_raw,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         if self.admin_data is not None:

odxtools/diagdatadictionaryspec.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -26,7 +26,7 @@ from .unitspec import UnitSpec
 
 @dataclass
 class DiagDataDictionarySpec:
-    admin_data: Optional[AdminData]
+    admin_data: AdminData | None
     dtc_dops: NamedItemList[DtcDop]
     env_data_descs: NamedItemList[EnvironmentDataDescription]
     data_object_props: NamedItemList[DataObjectProperty]
@@ -37,13 +37,13 @@ class DiagDataDictionarySpec:
     end_of_pdu_fields: NamedItemList[EndOfPduField]
     muxs: NamedItemList[Multiplexer]
     env_datas: NamedItemList[EnvironmentData]
-    unit_spec: Optional[UnitSpec]
+    unit_spec: UnitSpec | None
     tables: NamedItemList[Table]
-    sdgs: List[SpecialDataGroup]
+    sdgs: list[SpecialDataGroup]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DiagDataDictionarySpec":
+                doc_frags: list[OdxDocFragment]) -> "DiagDataDictionarySpec":
         admin_data = None
         if (admin_data_elem := et_element.find("ADMIN-DATA")) is not None:
             admin_data = AdminData.from_et(admin_data_elem, doc_frags)
@@ -149,7 +149,7 @@ class DiagDataDictionarySpec:
                 self.env_datas,
             ))
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         # note that DataDictionarySpec objects do not exhibit an ODXLINK id.
         odxlinks = {}
 

odxtools/diaglayercontainer.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Dict, List, Union
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .diaglayers.basevariant import BaseVariant
@@ -41,7 +41,7 @@ class DiagLayerContainer(OdxCategory):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DiagLayerContainer":
+                doc_frags: list[OdxDocFragment]) -> "DiagLayerContainer":
 
         cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type=DocType.CONTAINER)
         doc_frags = cat.odx_id.doc_fragments
@@ -85,7 +85,7 @@ class DiagLayerContainer(OdxCategory):
             self.ecu_variants,
         ),)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for protocol in self.protocols:
@@ -132,5 +132,5 @@ class DiagLayerContainer(OdxCategory):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
 
-    def __getitem__(self, key: Union[int, str]) -> DiagLayer:
+    def __getitem__(self, key: int | str) -> DiagLayer:
         return self.diag_layers[key]

odxtools/diaglayers/basevariant.py

@@ -1,7 +1,8 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any, Dict, Iterable, List, Optional, Union, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -32,19 +33,19 @@ class BaseVariant(HierarchyElement):
     # <properties forwarded to the "raw" base variant>
     #####
     @property
-    def diag_variables_raw(self) -> List[Union[DiagVariable, OdxLinkRef]]:
+    def diag_variables_raw(self) -> list[DiagVariable | OdxLinkRef]:
         return self.base_variant_raw.diag_variables_raw
 
     @property
-    def dyn_defined_spec(self) -> Optional[DynDefinedSpec]:
+    def dyn_defined_spec(self) -> DynDefinedSpec | None:
         return self.base_variant_raw.dyn_defined_spec
 
     @property
-    def base_variant_pattern(self) -> Optional[BaseVariantPattern]:
+    def base_variant_pattern(self) -> BaseVariantPattern | None:
         return self.base_variant_raw.base_variant_pattern
 
     @property
-    def parent_refs(self) -> List[ParentRef]:
+    def parent_refs(self) -> list[ParentRef]:
         return self.base_variant_raw.parent_refs
 
     #####
@@ -67,7 +68,7 @@ class BaseVariant(HierarchyElement):
     #######
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "BaseVariant":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "BaseVariant":
         base_variant_raw = BaseVariantRaw.from_et(et_element, doc_frags)
 
         return BaseVariant(diag_layer_raw=base_variant_raw)
@@ -80,7 +81,7 @@ class BaseVariant(HierarchyElement):
             "The raw diagnostic layer passed to BaseVariant "
             "must be a BaseVariantRaw")
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         """Create a deep copy of the base variant
 
         Note that the copied diagnostic layer is not fully
@@ -113,7 +114,7 @@ class BaseVariant(HierarchyElement):
 
             return dl.diag_layer_raw.diag_variables  # type: ignore[no-any-return]
 
-        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+        def not_inherited_fn(parent_ref: ParentRef) -> list[str]:
             return parent_ref.not_inherited_variables
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
@@ -127,7 +128,7 @@ class BaseVariant(HierarchyElement):
 
             return dl.diag_layer_raw.variable_groups  # type: ignore[no-any-return]
 
-        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+        def not_inherited_fn(parent_ref: ParentRef) -> list[str]:
             return []
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)

odxtools/diaglayers/basevariantraw.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 from xml.etree import ElementTree
 
 from ..basevariantpattern import BaseVariantPattern
@@ -21,11 +21,11 @@ class BaseVariantRaw(HierarchyElementRaw):
     """This is a diagnostic layer for common functionality of an ECU
     """
 
-    diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]]
+    diag_variables_raw: list[DiagVariable | OdxLinkRef]
     variable_groups: NamedItemList[VariableGroup]
-    dyn_defined_spec: Optional[DynDefinedSpec]
-    base_variant_pattern: Optional[BaseVariantPattern]
-    parent_refs: List[ParentRef]
+    dyn_defined_spec: DynDefinedSpec | None
+    base_variant_pattern: BaseVariantPattern | None
+    parent_refs: list[ParentRef]
 
     @property
     def diag_variables(self) -> NamedItemList[DiagVariable]:
@@ -33,7 +33,7 @@ class BaseVariantRaw(HierarchyElementRaw):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "BaseVariantRaw":
+                doc_frags: list[OdxDocFragment]) -> "BaseVariantRaw":
         # objects contained by diagnostic layers exibit an additional
         # document fragment for the diag layer, so we use the document
         # fragments of the odx id of the diag layer for IDs of
@@ -42,10 +42,10 @@ class BaseVariantRaw(HierarchyElementRaw):
         kwargs = dataclass_fields_asdict(her)
         doc_frags = her.odx_id.doc_fragments
 
-        diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]] = []
+        diag_variables_raw: list[DiagVariable | OdxLinkRef] = []
         if (dv_elems := et_element.find("DIAG-VARIABLES")) is not None:
             for dv_proxy_elem in dv_elems:
-                dv_proxy: Union[OdxLinkRef, DiagVariable]
+                dv_proxy: OdxLinkRef | DiagVariable
                 if dv_proxy_elem.tag == "DIAG-VARIABLE-REF":
                     dv_proxy = OdxLinkRef.from_et(dv_proxy_elem, doc_frags)
                 elif dv_proxy_elem.tag == "DIAG-VARIABLE":
@@ -81,7 +81,7 @@ class BaseVariantRaw(HierarchyElementRaw):
             parent_refs=parent_refs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for dv_proxy in self.diag_variables_raw: