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

odxtools/diagvariable.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import typing
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, runtime_checkable
+from typing import Any, runtime_checkable
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -33,32 +33,32 @@ class DiagVariable(IdentifiableElement):
     """Representation of a diagnostic variable
     """
 
-    admin_data: Optional[AdminData]
-    variable_group_ref: Optional[OdxLinkRef]
-    sw_variables: List[SwVariable]
+    admin_data: AdminData | None
+    variable_group_ref: OdxLinkRef | None
+    sw_variables: list[SwVariable]
 
     # a diag variable must specify either COMM-RELATIONS or a
     # reference to a table row
-    comm_relations: List[CommRelation]
+    comm_relations: list[CommRelation]
 
     # these are nested inside the SNREF-TO-TABLEROW tag
-    table_snref: Optional[str]
-    table_row_snref: Optional[str]
+    table_snref: str | None
+    table_row_snref: str | None
 
-    sdgs: List[SpecialDataGroup]
+    sdgs: list[SpecialDataGroup]
 
-    is_read_before_write_raw: Optional[bool]
+    is_read_before_write_raw: bool | None
 
     @property
-    def table(self) -> Optional[Table]:
+    def table(self) -> Table | None:
         return self._table
 
     @property
-    def table_row(self) -> Optional[TableRow]:
+    def table_row(self) -> TableRow | None:
         return self._table_row
 
     @property
-    def variable_group(self) -> Optional[VariableGroup]:
+    def variable_group(self) -> VariableGroup | None:
         return self._variable_group
 
     @property
@@ -66,7 +66,7 @@ class DiagVariable(IdentifiableElement):
         return self.is_read_before_write_raw is True
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagVariable":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DiagVariable":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
@@ -106,7 +106,7 @@ class DiagVariable(IdentifiableElement):
             is_read_before_write_raw=is_read_before_write_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/docrevision.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 .companyrevisioninfo import CompanyRevisionInfo
@@ -17,20 +17,20 @@ class DocRevision:
     Representation of a single revision of the relevant object.
     """
 
-    team_member_ref: Optional[OdxLinkRef]
-    revision_label: Optional[str]
-    state: Optional[str]
+    team_member_ref: OdxLinkRef | None
+    revision_label: str | None
+    state: str | None
     date: str
-    tool: Optional[str]
-    company_revision_infos: List[CompanyRevisionInfo]
-    modifications: List[Modification]
+    tool: str | None
+    company_revision_infos: list[CompanyRevisionInfo]
+    modifications: list[Modification]
 
     @property
-    def team_member(self) -> Optional[TeamMember]:
+    def team_member(self) -> TeamMember | None:
         return self._team_member
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DocRevision":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DocRevision":
 
         team_member_ref = OdxLinkRef.from_et(et_element.find("TEAM-MEMBER-REF"), doc_frags)
         revision_label = et_element.findtext("REVISION-LABEL")
@@ -59,11 +59,11 @@ class DocRevision:
             modifications=modifications,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._team_member: Optional[TeamMember] = None
+        self._team_member: TeamMember | None = None
         if self.team_member_ref is not None:
             self._team_member = odxlinks.resolve(self.team_member_ref, TeamMember)
 

odxtools/dopbase.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 .admindata import AdminData
@@ -24,11 +24,11 @@ class DopBase(IdentifiableElement):
 
     """
 
-    admin_data: Optional[AdminData]
-    sdgs: List[SpecialDataGroup]
+    admin_data: AdminData | None
+    sdgs: list[SpecialDataGroup]
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DopBase":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DopBase":
 
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
@@ -42,7 +42,7 @@ class DopBase(IdentifiableElement):
 
         return DopBase(admin_data=admin_data, sdgs=sdgs, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         for sdg in self.sdgs:
@@ -58,7 +58,7 @@ class DopBase(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_snrefs(context)
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return None
 
     def is_valid_physical_value(self, physical_value: ParameterValue) -> bool:

odxtools/dtcconnector.py

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .diagnostictroublecode import DiagnosticTroubleCode
+from .dtcdop import DtcDop
+from .element import NamedElement
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class DtcConnector(NamedElement):
+    dtc_dop_ref: OdxLinkRef
+    dtc_snref: str
+
+    @property
+    def dtc_dop(self) -> DtcDop:
+        return self._dtc_dop
+
+    @property
+    def dtc(self) -> DiagnosticTroubleCode:
+        return self._dtc
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DtcConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), doc_frags))
+        dtc_snref_el = odxrequire(et_element.find("DTC-SNREF"))
+        dtc_snref = odxrequire(dtc_snref_el.get("SHORT-NAME"))
+
+        return DtcConnector(dtc_dop_ref=dtc_dop_ref, dtc_snref=dtc_snref, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref, DtcDop)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        self._dtc = resolve_snref(self.dtc_snref, self._dtc_dop.dtcs, DiagnosticTroubleCode)

odxtools/dtcdop.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -14,60 +14,15 @@ from .diagnostictroublecode import DiagnosticTroubleCode
 from .dopbase import DopBase
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from .linkeddtcdop import LinkedDtcDop
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValue, odxstr_to_bool
 from .physicaltype import PhysicalType
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
-class LinkedDtcDop:
-    not_inherited_dtc_snrefs: List[str]
-    dtc_dop_ref: OdxLinkRef
-
-    @property
-    def not_inherited_dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
-        return self._not_inherited_dtcs
-
-    @property
-    def dtc_dop(self) -> "DtcDop":
-        return self._dtc_dop
-
-    @property
-    def short_name(self) -> str:
-        return self._dtc_dop.short_name
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "LinkedDtcDop":
-        not_inherited_dtc_snrefs = [
-            odxrequire(el.get("SHORT-NAME"))
-            for el in et_element.iterfind("NOT-INHERITED-DTC-SNREFS/"
-                                          "NOT-INHERITED-DTC-SNREF")
-        ]
-
-        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), doc_frags))
-
-        return LinkedDtcDop(
-            not_inherited_dtc_snrefs=not_inherited_dtc_snrefs, dtc_dop_ref=dtc_dop_ref)
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        return {}
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref, DtcDop)
-
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        dtc_dop = self._dtc_dop
-        not_inherited_dtcs = [
-            resolve_snref(ni_snref, dtc_dop.dtcs, DiagnosticTroubleCode)
-            for ni_snref in self.not_inherited_dtc_snrefs
-        ]
-
-        self._not_inherited_dtcs = NamedItemList(not_inherited_dtcs)
-
-
 @dataclass
 class DtcDop(DopBase):
     """A DOP describing a diagnostic trouble code"""
@@ -75,9 +30,9 @@ class DtcDop(DopBase):
     diag_coded_type: DiagCodedType
     physical_type: PhysicalType
     compu_method: CompuMethod
-    dtcs_raw: List[Union[DiagnosticTroubleCode, OdxLinkRef]]
-    linked_dtc_dops_raw: List[LinkedDtcDop]
-    is_visible_raw: Optional[bool]
+    dtcs_raw: list[DiagnosticTroubleCode | OdxLinkRef]
+    linked_dtc_dops_raw: list[LinkedDtcDop]
+    is_visible_raw: bool | None
 
     @property
     def dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
@@ -92,7 +47,7 @@ class DtcDop(DopBase):
         return self.is_visible_raw is True
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DtcDop":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DtcDop":
         """Reads a DTC-DOP."""
         kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, doc_frags))
 
@@ -106,7 +61,7 @@ class DtcDop(DopBase):
             internal_type=diag_coded_type.base_data_type,
             physical_type=physical_type.base_data_type,
         )
-        dtcs_raw: List[Union[DiagnosticTroubleCode, OdxLinkRef]] = []
+        dtcs_raw: list[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":
@@ -200,7 +155,7 @@ class DtcDop(DopBase):
             return cast(int, None)
 
     @override
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         if physical_value is None:
             odxraise(f"No DTC specified", EncodeError)
@@ -208,7 +163,11 @@ class DtcDop(DopBase):
 
         trouble_code = self.convert_to_numerical_trouble_code(physical_value)
 
-        internal_trouble_code = int(self.compu_method.convert_physical_to_internal(trouble_code))
+        if not isinstance(trouble_code, int):
+            odxraise()
+        internal_trouble_code = self.compu_method.convert_physical_to_internal(trouble_code)
+        if not isinstance(internal_trouble_code, int):
+            odxraise()
 
         found = False
         for dtc in self.dtcs:
@@ -223,7 +182,7 @@ class DtcDop(DopBase):
 
         self.diag_coded_type.encode_into_pdu(internal_trouble_code, encode_state)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
         odxlinks.update(self.compu_method._build_odxlinks())

odxtools/dynamicendmarkerfield.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Any, Dict, List, Sequence
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -33,7 +34,7 @@ class DynamicEndmarkerField(Field):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DynamicEndmarkerField":
+                doc_frags: list[OdxDocFragment]) -> "DynamicEndmarkerField":
         kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
 
         # ODX 2.0 uses DATA-OBJECT-PROP-REF
@@ -43,7 +44,7 @@ class DynamicEndmarkerField(Field):
 
         return DynamicEndmarkerField(dyn_end_dop_ref=dyn_end_dop_ref, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
         return odxlinks
 
@@ -102,7 +103,7 @@ class DynamicEndmarkerField(Field):
         orig_origin = decode_state.origin_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
-        result: List[ParameterValue] = []
+        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):

odxtools/dynamiclengthfield.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Any, Dict, List, Sequence
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -24,7 +25,7 @@ class DynamicLengthField(Field):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DynamicLengthField":
+                doc_frags: list[OdxDocFragment]) -> "DynamicLengthField":
         kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
 
         offset = int(odxrequire(et_element.findtext('OFFSET')))
@@ -36,7 +37,7 @@ class DynamicLengthField(Field):
         return DynamicLengthField(
             offset=offset, determine_number_of_items=determine_number_of_items, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
         odxlinks.update(self.determine_number_of_items._build_odxlinks())
         return odxlinks
@@ -106,7 +107,7 @@ class DynamicLengthField(Field):
         decode_state.cursor_bit_position = det_num_items.bit_position or 0
 
         n = det_num_items.dop.decode_from_pdu(decode_state)
-        result: List[ParameterValue] = []
+        result: list[ParameterValue] = []
 
         if not isinstance(n, int):
             odxraise(f"Number of items specified by a dynamic length field {self.short_name} "

odxtools/dyndefinedspec.py

@@ -1,180 +1,28 @@
 # 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 .diagcomm import DiagClassType, DiagComm
-from .exceptions import odxassert, odxraise, odxrequire
-from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .dyniddefmodeinfo import DynIdDefModeInfo
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
-from .table import Table
-
-
-@dataclass
-class DynIdDefModeInfo:
-    def_mode: str
-
-    clear_dyn_def_message_ref: Optional[OdxLinkRef]
-    clear_dyn_def_message_snref: Optional[str]
-
-    read_dyn_def_message_ref: Optional[OdxLinkRef]
-    read_dyn_def_message_snref: Optional[str]
-
-    dyn_def_message_ref: Optional[OdxLinkRef]
-    dyn_def_message_snref: Optional[str]
-
-    supported_dyn_ids: List[bytes]
-    selection_table_refs: List[Union[OdxLinkRef, str]]
-
-    @property
-    def clear_dyn_def_message(self) -> DiagComm:
-        return self._clear_dyn_def_message
-
-    @property
-    def read_dyn_def_message(self) -> DiagComm:
-        return self._read_dyn_def_message
-
-    @property
-    def dyn_def_message(self) -> DiagComm:
-        return self._dyn_def_message
-
-    @property
-    def selection_tables(self) -> NamedItemList[Table]:
-        return self._selection_tables
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DynIdDefModeInfo":
-        def_mode = odxrequire(et_element.findtext("DEF-MODE"))
-
-        clear_dyn_def_message_ref = OdxLinkRef.from_et(
-            et_element.find("CLEAR-DYN-DEF-MESSAGE-REF"), doc_frags)
-        clear_dyn_def_message_snref = None
-        if (snref_elem := et_element.find("CLEAR-DYN-DEF-MESSAGE-SNREF")) is not None:
-            clear_dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
-
-        read_dyn_def_message_ref = OdxLinkRef.from_et(
-            et_element.find("READ-DYN-DEF-MESSAGE-REF"), doc_frags)
-        read_dyn_def_message_snref = None
-        if (snref_elem := et_element.find("READ-DYN-DEF-MESSAGE-SNREF")) is not None:
-            read_dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
-
-        dyn_def_message_ref = OdxLinkRef.from_et(et_element.find("DYN-DEF-MESSAGE-REF"), doc_frags)
-        dyn_def_message_snref = None
-        if (snref_elem := et_element.find("DYN-DEF-MESSAGE-SNREF")) is not None:
-            dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
-
-        supported_dyn_ids = [
-            bytes.fromhex(odxrequire(x.text))
-            for x in et_element.iterfind("SUPPORTED-DYN-IDS/SUPPORTED-DYN-ID")
-        ]
-
-        selection_table_refs: List[Union[OdxLinkRef, str]] = []
-        if (st_elems := et_element.find("SELECTION-TABLE-REFS")) is not None:
-            for st_elem in st_elems:
-                if st_elem.tag == "SELECTION-TABLE-REF":
-                    selection_table_refs.append(OdxLinkRef.from_et(st_elem, doc_frags))
-                elif st_elem.tag == "SELECTION-TABLE-SNREF":
-                    selection_table_refs.append(odxrequire(st_elem.get("SHORT-NAME")))
-                else:
-                    odxraise()
-
-        return DynIdDefModeInfo(
-            def_mode=def_mode,
-            clear_dyn_def_message_ref=clear_dyn_def_message_ref,
-            clear_dyn_def_message_snref=clear_dyn_def_message_snref,
-            read_dyn_def_message_ref=read_dyn_def_message_ref,
-            read_dyn_def_message_snref=read_dyn_def_message_snref,
-            dyn_def_message_ref=dyn_def_message_ref,
-            dyn_def_message_snref=dyn_def_message_snref,
-            supported_dyn_ids=supported_dyn_ids,
-            selection_table_refs=selection_table_refs,
-        )
-
-    def __post_init__(self) -> None:
-        odxassert(
-            self.clear_dyn_def_message_ref is not None or
-            self.clear_dyn_def_message_snref is not None,
-            "A CLEAR-DYN-DEF-MESSAGE must be specified")
-        odxassert(
-            self.read_dyn_def_message_ref is not None or
-            self.read_dyn_def_message_snref is not None, "A READ-DYN-DEF-MESSAGE must be specified")
-        odxassert(self.dyn_def_message_ref is not None or self.dyn_def_message_snref is not None,
-                  "A DYN-DEF-MESSAGE must be specified")
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result: Dict[OdxLinkId, Any] = {}
-
-        return result
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        if self.clear_dyn_def_message_ref is not None:
-            self._clear_dyn_def_message = odxlinks.resolve(self.clear_dyn_def_message_ref, DiagComm)
-
-        if self.read_dyn_def_message_ref is not None:
-            self._read_dyn_def_message = odxlinks.resolve(self.read_dyn_def_message_ref, DiagComm)
-
-        if self.dyn_def_message_ref is not None:
-            self._dyn_def_message = odxlinks.resolve(self.dyn_def_message_ref, DiagComm)
-
-        # resolve the selection tables that are referenced via ODXLINK
-        self._selection_tables = NamedItemList[Table]()
-        for x in self.selection_table_refs:
-            if isinstance(x, OdxLinkRef):
-                self._selection_tables.append(odxlinks.resolve(x, Table))
-
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        diag_layer = odxrequire(context.diag_layer)
-
-        if self.clear_dyn_def_message_snref is not None:
-            self._clear_dyn_def_message = resolve_snref(self.clear_dyn_def_message_snref,
-                                                        diag_layer.diag_comms, DiagComm)
-
-        if self.read_dyn_def_message_snref is not None:
-            self._read_dyn_def_message = resolve_snref(self.read_dyn_def_message_snref,
-                                                       diag_layer.diag_comms, DiagComm)
-
-        if self.dyn_def_message_snref is not None:
-            self._dyn_def_message = resolve_snref(self.dyn_def_message_snref, diag_layer.diag_comms,
-                                                  DiagComm)
-
-        if self._clear_dyn_def_message.diagnostic_class != DiagClassType.CLEAR_DYN_DEF_MESSAGE:
-            odxraise(
-                f"Diagnostic communication object of wrong type referenced: "
-                f"({odxrequire(self._clear_dyn_def_message.diagnostic_class).value} instead of "
-                f"CLEAR-DYN-DEF-MESSAGE)")
-        if self._read_dyn_def_message.diagnostic_class != DiagClassType.READ_DYN_DEFINED_MESSAGE:
-            odxraise(f"Diagnostic communication object of wrong type referenced: "
-                     f"({odxrequire(self._read_dyn_def_message.diagnostic_class).value} instead of "
-                     f"READ-DYN-DEFINED-MESSAGE)")
-        if self._dyn_def_message.diagnostic_class != DiagClassType.DYN_DEF_MESSAGE:
-            odxraise(f"Diagnostic communication object of wrong type referenced: "
-                     f"({odxrequire(self._dyn_def_message.diagnostic_class).value} instead of "
-                     f"DYN-DEF-MESSAGE)")
-
-        # resolve the remaining selection tables that are referenced via SNREF
-        ddd_spec = odxrequire(diag_layer.diag_data_dictionary_spec)
-        for i, x in enumerate(self.selection_table_refs):
-            if isinstance(x, str):
-                self._selection_tables.insert(i, resolve_snref(x, ddd_spec.tables, Table))
 
 
 @dataclass
 class DynDefinedSpec:
-    dyn_id_def_mode_infos: List[DynIdDefModeInfo]
+    dyn_id_def_mode_infos: list[DynIdDefModeInfo]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DynDefinedSpec":
+                doc_frags: list[OdxDocFragment]) -> "DynDefinedSpec":
         dyn_id_def_mode_infos = [
             DynIdDefModeInfo.from_et(x, doc_frags)
             for x in et_element.iterfind("DYN-ID-DEF-MODE-INFOS/DYN-ID-DEF-MODE-INFO")
         ]
         return DynDefinedSpec(dyn_id_def_mode_infos=dyn_id_def_mode_infos)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result: Dict[OdxLinkId, Any] = {}
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result: dict[OdxLinkId, Any] = {}
 
         for didmi in self.dyn_id_def_mode_infos:
             result.update(didmi._build_odxlinks())

odxtools/dynenddopref.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, overload
+from typing import Optional, overload
 from xml.etree import ElementTree
 
 from .exceptions import odxraise, odxrequire
@@ -14,18 +14,18 @@ class DynEndDopRef(OdxLinkRef):
 
     @staticmethod
     @overload
-    def from_et(et_element: None, source_doc_frags: List[OdxDocFragment]) -> None:
+    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":
+                source_doc_frags: list[OdxDocFragment]) -> "DynEndDopRef":
         ...
 
     @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element],
-                source_doc_frags: List[OdxDocFragment]) -> Optional["DynEndDopRef"]:
+    def from_et(et_element: ElementTree.Element | None,
+                source_doc_frags: list[OdxDocFragment]) -> Optional["DynEndDopRef"]:
 
         if et_element is None:
             odxraise("Mandatory DYN-END-DOP-REF tag is missing")