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

odxtools/diaglayers/hierarchyelement.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 import re
 import warnings
+from collections.abc import Callable, Iterable
 from copy import deepcopy
 from dataclasses import dataclass
 from functools import cached_property
-from typing import (TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional, Tuple, TypeVar,
-                    Union, cast)
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 from xml.etree import ElementTree
 
 from ..additionalaudience import AdditionalAudience
@@ -47,7 +47,7 @@ class HierarchyElement(DiagLayer):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "HierarchyElement":
+                doc_frags: list[OdxDocFragment]) -> "HierarchyElement":
         hierarchy_element_raw = HierarchyElementRaw.from_et(et_element, doc_frags)
 
         return HierarchyElement(diag_layer_raw=hierarchy_element_raw)
@@ -62,7 +62,7 @@ class HierarchyElement(DiagLayer):
             "The raw diagnostic layer passed to HierarchyElement "
             "must be a HierarchyElementRaw")
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         return result
@@ -73,7 +73,7 @@ class HierarchyElement(DiagLayer):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         """Create a deep copy of the hierarchy element
 
         Note that the copied diagnostic layer is not fully
@@ -121,13 +121,13 @@ class HierarchyElement(DiagLayer):
         unit_groups = self._compute_available_unit_groups()
 
         # convenience variable for the locally-defined unit spec
-        local_unit_spec: Optional[UnitSpec]
+        local_unit_spec: UnitSpec | None
         if self.diag_layer_raw.diag_data_dictionary_spec is not None:
             local_unit_spec = self.diag_layer_raw.diag_data_dictionary_spec.unit_spec
         else:
             local_unit_spec = None
 
-        unit_spec: Optional[UnitSpec]
+        unit_spec: UnitSpec | None
         if local_unit_spec is None and not unit_groups:
             # no locally defined unit spec and no inherited unit groups
             unit_spec = None
@@ -188,8 +188,8 @@ class HierarchyElement(DiagLayer):
         tables = self._compute_available_ddd_spec_items(
             lambda ddd_spec: ddd_spec.tables, lambda parent_ref: parent_ref.not_inherited_tables)
 
-        ddds_admin_data: Optional[AdminData] = None
-        ddds_sdgs: List[SpecialDataGroup] = []
+        ddds_admin_data: AdminData | None = None
+        ddds_sdgs: list[SpecialDataGroup] = []
         if self.diag_layer_raw.diag_data_dictionary_spec:
             ddds_admin_data = self.diag_layer_raw.diag_data_dictionary_spec.admin_data
             ddds_sdgs = self.diag_layer_raw.diag_data_dictionary_spec.sdgs
@@ -291,7 +291,7 @@ class HierarchyElement(DiagLayer):
 
         local_objects = get_local_objects(self)
         local_object_short_names = {x.short_name for x in local_objects}
-        result_dict: Dict[str, Tuple[TNamed, DiagLayer]] = {}
+        result_dict: dict[str, tuple[TNamed, DiagLayer]] = {}
 
         # populate the result dictionary with the inherited objects
         for parent_ref in self._get_parent_refs_sorted_by_priority(reverse=True):
@@ -361,7 +361,7 @@ class HierarchyElement(DiagLayer):
         def get_local_objects_fn(dl: DiagLayer) -> Iterable[DiagComm]:
             return dl._get_local_diag_comms(odxlinks)
 
-        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+        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)
@@ -372,7 +372,7 @@ class HierarchyElement(DiagLayer):
         def get_local_objects_fn(dl: DiagLayer) -> Iterable[Response]:
             return dl.diag_layer_raw.global_negative_responses
 
-        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+        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)
@@ -380,7 +380,7 @@ class HierarchyElement(DiagLayer):
     def _compute_available_ddd_spec_items(
         self,
         include: Callable[[DiagDataDictionarySpec], Iterable[TNamed]],
-        exclude: Callable[["ParentRef"], List[str]],
+        exclude: Callable[["ParentRef"], list[str]],
     ) -> NamedItemList[TNamed]:
 
         def get_local_objects_fn(dl: DiagLayer) -> Iterable[TNamed]:
@@ -396,7 +396,7 @@ class HierarchyElement(DiagLayer):
         def get_local_objects_fn(dl: DiagLayer) -> Iterable[FunctionalClass]:
             return dl.diag_layer_raw.functional_classes
 
-        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)
@@ -406,7 +406,7 @@ class HierarchyElement(DiagLayer):
         def get_local_objects_fn(dl: DiagLayer) -> Iterable[AdditionalAudience]:
             return dl.diag_layer_raw.additional_audiences
 
-        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)
@@ -416,7 +416,7 @@ class HierarchyElement(DiagLayer):
         def get_local_objects_fn(dl: DiagLayer) -> Iterable[StateChart]:
             return dl.diag_layer_raw.state_charts
 
-        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)
@@ -426,7 +426,7 @@ class HierarchyElement(DiagLayer):
         def get_local_objects_fn(dl: DiagLayer) -> Iterable[UnitGroup]:
             return dl._get_local_unit_groups()
 
-        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)
@@ -502,7 +502,7 @@ class HierarchyElement(DiagLayer):
     #####
     # <communication parameter handling>
     #####
-    def _compute_available_commmunication_parameters(self) -> List[ComparamInstance]:
+    def _compute_available_commmunication_parameters(self) -> list[ComparamInstance]:
         """Compute the list of communication parameters that apply to
         the diagnostic layer
 
@@ -526,7 +526,7 @@ class HierarchyElement(DiagLayer):
         without a specified protocol are taken as fallbacks...
 
         """
-        com_params_dict: Dict[Tuple[str, Optional[str]], ComparamInstance] = {}
+        com_params_dict: dict[tuple[str, str | None], ComparamInstance] = {}
 
         # Look in parent refs for inherited communication
         # parameters. First fetch the communication parameters from
@@ -564,7 +564,7 @@ class HierarchyElement(DiagLayer):
         """
         from .protocol import Protocol
 
-        result_dict: Dict[str, Protocol] = {}
+        result_dict: dict[str, Protocol] = {}
 
         for parent_ref in getattr(self, "parent_refs", []):
             for prot in getattr(parent_ref.layer, "protocols", []):
@@ -579,15 +579,15 @@ class HierarchyElement(DiagLayer):
         self,
         cp_short_name: str,
         *,
-        protocol: Optional[Union[str, "Protocol"]] = None,
-    ) -> Optional[ComparamInstance]:
+        protocol: Union[str, "Protocol"] | None = None,
+    ) -> ComparamInstance | None:
         """Find a specific communication parameter according to some criteria.
 
         Setting a given parameter to `None` means "don't care"."""
 
         from .protocol import Protocol
 
-        protocol_name: Optional[str]
+        protocol_name: str | None
         if isinstance(protocol, Protocol):
             protocol_name = protocol.short_name
         else:
@@ -611,8 +611,7 @@ class HierarchyElement(DiagLayer):
         return cps[0]
 
     def get_max_can_payload_size(self,
-                                 protocol: Optional[Union[str,
-                                                          "Protocol"]] = None) -> Optional[int]:
+                                 protocol: Union[str, "Protocol"] | None = None) -> int | None:
         """Return the maximum size of a CAN frame payload that can be
         transmitted in bytes.
 
@@ -642,13 +641,13 @@ class HierarchyElement(DiagLayer):
         # unexpected format of parameter value
         return 8
 
-    def uses_can(self, protocol: Optional[Union[str, "Protocol"]] = None) -> bool:
+    def uses_can(self, protocol: Union[str, "Protocol"] | None = None) -> bool:
         """
         Check if CAN ought to be used as the link layer protocol.
         """
         return self.get_can_receive_id(protocol=protocol) is not None
 
-    def uses_can_fd(self, protocol: Optional[Union[str, "Protocol"]] = None) -> bool:
+    def uses_can_fd(self, protocol: Union[str, "Protocol"] | None = None) -> bool:
         """Check if CAN-FD ought to be used.
 
         If the ECU is not using CAN-FD for the specified protocol, `False`
@@ -667,7 +666,7 @@ class HierarchyElement(DiagLayer):
 
         return "CANFD" in com_param.value
 
-    def get_can_baudrate(self, protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
+    def get_can_baudrate(self, protocol: Union[str, "Protocol"] | None = None) -> int | None:
         """Baudrate of the CAN bus which is used by the ECU [bits/s]
 
         If the ECU is not using CAN for the specified protocol, None
@@ -684,8 +683,7 @@ class HierarchyElement(DiagLayer):
 
         return int(val)
 
-    def get_can_fd_baudrate(self,
-                            protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
+    def get_can_fd_baudrate(self, protocol: Union[str, "Protocol"] | None = None) -> int | None:
         """Data baudrate of the CAN bus which is used by the ECU [bits/s]
 
         If the ECU is not using CAN-FD for the specified protocol,
@@ -704,8 +702,7 @@ class HierarchyElement(DiagLayer):
 
         return int(val)
 
-    def get_can_receive_id(self,
-                           protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
+    def get_can_receive_id(self, protocol: Union[str, "Protocol"] | None = None) -> int | None:
         """CAN ID to which the ECU listens for diagnostic messages"""
         com_param = self.get_comparam("CP_UniqueRespIdTable", protocol=protocol)
         if com_param is None:
@@ -724,7 +721,7 @@ class HierarchyElement(DiagLayer):
 
         return int(result)
 
-    def get_can_send_id(self, protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
+    def get_can_send_id(self, protocol: Union[str, "Protocol"] | None = None) -> int | None:
         """CAN ID to which the ECU sends replies to diagnostic messages"""
 
         # this hopefully resolves to the 'CP_UniqueRespIdTable'
@@ -749,8 +746,7 @@ class HierarchyElement(DiagLayer):
 
         return int(result)
 
-    def get_can_func_req_id(self,
-                            protocol: Optional[Union[str, "Protocol"]] = None) -> Optional[int]:
+    def get_can_func_req_id(self, protocol: Union[str, "Protocol"] | None = None) -> int | None:
         """CAN Functional Request Id."""
         com_param = self.get_comparam("CP_CanFuncReqId", protocol=protocol)
         if com_param is None:
@@ -764,8 +760,7 @@ class HierarchyElement(DiagLayer):
         return int(result)
 
     def get_doip_logical_ecu_address(self,
-                                     protocol: Optional[Union[str,
-                                                              "Protocol"]] = None) -> Optional[int]:
+                                     protocol: Union[str, "Protocol"] | None = None) -> int | None:
         """Return the address of the ECU when using functional addressing.
 
         The parameter protocol is used to distinguish between
@@ -796,8 +791,8 @@ class HierarchyElement(DiagLayer):
         return int(ecu_addr)
 
     def get_doip_logical_gateway_address(self,
-                                         protocol: Optional[Union[str, "Protocol"]] = None
-                                        ) -> Optional[int]:
+                                         protocol: Union[str, "Protocol"] | None = None
+                                        ) -> int | None:
         """The logical gateway address for the diagnosis over IP transport protocol"""
 
         # retrieve CP_DoIPLogicalGatewayAddress from the
@@ -814,8 +809,8 @@ class HierarchyElement(DiagLayer):
         return int(result)
 
     def get_doip_logical_tester_address(self,
-                                        protocol: Optional[Union[str, "Protocol"]] = None
-                                       ) -> Optional[int]:
+                                        protocol: Union[str, "Protocol"] | None = None
+                                       ) -> int | None:
         """DoIp logical gateway address"""
 
         # retrieve CP_DoIPLogicalTesterAddress from the
@@ -832,8 +827,8 @@ class HierarchyElement(DiagLayer):
         return int(result)
 
     def get_doip_logical_functional_address(self,
-                                            protocol: Optional[Union[str, "Protocol"]] = None
-                                           ) -> Optional[int]:
+                                            protocol: Union[str, "Protocol"] | None = None
+                                           ) -> int | None:
         """The logical functional DoIP address of the ECU."""
 
         # retrieve CP_DoIPLogicalFunctionalAddress from the
@@ -853,8 +848,8 @@ class HierarchyElement(DiagLayer):
         return int(result)
 
     def get_doip_routing_activation_timeout(self,
-                                            protocol: Optional[Union[str, "Protocol"]] = None
-                                           ) -> Optional[float]:
+                                            protocol: Union[str, "Protocol"] | None = None
+                                           ) -> float | None:
         """The timout for the DoIP routing activation request in seconds"""
 
         # retrieve CP_DoIPRoutingActivationTimeout from the
@@ -871,8 +866,8 @@ class HierarchyElement(DiagLayer):
         return float(result) / 1e6
 
     def get_doip_routing_activation_type(self,
-                                         protocol: Optional[Union[str, "Protocol"]] = None
-                                        ) -> Optional[int]:
+                                         protocol: Union[str, "Protocol"] | None = None
+                                        ) -> int | None:
         """The DoIP routing activation type
 
         The number returned has the following meaning:
@@ -897,8 +892,7 @@ class HierarchyElement(DiagLayer):
         return int(result)
 
     def get_tester_present_time(self,
-                                protocol: Optional[Union[str,
-                                                         "Protocol"]] = None) -> Optional[float]:
+                                protocol: Union[str, "Protocol"] | None = None) -> float | None:
         """Timeout on inactivity in seconds.
 
         This is defined by the communication parameter "CP_TesterPresentTime".

odxtools/diaglayers/hierarchyelementraw.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any
 from xml.etree import ElementTree
 
 from ..comparaminstance import ComparamInstance
@@ -17,11 +17,11 @@ class HierarchyElementRaw(DiagLayerRaw):
     This class represents the data present in the XML, not the "logical" view.
     """
 
-    comparam_refs: List[ComparamInstance]
+    comparam_refs: list[ComparamInstance]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "HierarchyElementRaw":
+                doc_frags: list[OdxDocFragment]) -> "HierarchyElementRaw":
         # 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
@@ -37,7 +37,7 @@ class HierarchyElementRaw(DiagLayerRaw):
 
         return HierarchyElementRaw(comparam_refs=comparam_refs, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for comparam_ref in self.comparam_refs:

odxtools/diaglayers/protocol.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from ..comparamspec import ComparamSpec
@@ -29,11 +29,11 @@ class Protocol(HierarchyElement):
         return self.protocol_raw.comparam_spec
 
     @property
-    def prot_stack(self) -> Optional[ProtStack]:
+    def prot_stack(self) -> ProtStack | None:
         return self.protocol_raw.prot_stack
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Protocol":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Protocol":
         protocol_raw = ProtocolRaw.from_et(et_element, doc_frags)
 
         return Protocol(diag_layer_raw=protocol_raw)
@@ -46,7 +46,7 @@ class Protocol(HierarchyElement):
             "The raw diagnostic layer passed to Protocol "
             "must be a ProtocolRaw")
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         """Create a deep copy of the protocol layer
 
         Note that the copied diagnostic layer is not fully

odxtools/diaglayers/protocolraw.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 ..comparamspec import ComparamSpec
@@ -24,19 +24,19 @@ class ProtocolRaw(HierarchyElementRaw):
     """
 
     comparam_spec_ref: OdxLinkRef
-    prot_stack_snref: Optional[str]
-    parent_refs: List[ParentRef]
+    prot_stack_snref: str | None
+    parent_refs: list[ParentRef]
 
     @property
     def comparam_spec(self) -> ComparamSpec:
         return self._comparam_spec
 
     @property
-    def prot_stack(self) -> Optional[ProtStack]:
+    def prot_stack(self) -> ProtStack | None:
         return self._prot_stack
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProtocolRaw":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "ProtocolRaw":
         # 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
@@ -63,7 +63,7 @@ class ProtocolRaw(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 parent_ref in self.parent_refs:

odxtools/diagnostictroublecode.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 .element import IdentifiableElement
@@ -16,12 +16,12 @@ from .utils import dataclass_fields_asdict
 @dataclass
 class DiagnosticTroubleCode(IdentifiableElement):
     trouble_code: int
-    display_trouble_code: Optional[str]
+    display_trouble_code: str | None
     text: Text
-    level: Optional[int]
-    sdgs: List[SpecialDataGroup]
+    level: int | None
+    sdgs: list[SpecialDataGroup]
 
-    is_temporary_raw: Optional[bool]
+    is_temporary_raw: bool | None
 
     @property
     def is_temporary(self) -> bool:
@@ -29,7 +29,7 @@ class DiagnosticTroubleCode(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DiagnosticTroubleCode":
+                doc_frags: list[OdxDocFragment]) -> "DiagnosticTroubleCode":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         trouble_code = int(odxrequire(et_element.findtext("TROUBLE-CODE")))
@@ -53,8 +53,8 @@ class DiagnosticTroubleCode(IdentifiableElement):
             is_temporary_raw=is_temporary_raw,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result: Dict[OdxLinkId, Any] = {}
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result: dict[OdxLinkId, Any] = {}
 
         result[self.odx_id] = self
 

odxtools/diagservice.py

@@ -1,9 +1,9 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
+from .addressing import Addressing
 from .comparaminstance import ComparamInstance
 from .diagcomm import DiagComm
 from .exceptions import DecodeError, DecodeMismatch, odxassert, odxraise, odxrequire
@@ -12,112 +12,36 @@ from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValue, odxstr_to_bool
 from .parameters.parameter import Parameter
+from .posresponsesuppressible import PosResponseSuppressible
 from .request import Request
 from .response import Response
 from .snrefcontext import SnRefContext
+from .transmode import TransMode
 from .utils import dataclass_fields_asdict
 
 
-class Addressing(Enum):
-    FUNCTIONAL = "FUNCTIONAL"
-    PHYSICAL = "PHYSICAL"
-    FUNCTIONAL_OR_PHYSICAL = "FUNCTIONAL-OR-PHYSICAL"
-
-
-class TransMode(Enum):
-    SEND_ONLY = "SEND-ONLY"
-    RECEIVE_ONLY = "RECEIVE-ONLY"
-    SEND_AND_RECEIVE = "SEND-AND-RECEIVE"
-    SEND_OR_RECEIVE = "SEND-OR-RECEIVE"
-
-
-# note that the spec has a typo here: it calls the corresponding
-# XML tag POS-RESPONSE-SUPPRESSABLE...
-@dataclass
-class PosResponseSuppressible:
-    bit_mask: int
-
-    coded_const_snref: Optional[str]
-    coded_const_snpathref: Optional[str]
-
-    value_snref: Optional[str]
-    value_snpathref: Optional[str]
-
-    phys_const_snref: Optional[str]
-    phys_const_snpathref: Optional[str]
-
-    table_key_snref: Optional[str]
-    table_key_snpathref: Optional[str]
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "PosResponseSuppressible":
-
-        bit_mask = int(odxrequire(et_element.findtext("BIT-MASK")))
-
-        coded_const_snref = None
-        if (cc_snref_elem := et_element.find("CODED-CONST-SNREF")) is not None:
-            coded_const_snref = cc_snref_elem.attrib["SHORT-NAME"]
-        coded_const_snpathref = None
-        if (cc_snpathref_elem := et_element.find("CODED-CONST-SNPATHREF")) is not None:
-            coded_const_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
-
-        value_snref = None
-        if (cc_snref_elem := et_element.find("VALUE-SNREF")) is not None:
-            value_snref = cc_snref_elem.attrib["SHORT-NAME"]
-        value_snpathref = None
-        if (cc_snpathref_elem := et_element.find("VALUE-SNPATHREF")) is not None:
-            value_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
-
-        phys_const_snref = None
-        if (cc_snref_elem := et_element.find("PHYS-CONST-SNREF")) is not None:
-            phys_const_snref = cc_snref_elem.attrib["SHORT-NAME"]
-        phys_const_snpathref = None
-        if (cc_snpathref_elem := et_element.find("PHYS-CONST-SNPATHREF")) is not None:
-            phys_const_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
-
-        table_key_snref = None
-        if (cc_snref_elem := et_element.find("TABLE-KEY-SNREF")) is not None:
-            table_key_snref = cc_snref_elem.attrib["SHORT-NAME"]
-        table_key_snpathref = None
-        if (cc_snpathref_elem := et_element.find("TABLE-KEY-SNPATHREF")) is not None:
-            table_key_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
-
-        return PosResponseSuppressible(
-            bit_mask=bit_mask,
-            coded_const_snref=coded_const_snref,
-            coded_const_snpathref=coded_const_snpathref,
-            value_snref=value_snref,
-            value_snpathref=value_snpathref,
-            phys_const_snref=phys_const_snref,
-            phys_const_snpathref=phys_const_snpathref,
-            table_key_snref=table_key_snref,
-            table_key_snpathref=table_key_snpathref,
-        )
-
-
 @dataclass
 class DiagService(DiagComm):
     """Representation of a diagnostic service description.
     """
 
-    comparam_refs: List[ComparamInstance]
+    comparam_refs: list[ComparamInstance]
     request_ref: OdxLinkRef
-    pos_response_refs: List[OdxLinkRef]
-    neg_response_refs: List[OdxLinkRef]
-    pos_response_suppressible: Optional[PosResponseSuppressible]
+    pos_response_refs: list[OdxLinkRef]
+    neg_response_refs: list[OdxLinkRef]
+    pos_response_suppressible: PosResponseSuppressible | None
 
-    is_cyclic_raw: Optional[bool]
-    is_multiple_raw: Optional[bool]
-    addressing_raw: Optional[Addressing]
-    transmission_mode_raw: Optional[TransMode]
+    is_cyclic_raw: bool | None
+    is_multiple_raw: bool | None
+    addressing_raw: Addressing | None
+    transmission_mode_raw: TransMode | None
 
     @property
     def comparams(self) -> NamedItemList[ComparamInstance]:
         return self._comparams
 
     @property
-    def request(self) -> Optional[Request]:
+    def request(self) -> Request | None:
         return self._request
 
     @property
@@ -145,14 +69,14 @@ class DiagService(DiagComm):
         return self.transmission_mode_raw or TransMode.SEND_AND_RECEIVE
 
     @property
-    def free_parameters(self) -> List[Parameter]:
+    def free_parameters(self) -> list[Parameter]:
         """Return the list of parameters which can be freely specified by
         the user when encoding the service's request.
         """
         return self.request.free_parameters if self.request is not None else []
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagService":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DiagService":
 
         kwargs = dataclass_fields_asdict(DiagComm.from_et(et_element, doc_frags))
 
@@ -180,7 +104,7 @@ class DiagService(DiagComm):
         is_cyclic_raw = odxstr_to_bool(et_element.get("IS-CYCLIC"))
         is_multiple_raw = odxstr_to_bool(et_element.get("IS-MULTIPLE"))
 
-        addressing_raw: Optional[Addressing] = None
+        addressing_raw: Addressing | None = None
         if (addressing_raw_str := et_element.get("ADDRESSING")) is not None:
             try:
                 addressing_raw = Addressing(addressing_raw_str)
@@ -188,7 +112,7 @@ class DiagService(DiagComm):
                 addressing_raw = cast(Addressing, None)
                 odxraise(f"Encountered unknown addressing type '{addressing_raw_str}'")
 
-        transmission_mode_raw: Optional[TransMode] = None
+        transmission_mode_raw: TransMode | None = None
         if (transmission_mode_raw_str := et_element.get("TRANSMISSION-MODE")) is not None:
             try:
                 transmission_mode_raw = TransMode(transmission_mode_raw_str)
@@ -208,7 +132,7 @@ class DiagService(DiagComm):
             transmission_mode_raw=transmission_mode_raw,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for cpr in self.comparam_refs:
@@ -256,20 +180,20 @@ class DiagService(DiagComm):
 
     def decode_message(self, raw_message: bytes) -> Message:
         request_prefix = b''
-        candidate_coding_objects: List[Union[Request, Response]] = [
+        candidate_coding_objects: list[Request | Response] = [
             *self.positive_responses, *self.negative_responses
         ]
         if self.request is not None:
             request_prefix = self.request.coded_const_prefix()
             candidate_coding_objects.append(self.request)
 
-        coding_objects: List[Union[Request, Response]] = []
+        coding_objects: list[Request | Response] = []
         for candidate_coding_object in candidate_coding_objects:
             prefix = candidate_coding_object.coded_const_prefix(request_prefix=request_prefix)
             if len(raw_message) >= len(prefix) and prefix == raw_message[:len(prefix)]:
                 coding_objects.append(candidate_coding_object)
 
-        result_list: List[Message] = []
+        result_list: list[Message] = []
         for coding_object in coding_objects:
             try:
                 result_list.append(