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

odxtools/functionalclass.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
@@ -16,11 +16,11 @@ class FunctionalClass(IdentifiableElement):
     Corresponds to FUNCT-CLASS.
     """
 
-    admin_data: Optional[AdminData]
+    admin_data: AdminData | None
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "FunctionalClass":
+                doc_frags: list[OdxDocFragment]) -> "FunctionalClass":
 
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
@@ -28,7 +28,7 @@ class FunctionalClass(IdentifiableElement):
 
         return FunctionalClass(admin_data=admin_data, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/inputparam.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 deprecation import deprecated
@@ -15,10 +15,10 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class InputParam(NamedElement):
-    physical_default_value: Optional[str]
+    physical_default_value: str | None
     dop_base_ref: OdxLinkRef
-    oid: Optional[str]
-    semantic: Optional[str]
+    oid: str | None
+    semantic: str | None
 
     @property
     def dop(self) -> DopBase:
@@ -30,7 +30,7 @@ class InputParam(NamedElement):
         return self._dop
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "InputParam":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "InputParam":
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
         physical_default_value = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
@@ -46,7 +46,7 @@ class InputParam(NamedElement):
             semantic=semantic,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/internalconstr.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .compumethods.limit import Limit
@@ -16,14 +15,14 @@ class InternalConstr:
 
     # TODO: Enforce the internal and physical constraints.
 
-    lower_limit: Optional[Limit]
-    upper_limit: Optional[Limit]
-    scale_constrs: List[ScaleConstr]
+    lower_limit: Limit | None
+    upper_limit: Limit | None
+    scale_constrs: list[ScaleConstr]
 
     value_type: DataType
 
     @staticmethod
-    def constr_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def constr_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                        value_type: DataType) -> "InternalConstr":
 
         lower_limit = Limit.limit_from_et(

odxtools/isotp_state_machine.py

@@ -4,9 +4,10 @@
 import asyncio
 import re
 import sys
+from collections.abc import AsyncGenerator, Iterable
 from enum import IntEnum
 from io import TextIOBase
-from typing import AsyncGenerator, Iterable, List, Optional, TextIO, Tuple, Union
+from typing import TextIO
 
 import bitstruct
 import can
@@ -32,7 +33,7 @@ class IsoTpStateMachine:
     can_fd_log_frame_re = re.compile(
         "\\([0-9.]*\\) *([a-zA-Z0-9_-]*) ([0-9A-Fa-f]+)##[0-9A-Fa-f]([0-9A-Fa-f]+)")
 
-    def __init__(self, can_rx_ids: Union[int, List[int]]):
+    def __init__(self, can_rx_ids: int | list[int]):
         if isinstance(can_rx_ids, int):
             can_rx_ids = [can_rx_ids]
 
@@ -40,10 +41,10 @@ class IsoTpStateMachine:
         assert isinstance(self._can_rx_ids, list)
 
         self._telegram_specified_len = [0] * len(can_rx_ids)
-        self._telegram_data: List[Optional[bytearray]] = [None] * len(can_rx_ids)
+        self._telegram_data: list[bytearray | None] = [None] * len(can_rx_ids)
         self._telegram_last_rx_fragment_idx = [0] * len(can_rx_ids)
 
-    def decode_rx_frame(self, rx_id: int, data: bytes) -> Iterable[Tuple[int, bytes]]:
+    def decode_rx_frame(self, rx_id: int, data: bytes) -> Iterable[tuple[int, bytes]]:
         """Handle the ISO-TP state transitions caused by a CAN frame.
 
         E.g., add some data to a telegram, etc. Returns a generator of
@@ -114,8 +115,8 @@ class IsoTpStateMachine:
         else:
             self.on_frame_type_error(telegram_idx, frame_type)
 
-    async def read_telegrams(self, bus: Union[can.BusABC,
-                                              TextIO]) -> AsyncGenerator[Tuple[int, bytes], None]:
+    async def read_telegrams(self,
+                             bus: can.BusABC | TextIO) -> AsyncGenerator[tuple[int, bytes], None]:
         """This is equivalent to the :py:meth:`file.readlines()` method, but
         it yields ISO-TP telegrams instead of lines.
 
@@ -184,7 +185,7 @@ class IsoTpStateMachine:
         """
         return self._can_rx_ids[telegram_idx]
 
-    def telegram_data(self, telegram_idx: int) -> Optional[bytes]:
+    def telegram_data(self, telegram_idx: int) -> bytes | None:
         """Given a Telegram index, returns the data received for this telegram
         so far.
 
@@ -233,8 +234,8 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
     def __init__(self,
                  can_bus: can.BusABC,
-                 can_rx_ids: List[int],
-                 can_tx_ids: List[int],
+                 can_rx_ids: list[int],
+                 can_tx_ids: list[int],
                  padding_size: int = 0,
                  padding_value: int = 0xAA):
         self._can_bus = can_bus
@@ -251,8 +252,8 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
         assert len(self._can_rx_ids) == len(self._can_tx_ids)
         assert set(self._can_rx_ids).isdisjoint(set(self._can_tx_ids))  # correct?
 
-        self._block_size: List[Optional[int]] = [None] * len(self._can_rx_ids)
-        self._frames_received: List[Optional[int]] = [None] * len(self._can_rx_ids)
+        self._block_size: list[int | None] = [None] * len(self._can_rx_ids)
+        self._frames_received: list[int | None] = [None] * len(self._can_rx_ids)
 
     def can_tx_id(self, telegram_idx: int) -> int:
         """Given a Telegram index, returns the CAN ID for sending data.

odxtools/leadinglengthinfotype.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -30,7 +29,7 @@ class LeadingLengthInfoType(DiagCodedType):
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "LeadingLengthInfoType":
+                doc_frags: list[OdxDocFragment]) -> "LeadingLengthInfoType":
         kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
 
         bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
@@ -53,7 +52,7 @@ class LeadingLengthInfoType(DiagCodedType):
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 
-        if not isinstance(internal_value, (str, bytes)):
+        if not isinstance(internal_value, str | bytes):
             odxraise(
                 f"LEADING-LENGTH-INFO types can only be used for strings and byte fields, "
                 f"not {type(internal_value).__name__}", EncodeError)

odxtools/library.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 .element import IdentifiableElement
@@ -19,17 +19,17 @@ class Library(IdentifiableElement):
     """
 
     code_file: str
-    encryption: Optional[str]
+    encryption: str | None
     syntax: str
     revision: str
-    entrypoint: Optional[str]
+    entrypoint: str | None
 
     @property
     def code(self) -> bytes:
         return self._code
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Library":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Library":
 
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
@@ -47,7 +47,7 @@ class Library(IdentifiableElement):
             entrypoint=entrypoint,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/linkeddtcdop.py

@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+from xml.etree import ElementTree
+
+from .diagnostictroublecode import DiagnosticTroubleCode
+from .exceptions import odxrequire
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+
+if TYPE_CHECKING:
+    from .dtcdop import DtcDop
+
+
+@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:
+        if TYPE_CHECKING:
+            self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref, DtcDop)
+        else:
+            self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref)
+
+    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)

odxtools/loadfile.py

@@ -1,19 +1,18 @@
 # SPDX-License-Identifier: MIT
 import os
 from pathlib import Path
-from typing import Union
 
 from .database import Database
 
 
-def load_pdx_file(pdx_file: Union[str, Path]) -> Database:
+def load_pdx_file(pdx_file: str | Path) -> Database:
     db = Database()
     db.add_pdx_file(str(pdx_file))
     db.refresh()
     return db
 
 
-def load_odx_d_file(odx_d_file_name: Union[str, Path]) -> Database:
+def load_odx_d_file(odx_d_file_name: str | Path) -> Database:
     db = Database()
     db.add_odx_file(str(odx_d_file_name))
     db.refresh()
@@ -21,7 +20,7 @@ def load_odx_d_file(odx_d_file_name: Union[str, Path]) -> Database:
     return db
 
 
-def load_file(file_name: Union[str, Path]) -> Database:
+def load_file(file_name: str | Path) -> Database:
     if str(file_name).lower().endswith(".pdx"):
         return load_pdx_file(str(file_name))
     elif str(file_name).lower().endswith(".odx-d"):
@@ -30,7 +29,7 @@ def load_file(file_name: Union[str, Path]) -> Database:
         raise RuntimeError(f"Could not guess the file format of file '{file_name}'!")
 
 
-def load_files(*file_names: Union[str, Path]) -> Database:
+def load_files(*file_names: str | Path) -> Database:
     db = Database()
     for file_name in file_names:
         p = Path(file_name)
@@ -45,7 +44,7 @@ def load_files(*file_names: Union[str, Path]) -> Database:
     return db
 
 
-def load_directory(dir_name: Union[str, Path]) -> Database:
+def load_directory(dir_name: str | Path) -> Database:
     db = Database()
     for file_name in os.listdir(str(dir_name)):
         p = Path(dir_name) / file_name

odxtools/matchingbasevariantparameter.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .matchingparameter import MatchingParameter
@@ -18,7 +17,7 @@ class MatchingBaseVariantParameter(MatchingParameter):
     additional subtag `USE-PHYSICAL-ADDRESSING`.
     """
 
-    use_physical_addressing_raw: Optional[bool]
+    use_physical_addressing_raw: bool | None
 
     @property
     def use_physical_addressing(self) -> bool:
@@ -26,7 +25,7 @@ class MatchingBaseVariantParameter(MatchingParameter):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MatchingBaseVariantParameter":
+                doc_frags: list[OdxDocFragment]) -> "MatchingBaseVariantParameter":
 
         kwargs = dataclass_fields_asdict(MatchingParameter.from_et(et_element, doc_frags))
 

odxtools/matchingparameter.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 .diaglayers.diaglayer import DiagLayer
@@ -34,12 +34,12 @@ class MatchingParameter:
     # or negative response. What it probably actually wants to say is
     # that any response that can possibly be received shall exhibit
     # the referenced parameter.
-    out_param_if_snref: Optional[str]
-    out_param_if_snpathref: Optional[str]
+    out_param_if_snref: str | None
+    out_param_if_snpathref: str | None
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MatchingParameter":
+                doc_frags: list[OdxDocFragment]) -> "MatchingParameter":
 
         expected_value = odxrequire(et_element.findtext("EXPECTED-VALUE"))
         diag_comm_snref = odxrequire(
@@ -61,7 +61,7 @@ class MatchingParameter:
             out_param_if_snpathref=out_param_if_snpathref,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -93,7 +93,7 @@ class MatchingParameter:
 
         return self.__matches(param_dict, snpath_chunks)
 
-    def __matches(self, param_dict: ParameterValue, snpath_chunks: List[str]) -> bool:
+    def __matches(self, param_dict: ParameterValue, snpath_chunks: list[str]) -> bool:
         if len(snpath_chunks) == 0:
             parameter_value = param_dict
             if isinstance(parameter_value, dict):
@@ -105,7 +105,7 @@ class MatchingParameter:
                 # floating point
                 return abs(float(self.expected_value) - parameter_value) < 1e-8
             elif isinstance(parameter_value, BytesTypes):
-                return parameter_value.hex().upper() == self.expected_value.upper()
+                return bytes(parameter_value).hex().upper() == self.expected_value.upper()
             elif isinstance(parameter_value, DiagnosticTroubleCode):
                 # TODO: what happens if non-numerical DTCs like
                 # "U123456" are specified? Is specifying DTCs even

odxtools/minmaxlengthtype.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
-from typing import List, Optional, cast
+from typing import cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -13,18 +12,13 @@ from .encoding import get_string_encoding
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, BytesTypes, DataType
+from .termination import Termination
 from .utils import dataclass_fields_asdict
 
 
-class Termination(Enum):
-    END_OF_PDU = "END-OF-PDU"
-    ZERO = "ZERO"
-    HEX_FF = "HEX-FF"
-
-
 @dataclass
 class MinMaxLengthType(DiagCodedType):
-    max_length: Optional[int]
+    max_length: int | None
     min_length: int
     termination: Termination
 
@@ -35,7 +29,7 @@ class MinMaxLengthType(DiagCodedType):
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MinMaxLengthType":
+                doc_frags: list[OdxDocFragment]) -> "MinMaxLengthType":
         kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
 
         max_length = None
@@ -83,7 +77,7 @@ class MinMaxLengthType(DiagCodedType):
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 
-        if not isinstance(internal_value, (str, BytesTypes)):
+        if not isinstance(internal_value, str | BytesTypes):
             odxraise("MinMaxLengthType is currently only implemented for strings and byte arrays",
                      EncodeError)
 

odxtools/modification.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 .exceptions import odxrequire
@@ -11,16 +11,16 @@ from .snrefcontext import SnRefContext
 @dataclass
 class Modification:
     change: str
-    reason: Optional[str]
+    reason: str | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Modification":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Modification":
         change = odxrequire(et_element.findtext("CHANGE"))
         reason = et_element.findtext("REASON")
 
         return Modification(change=change, reason=reason)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/multiplexer.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple, Union, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -30,9 +30,9 @@ class Multiplexer(ComplexDop):
 
     byte_position: int
     switch_key: MultiplexerSwitchKey
-    default_case: Optional[MultiplexerDefaultCase]
+    default_case: MultiplexerDefaultCase | None
     cases: NamedItemList[MultiplexerCase]
-    is_visible_raw: Optional[bool]
+    is_visible_raw: bool | None
 
     @property
     def is_visible(self) -> bool:
@@ -40,7 +40,7 @@ class Multiplexer(ComplexDop):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Multiplexer":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Multiplexer":
         """Reads a Multiplexer from Diag Layer."""
         kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
 
@@ -66,7 +66,7 @@ class Multiplexer(ComplexDop):
             **kwargs)
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
         odxlinks.update(self.switch_key._build_odxlinks())
@@ -98,7 +98,7 @@ class Multiplexer(ComplexDop):
         for mux_case in self.cases:
             mux_case._resolve_snrefs(context)
 
-    def _get_case_limits(self, case: MultiplexerCase) -> Tuple[AtomicOdxType, AtomicOdxType]:
+    def _get_case_limits(self, case: MultiplexerCase) -> tuple[AtomicOdxType, AtomicOdxType]:
         key_type = self.switch_key.dop.physical_type.base_data_type
         lower_limit = key_type.make_from(case.lower_limit.value)
         upper_limit = key_type.make_from(case.upper_limit.value)
@@ -118,7 +118,7 @@ class Multiplexer(ComplexDop):
         orig_origin = encode_state.origin_byte_position
         encode_state.origin_byte_position = encode_state.cursor_byte_position
 
-        if isinstance(physical_value, (list, tuple)) and len(physical_value) == 2:
+        if isinstance(physical_value, list | tuple) and len(physical_value) == 2:
             case_spec, case_value = physical_value
         elif isinstance(physical_value, dict) and len(physical_value) == 1:
             case_spec, case_value = next(iter(physical_value.items()))
@@ -127,8 +127,8 @@ class Multiplexer(ComplexDop):
                 f"Values of multiplexer parameters must be defined as a "
                 f"(case_name, content_value) tuple instead of as '{physical_value!r}'")
 
-        mux_case: Union[MultiplexerCase, MultiplexerDefaultCase]
-        applicable_cases: List[Union[MultiplexerCase, MultiplexerDefaultCase]]
+        mux_case: MultiplexerCase | MultiplexerDefaultCase
+        applicable_cases: list[MultiplexerCase | MultiplexerDefaultCase]
 
         if isinstance(case_spec, str):
             applicable_cases = [x for x in self.cases if x.short_name == case_spec]
@@ -147,7 +147,7 @@ class Multiplexer(ComplexDop):
         elif isinstance(case_spec, int):
             applicable_cases = []
             for x in self.cases:
-                lower, upper = cast(Tuple[int, int], self._get_case_limits(x))
+                lower, upper = cast(tuple[int, int], self._get_case_limits(x))
                 if lower <= case_spec and case_spec <= upper:
                     applicable_cases.append(x)
 
@@ -208,7 +208,7 @@ class Multiplexer(ComplexDop):
         # relatively to the byte position of the MUX."
         decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
 
-        applicable_case: Optional[Union[MultiplexerCase, MultiplexerDefaultCase]] = None
+        applicable_case: MultiplexerCase | MultiplexerDefaultCase | None = None
         for mux_case in self.cases:
             lower, upper = self._get_case_limits(mux_case)
             if lower <= key_value and key_value <= upper:  # type: ignore[operator]

odxtools/multiplexercase.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 .compumethods.limit import Limit
@@ -17,18 +17,18 @@ from .utils import dataclass_fields_asdict
 class MultiplexerCase(NamedElement):
     """This class represents a case which represents a range of keys of a multiplexer."""
 
-    structure_ref: Optional[OdxLinkRef]
-    structure_snref: Optional[str]
+    structure_ref: OdxLinkRef | None
+    structure_snref: str | None
     lower_limit: Limit
     upper_limit: Limit
 
     @property
-    def structure(self) -> Optional[Structure]:
+    def structure(self) -> Structure | None:
         return self._structure
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MultiplexerCase":
+                doc_frags: list[OdxDocFragment]) -> "MultiplexerCase":
         """Reads a case for a Multiplexer."""
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
         structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), doc_frags)
@@ -54,7 +54,7 @@ class MultiplexerCase(NamedElement):
             upper_limit=upper_limit,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/multiplexerdefaultcase.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 NamedElement
@@ -14,16 +14,16 @@ from .utils import dataclass_fields_asdict
 @dataclass
 class MultiplexerDefaultCase(NamedElement):
     """This class represents a Default Case, which is selected when there are no cases defined in the Multiplexer."""
-    structure_ref: Optional[OdxLinkRef]
-    structure_snref: Optional[str]
+    structure_ref: OdxLinkRef | None
+    structure_snref: str | None
 
     @property
-    def structure(self) -> Optional[Structure]:
+    def structure(self) -> Structure | None:
         return self._structure
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MultiplexerDefaultCase":
+                doc_frags: list[OdxDocFragment]) -> "MultiplexerDefaultCase":
         """Reads a default case for a multiplexer."""
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
@@ -35,7 +35,7 @@ class MultiplexerDefaultCase(NamedElement):
         return MultiplexerDefaultCase(
             structure_ref=structure_ref, structure_snref=structure_snref, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None: