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

odxtools/multiplexerswitchkey.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from .dataobjectproperty import DataObjectProperty
@@ -15,7 +15,7 @@ class MultiplexerSwitchKey:
     The object that determines the case to be used by a multiplexer
     """
     byte_position: int
-    bit_position: Optional[int]
+    bit_position: int | None
     dop_ref: OdxLinkRef
 
     @property
@@ -24,7 +24,7 @@ class MultiplexerSwitchKey:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MultiplexerSwitchKey":
+                doc_frags: list[OdxDocFragment]) -> "MultiplexerSwitchKey":
         byte_position = int(odxrequire(et_element.findtext("BYTE-POSITION")))
         bit_position_str = et_element.findtext("BIT-POSITION")
         bit_position = int(bit_position_str) if bit_position_str is not None else None
@@ -36,7 +36,7 @@ class MultiplexerSwitchKey:
             dop_ref=dop_ref,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/nameditemlist.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MIT
 import abc
 import typing
+from collections.abc import Collection, Iterable
 from copy import deepcopy
 from keyword import iskeyword
-from typing import (Any, Collection, Dict, Iterable, List, Optional, SupportsIndex, Tuple, TypeVar,
-                    Union, cast, overload, runtime_checkable)
+from typing import Any, SupportsIndex, TypeVar, cast, overload, runtime_checkable
 
 from .exceptions import odxraise
 
@@ -21,7 +21,7 @@ T = TypeVar("T")
 TNamed = TypeVar("TNamed", bound=OdxNamed)
 
 
-class ItemAttributeList(List[T]):
+class ItemAttributeList(list[T]):
     """A list that provides direct access to its items as named attributes.
 
     This is a hybrid between a list and a user-defined object: One can
@@ -35,8 +35,8 @@ class ItemAttributeList(List[T]):
     returned by the item-to-name function are valid identifiers in python.
     """
 
-    def __init__(self, input_list: Optional[Iterable[T]] = None) -> None:
-        self._item_dict: Dict[str, T] = {}
+    def __init__(self, input_list: Iterable[T] | None = None) -> None:
+        self._item_dict: dict[str, T] = {}
 
         if input_list is not None:
             for item in input_list:
@@ -121,10 +121,10 @@ class ItemAttributeList(List[T]):
     def values(self) -> Collection[T]:
         return self._item_dict.values()
 
-    def items(self) -> Collection[Tuple[str, T]]:
+    def items(self) -> Collection[tuple[str, T]]:
         return self._item_dict.items()
 
-    def __dir__(self) -> Dict[str, Any]:
+    def __dir__(self) -> dict[str, Any]:
         result = dict(self.__dict__)
         result.update(self._item_dict)
         return result
@@ -138,11 +138,11 @@ class ItemAttributeList(List[T]):
         ...
 
     @overload
-    def __getitem__(self, key: slice) -> List[T]:
+    def __getitem__(self, key: slice) -> list[T]:
         ...
 
-    def __getitem__(self, key: Union[SupportsIndex, str, slice]) -> Union[T, List[T]]:
-        if isinstance(key, (SupportsIndex, slice)):
+    def __getitem__(self, key: SupportsIndex | str | slice) -> T | list[T]:
+        if isinstance(key, SupportsIndex | slice):
             return super().__getitem__(key)
         else:
             return self._item_dict[key]
@@ -153,13 +153,13 @@ class ItemAttributeList(List[T]):
 
         return self._item_dict[key]
 
-    def get(self, key: Union[int, str], default: Optional[T] = None) -> Optional[T]:
+    def get(self, key: int | str, default: T | None = None) -> T | None:
         if isinstance(key, int):
             if 0 <= key and key < len(self):
                 return super().__getitem__(key)
             return default
         else:
-            return cast(Optional[T], self._item_dict.get(key, default))
+            return cast(T | None, self._item_dict.get(key, default))
 
     def __eq__(self, other: object) -> bool:
         """
@@ -179,7 +179,7 @@ class ItemAttributeList(List[T]):
     def __copy__(self) -> Any:
         return self.__class__(list(self))
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         cls = self.__class__
         result = cls.__new__(cls)
         memo[id(self)] = result
@@ -189,7 +189,7 @@ class ItemAttributeList(List[T]):
 
         return result
 
-    def __reduce__(self) -> Tuple[Any, ...]:
+    def __reduce__(self) -> tuple[Any, ...]:
         """Support for Python's pickle protocol.
         This method ensures that the object can be reconstructed with its current state,
         using its class and the list of items it contains.

odxtools/negoutputparam.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 .dopbase import DopBase
@@ -22,14 +22,14 @@ class NegOutputParam(NamedElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "NegOutputParam":
+                doc_frags: list[OdxDocFragment]) -> "NegOutputParam":
 
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
         dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), doc_frags))
 
         return NegOutputParam(dop_base_ref=dop_base_ref, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/obd.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from enum import IntEnum
-from typing import Optional
 
 
 class SID(IntEnum):
@@ -47,7 +46,7 @@ _sid_to_name = {
 }
 
 
-def sid_to_name(sid: int) -> Optional[str]:
+def sid_to_name(sid: int) -> str | None:
     if sid in _sid_to_name:
         return _sid_to_name[sid]
 

odxtools/odxcategory.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -21,17 +21,17 @@ if TYPE_CHECKING:
 class OdxCategory(IdentifiableElement):
     """This is the base class for all top-level container classes in ODX"""
 
-    admin_data: Optional[AdminData]
+    admin_data: AdminData | None
     company_datas: NamedItemList[CompanyData]
-    sdgs: List[SpecialDataGroup]
+    sdgs: list[SpecialDataGroup]
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "OdxCategory":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "OdxCategory":
         raise Exception("Calling `._from_et()` is not allowed for OdxCategory. "
                         "Use `OdxCategory.category_from_et()`!")
 
     @staticmethod
-    def category_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def category_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                          doc_type: DocType) -> "OdxCategory":
 
         short_name = odxrequire(et_element.findtext("SHORT-NAME"))
@@ -51,7 +51,7 @@ class OdxCategory(IdentifiableElement):
 
         return OdxCategory(admin_data=admin_data, company_datas=company_datas, sdgs=sdgs, **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/odxlink.py

@@ -1,8 +1,9 @@
 # SPDX-License-Identifier: MIT
 import warnings
+from collections.abc import Iterable
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, Iterable, List, Optional, Type, TypeVar, overload
+from typing import Any, Optional, TypeVar, overload
 from xml.etree import ElementTree
 
 from .exceptions import OdxWarning, odxassert, odxraise, odxrequire
@@ -44,7 +45,7 @@ class OdxLinkId:
 
     #: The name and type of the document fragment to which the
     #: `local_id` is relative to
-    doc_fragments: List[OdxDocFragment]
+    doc_fragments: list[OdxDocFragment]
 
     def __hash__(self) -> int:
         # we do not hash about the document fragment here, because
@@ -68,7 +69,7 @@ class OdxLinkId:
 
     @staticmethod
     def from_et(et: ElementTree.Element,
-                doc_fragments: List[OdxDocFragment]) -> Optional["OdxLinkId"]:
+                doc_fragments: list[OdxDocFragment]) -> Optional["OdxLinkId"]:
         """Construct an OdxLinkId for a given XML node (ElementTree object).
 
         Returns None if the given XML node does not exhibit an ID.
@@ -94,7 +95,7 @@ class OdxLinkRef:
     ref_id: str
 
     #: The document fragments to which the `ref_id` refers to (in reverse order)
-    ref_docs: List[OdxDocFragment]
+    ref_docs: list[OdxDocFragment]
 
     # TODO: this is difficult because OdxLinkRef is derived from and
     # we do not want having to specify it mandatorily
@@ -102,17 +103,17 @@ class OdxLinkRef:
 
     @overload
     @staticmethod
-    def from_et(et: None, source_doc_frags: List[OdxDocFragment]) -> None:
+    def from_et(et: None, source_doc_frags: list[OdxDocFragment]) -> None:
         ...
 
     @overload
     @staticmethod
-    def from_et(et: ElementTree.Element, source_doc_frags: List[OdxDocFragment]) -> "OdxLinkRef":
+    def from_et(et: ElementTree.Element, source_doc_frags: list[OdxDocFragment]) -> "OdxLinkRef":
         ...
 
     @staticmethod
-    def from_et(et: Optional[ElementTree.Element],
-                source_doc_frags: List[OdxDocFragment]) -> Optional["OdxLinkRef"]:
+    def from_et(et: ElementTree.Element | None,
+                source_doc_frags: list[OdxDocFragment]) -> Optional["OdxLinkRef"]:
         """Construct an OdxLinkRef for a given XML node (ElementTree object).
 
         Returns None if the given XML node does not represent a reference.
@@ -170,17 +171,17 @@ class OdxLinkDatabase:
     """
 
     def __init__(self) -> None:
-        self._db: Dict[OdxDocFragment, Dict[str, Any]] = {}
+        self._db: dict[OdxDocFragment, dict[str, Any]] = {}
 
     @overload
     def resolve(self, ref: OdxLinkRef, expected_type: None = None) -> Any:
         ...
 
     @overload
-    def resolve(self, ref: OdxLinkRef, expected_type: Type[T]) -> T:
+    def resolve(self, ref: OdxLinkRef, expected_type: type[T]) -> T:
         ...
 
-    def resolve(self, ref: OdxLinkRef, expected_type: Optional[Any] = None) -> Any:
+    def resolve(self, ref: OdxLinkRef, expected_type: Any | None = None) -> Any:
         """
         Resolve a reference to an object
 
@@ -219,12 +220,10 @@ class OdxLinkDatabase:
         ...
 
     @overload
-    def resolve_lenient(self, ref: OdxLinkRef, expected_type: Type[T]) -> Optional[T]:
+    def resolve_lenient(self, ref: OdxLinkRef, expected_type: type[T]) -> T | None:
         ...
 
-    def resolve_lenient(self,
-                        ref: OdxLinkRef,
-                        expected_type: Optional[Any] = None) -> Optional[Any]:
+    def resolve_lenient(self, ref: OdxLinkRef, expected_type: Any | None = None) -> Any | None:
         """
         Resolve a reference to an object
 
@@ -254,7 +253,7 @@ class OdxLinkDatabase:
 
         return None
 
-    def update(self, new_entries: Dict[OdxLinkId, Any], *, overwrite: bool = True) -> None:
+    def update(self, new_entries: dict[OdxLinkId, Any], *, overwrite: bool = True) -> None:
         """
         Add a bunch of new objects to the ODXLINK database.
 
@@ -287,7 +286,7 @@ def resolve_snref(target_short_name: str,
 @overload
 def resolve_snref(target_short_name: str,
                   items: Iterable[OdxNamed],
-                  expected_type: Type[TNamed],
+                  expected_type: type[TNamed],
                   *,
                   lenient: None = None) -> TNamed:
     ...
@@ -296,16 +295,16 @@ def resolve_snref(target_short_name: str,
 @overload
 def resolve_snref(target_short_name: str,
                   items: Iterable[OdxNamed],
-                  expected_type: Type[TNamed],
+                  expected_type: type[TNamed],
                   *,
-                  lenient: bool = True) -> Optional[TNamed]:
+                  lenient: bool = True) -> TNamed | None:
     ...
 
 
 def resolve_snref(target_short_name: str,
                   items: Iterable[OdxNamed],
                   expected_type: Any = None,
-                  lenient: Optional[bool] = None) -> Any:
+                  lenient: bool | None = None) -> Any:
     candidates = [x for x in items if x.short_name == target_short_name]
 
     if not candidates:

odxtools/odxtypes.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Callable, Iterable
 from enum import Enum
-from typing import (TYPE_CHECKING, Any, Callable, Dict, Iterable, Optional, SupportsBytes, Tuple,
-                    Type, Union, overload)
+from typing import TYPE_CHECKING, Any, SupportsBytes, Union, overload
 from xml.etree import ElementTree
 
 from .exceptions import odxassert, odxraise, odxrequire
@@ -16,22 +16,22 @@ def bytefield_to_bytearray(bytefield: str) -> bytearray:
     return bytearray([int(x, 16) for x in bytes_string])
 
 
-BytesTypes = (bytearray, bytes, SupportsBytes)
-AtomicOdxType = Union[str, int, float, bytearray, bytes]
+BytesTypes = bytearray | bytes | SupportsBytes
+AtomicOdxType = str | int | float | BytesTypes
 
 # dictionary mapping short names to a Parameter that needs to be
 # specified. Complex parameters (structures) may contain
 # sub-parameters, so this is a recursive type...
-ParameterDict = Dict[str, Union["Parameter", "ParameterDict"]]
+ParameterDict = dict[str, Union["Parameter", "ParameterDict"]]
 
 # Dictionary mapping short names of parameters to the value it
 # exhibits. Complex parameters (structures) may contain
 # sub-parameters, so this is a recursive type, and fields encompass
 # multiple items, so this can be a list of objects.
-TableStructParameterValue = Tuple[str, "ParameterValue"]
+TableStructParameterValue = tuple[str, "ParameterValue"]
 ParameterValue = Union[AtomicOdxType, "ParameterValueDict", TableStructParameterValue,
                        Iterable["ParameterValue"], "DiagnosticTroubleCode"]
-ParameterValueDict = Dict[str, ParameterValue]
+ParameterValueDict = dict[str, ParameterValue]
 
 
 @overload
@@ -44,7 +44,7 @@ def odxstr_to_bool(str_val: str) -> bool:
     ...
 
 
-def odxstr_to_bool(str_val: Optional[str]) -> Optional[bool]:
+def odxstr_to_bool(str_val: str | None) -> bool | None:
     if str_val is None:
         return None
 
@@ -79,7 +79,7 @@ def parse_int(value: str) -> int:
 
 #: conversion functions for strings from the XML to the types stored
 #: by the internalized database
-_PARSE_ODX_TYPE: Dict[str, Callable[[str], AtomicOdxType]] = {
+_PARSE_ODX_TYPE: dict[str, Callable[[str], AtomicOdxType]] = {
     "A_INT32": parse_int,
     "A_UINT32": parse_int,
     "A_FLOAT32": float,
@@ -92,7 +92,7 @@ _PARSE_ODX_TYPE: Dict[str, Callable[[str], AtomicOdxType]] = {
 
 #: mapping from type name strings specified by the XML to the types
 #: used by the internalized database
-_ODX_TYPE_TO_PYTHON_TYPE: Dict[str, Type[AtomicOdxType]] = {
+_ODX_TYPE_TO_PYTHON_TYPE: dict[str, type[int | float | str | bytearray]] = {
     "A_INT32": int,
     "A_UINT32": int,
     "A_FLOAT32": float,
@@ -109,8 +109,8 @@ def compare_odx_values(a: AtomicOdxType, b: AtomicOdxType) -> int:
     # specification. (cf section 7.3.6.5)
 
     # numeric values are compared numerically (duh!)
-    if isinstance(a, (int, float)):
-        if not isinstance(b, (int, float)):
+    if isinstance(a, int | float):
+        if not isinstance(b, int | float):
             odxraise()
 
         tmp = a - b
@@ -140,10 +140,13 @@ def compare_odx_values(a: AtomicOdxType, b: AtomicOdxType) -> int:
         if not isinstance(b, BytesTypes):
             odxraise()
 
-        obj_len = max(len(a), len(b))
+        a_bytes = bytes(a)
+        b_bytes = bytes(b)
 
-        tmp_a = a.ljust(obj_len, b'\x00')
-        tmp_b = b.ljust(obj_len, b'\x00')
+        obj_len = max(len(a_bytes), len(b_bytes))
+
+        tmp_a = a_bytes.ljust(obj_len, b'\x00')
+        tmp_b = b_bytes.ljust(obj_len, b'\x00')
 
         if tmp_a > tmp_b:
             return 1
@@ -193,7 +196,7 @@ class DataType(Enum):
     A_UTF8STRING = "A_UTF8STRING"
 
     @property
-    def python_type(self) -> Type[AtomicOdxType]:
+    def python_type(self) -> type[int | float | str | bytearray]:
         return _ODX_TYPE_TO_PYTHON_TYPE[self.value]
 
     @property
@@ -211,7 +214,7 @@ class DataType(Enum):
     def create_from_et(self, et_element: ElementTree.Element) -> AtomicOdxType:
         ...
 
-    def create_from_et(self, et_element: Optional[ElementTree.Element]) -> Optional[AtomicOdxType]:
+    def create_from_et(self, et_element: ElementTree.Element | None) -> AtomicOdxType | None:
         """
             Parse a V/VT value union and return an AtomicOdxType from them that match current datatype
             this includes, but not limited to COMPU-CONST, COMPU-DEFAULT-VALUE, COMPU-INVERSE-VALUE
@@ -236,7 +239,7 @@ class DataType(Enum):
         expected_type = self.python_type
         if isinstance(value, expected_type):
             return True
-        elif expected_type is float and isinstance(value, (int, float)):
+        elif expected_type is float and isinstance(value, int | float):
             return True
         elif self == DataType.A_BYTEFIELD and isinstance(value, BytesTypes):
             return True

odxtools/outputparam.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
@@ -16,7 +16,7 @@ from .utils import dataclass_fields_asdict
 @dataclass
 class OutputParam(IdentifiableElement):
     dop_base_ref: OdxLinkRef
-    semantic: Optional[str]
+    semantic: str | None
 
     @property
     def dop(self) -> DopBase:
@@ -27,7 +27,7 @@ class OutputParam(IdentifiableElement):
         return self._dop
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "OutputParam":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "OutputParam":
 
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
@@ -36,7 +36,7 @@ class OutputParam(IdentifiableElement):
 
         return OutputParam(dop_base_ref=dop_base_ref, 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/parameterinfo.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 import textwrap
+from collections.abc import Iterable
 from io import StringIO
-from typing import Iterable
 
 from .compumethods.compucodecompumethod import CompuCodeCompuMethod
 from .compumethods.identicalcompumethod import IdenticalCompuMethod
-from .compumethods.limit import IntervalType
+from .compumethods.intervaltype import IntervalType
 from .compumethods.linearcompumethod import LinearCompuMethod
 from .compumethods.linearsegment import LinearSegment
 from .compumethods.ratfunccompumethod import RatFuncCompuMethod

odxtools/parameters/codedconstparameter.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -45,7 +45,7 @@ class CodedConstParameter(Parameter):
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "CodedConstParameter":
+                doc_frags: list[OdxDocFragment]) -> "CodedConstParameter":
 
         kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
 
@@ -61,7 +61,7 @@ class CodedConstParameter(Parameter):
             AtomicOdxType, self.diag_coded_type.base_data_type.from_string(self.coded_value_raw))
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         result.update(self.diag_coded_type._build_odxlinks())
@@ -69,7 +69,7 @@ class CodedConstParameter(Parameter):
         return result
 
     @override
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return self.diag_coded_type.get_static_bit_length()
 
     @property
@@ -77,7 +77,7 @@ class CodedConstParameter(Parameter):
         return self.diag_coded_type.base_data_type
 
     @override
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         if physical_value is not None and physical_value != self.coded_value:
             odxraise(

odxtools/parameters/createanyparameter.py

@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: MIT
-from typing import List
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise
@@ -21,7 +20,7 @@ from .valueparameter import ValueParameter
 
 
 def create_any_parameter_from_et(et_element: ElementTree.Element,
-                                 doc_frags: List[OdxDocFragment]) \
+                                 doc_frags: list[OdxDocFragment]) \
                                  -> Parameter:
     parameter_type = et_element.get(f"{xsi}type")
 

odxtools/parameters/dynamicparameter.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -34,14 +33,14 @@ class DynamicParameter(Parameter):
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DynamicParameter":
+                doc_frags: list[OdxDocFragment]) -> "DynamicParameter":
 
         kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
 
         return DynamicParameter(**kwargs)
 
     @override
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         raise NotImplementedError("Encoding DynamicParameter is not implemented yet.")
 

odxtools/parameters/lengthkeyparameter.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 final, override
@@ -49,7 +49,7 @@ class LengthKeyParameter(ParameterWithDOP):
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "LengthKeyParameter":
+                doc_frags: list[OdxDocFragment]) -> "LengthKeyParameter":
 
         kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
 
@@ -58,7 +58,7 @@ class LengthKeyParameter(ParameterWithDOP):
         return LengthKeyParameter(odx_id=odx_id, **kwargs)
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         result[self.odx_id] = self
@@ -67,7 +67,7 @@ class LengthKeyParameter(ParameterWithDOP):
 
     @override
     @final
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         # if you get this exception, you ought to use
         # `.encode_placeholder_into_pdu()` followed by (after the
@@ -75,7 +75,7 @@ class LengthKeyParameter(ParameterWithDOP):
         # `.encode_value_into_pdu()`.
         raise RuntimeError("_encode_positioned_into_pdu() cannot be called for length keys.")
 
-    def encode_placeholder_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_placeholder_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
 
         if physical_value is not None:

odxtools/parameters/matchingrequestparameter.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -37,7 +36,7 @@ class MatchingRequestParameter(Parameter):
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MatchingRequestParameter":
+                doc_frags: list[OdxDocFragment]) -> "MatchingRequestParameter":
 
         kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
 
@@ -48,11 +47,11 @@ class MatchingRequestParameter(Parameter):
             request_byte_position=request_byte_position, byte_length=byte_length, **kwargs)
 
     @override
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return 8 * self.byte_length
 
     @override
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         if encode_state.triggering_request is None:
             odxraise(