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

odxtools/environmentdatadescription.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 typing_extensions import override
@@ -35,18 +35,18 @@ class EnvironmentDataDescription(ComplexDop):
 
     """
 
-    param_snref: Optional[str]
-    param_snpathref: Optional[str]
+    param_snref: str | None
+    param_snpathref: str | None
 
     # in ODX 2.0.0, ENV-DATAS seems to be a mandatory
     # sub-element of ENV-DATA-DESC, in ODX 2.2 it is not
     # present
     env_datas: NamedItemList[EnvironmentData]
-    env_data_refs: List[OdxLinkRef]
+    env_data_refs: list[OdxLinkRef]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "EnvironmentDataDescription":
+                doc_frags: list[OdxDocFragment]) -> "EnvironmentDataDescription":
         """Reads Environment Data Description from Diag Layer."""
         kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
 
@@ -78,7 +78,7 @@ class EnvironmentDataDescription(ComplexDop):
             env_data_refs=env_data_refs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
         if not self.env_data_refs:
@@ -105,7 +105,7 @@ class EnvironmentDataDescription(ComplexDop):
                 ed._resolve_snrefs(context)
 
     @override
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         """Convert a physical value into bytes and emplace them into a PDU.
         """
@@ -118,7 +118,7 @@ class EnvironmentDataDescription(ComplexDop):
                      "descriptions via SNPATHREF is not supported yet")
             return None
 
-        numerical_dtc_value: Optional[ParameterValue] = None
+        numerical_dtc_value: ParameterValue | None = None
         for prev_param, prev_param_value in reversed(encode_state.journal):
             if prev_param.short_name == self.param_snref:
                 numerical_dtc_value = self._get_numerical_dtc_from_parameter(
@@ -165,7 +165,7 @@ class EnvironmentDataDescription(ComplexDop):
                      "descriptions via SNPATHREF is not supported yet")
             return None
 
-        numerical_dtc_value: Optional[ParameterValue] = None
+        numerical_dtc_value: ParameterValue | None = None
         for prev_param, prev_param_value in reversed(decode_state.journal):
             if prev_param.short_name == self.param_snref:
                 numerical_dtc_value = self._get_numerical_dtc_from_parameter(
@@ -204,10 +204,10 @@ class EnvironmentDataDescription(ComplexDop):
         return result
 
     def _get_numerical_dtc_from_parameter(self, param: Parameter,
-                                          param_value: Optional[ParameterValue]) -> int:
+                                          param_value: ParameterValue | None) -> int:
         if isinstance(param, ParameterWithDOP):
             dop = param.dop
-            if not isinstance(dop, (DataObjectProperty, DtcDop)):
+            if not isinstance(dop, DataObjectProperty | DtcDop):
                 odxraise(f"The DOP of the parameter referenced by environment data descriptions "
                          f"must use either be DataObjectProperty or a DtcDop (encountered "
                          f"{type(param).__name__} for parameter '{param.short_name}' "

odxtools/exceptions.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from typing import TYPE_CHECKING, NoReturn, Optional, Type, TypeVar
+from typing import TYPE_CHECKING, NoReturn, TypeVar
 
 from .globals import logger
 
@@ -37,7 +37,7 @@ class OdxWarning(Warning):
 strict_mode = True
 
 
-def odxraise(message: Optional[str] = None, error_type: Type[Exception] = OdxError) -> NoReturn:
+def odxraise(message: str | None = None, error_type: type[Exception] = OdxError) -> NoReturn:
     """
     Raise an exception but only if in strict mode.
 
@@ -53,8 +53,8 @@ def odxraise(message: Optional[str] = None, error_type: Type[Exception] = OdxErr
 
 
 def odxassert(condition: bool,
-              message: Optional[str] = None,
-              error_type: Type[Exception] = OdxError) -> None:
+              message: str | None = None,
+              error_type: type[Exception] = OdxError) -> None:
     """
     This method works similar as the build-in `assert` statement
 
@@ -72,7 +72,7 @@ def odxassert(condition: bool,
 T = TypeVar("T")
 
 
-def odxrequire(obj: Optional[T], message: Optional[str] = None) -> T:
+def odxrequire(obj: T | None, message: str | None = None) -> T:
     """This function ensures that an object required by the ODX
     specification is actually present.
 

odxtools/externalaccessmethod.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
@@ -15,7 +14,7 @@ class ExternalAccessMethod(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ExternalAccessMethod":
+                doc_frags: list[OdxDocFragment]) -> "ExternalAccessMethod":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         method = odxrequire(et_element.findtext("METHOD"))

odxtools/externaldoc.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
@@ -8,12 +8,12 @@ from .odxlink import OdxDocFragment
 
 @dataclass
 class ExternalDoc:
-    description: Optional[str]
+    description: str | None
     href: str
 
     @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element],
-                doc_frags: List[OdxDocFragment]) -> Optional["ExternalDoc"]:
+    def from_et(et_element: ElementTree.Element | None,
+                doc_frags: list[OdxDocFragment]) -> Optional["ExternalDoc"]:
         if et_element is None:
             return None
 

odxtools/field.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
@@ -15,11 +14,11 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class Field(ComplexDop):
-    structure_ref: Optional[OdxLinkRef]
-    structure_snref: Optional[str]
-    env_data_desc_ref: Optional[OdxLinkRef]
-    env_data_desc_snref: Optional[str]
-    is_visible_raw: Optional[bool]
+    structure_ref: OdxLinkRef | None
+    structure_snref: str | None
+    env_data_desc_ref: OdxLinkRef | None
+    env_data_desc_snref: str | None
+    is_visible_raw: bool | None
 
     @property
     def structure(self) -> BasicStructure:
@@ -31,7 +30,7 @@ class Field(ComplexDop):
         return self.is_visible_raw in (None, True)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Field":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Field":
         kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
 
         structure_ref = OdxLinkRef.from_et(et_element.find("BASIC-STRUCTURE-REF"), doc_frags)
@@ -54,8 +53,8 @@ class Field(ComplexDop):
             **kwargs)
 
     def __post_init__(self) -> None:
-        self._structure: Optional[BasicStructure] = None
-        self._env_data_desc: Optional[EnvironmentDataDescription] = None
+        self._structure: BasicStructure | None = None
+        self._env_data_desc: EnvironmentDataDescription | None = None
         num_struct_refs = 0 if self.structure_ref is None else 1
         num_struct_refs += 0 if self.structure_snref is None else 1
 
@@ -87,5 +86,5 @@ class Field(ComplexDop):
             self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddds.env_data_descs,
                                                 EnvironmentDataDescription)
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return None

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

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .diagnostictroublecode import DiagnosticTroubleCode
@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 
 @dataclass
 class LinkedDtcDop:
-    not_inherited_dtc_snrefs: List[str]
+    not_inherited_dtc_snrefs: list[str]
     dtc_dop_ref: OdxLinkRef
 
     @property
@@ -31,7 +31,7 @@ class LinkedDtcDop:
         return self._dtc_dop.short_name
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "LinkedDtcDop":
+    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/"
@@ -43,7 +43,7 @@ class LinkedDtcDop:
         return LinkedDtcDop(
             not_inherited_dtc_snrefs=not_inherited_dtc_snrefs, dtc_dop_ref=dtc_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/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,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, cast
+from typing import cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -18,7 +18,7 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class MinMaxLengthType(DiagCodedType):
-    max_length: Optional[int]
+    max_length: int | None
     min_length: int
     termination: Termination
 
@@ -29,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
@@ -77,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: