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

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,15 +1,14 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .matchingparameter import MatchingParameter
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import odxstr_to_bool
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class MatchingBaseVariantParameter(MatchingParameter):
     """A description of a parameter used for base variant matching.
 
@@ -18,7 +17,7 @@ class MatchingBaseVariantParameter(MatchingParameter):
     additional subtag `USE-PHYSICAL-ADDRESSING`.
     """
 
-    use_physical_addressing_raw: Optional[bool]
+    use_physical_addressing_raw: bool | None = None
 
     @property
     def use_physical_addressing(self) -> bool:
@@ -26,9 +25,9 @@ class MatchingBaseVariantParameter(MatchingParameter):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MatchingBaseVariantParameter":
+                context: OdxDocContext) -> "MatchingBaseVariantParameter":
 
-        kwargs = dataclass_fields_asdict(MatchingParameter.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(MatchingParameter.from_et(et_element, context))
 
         use_physical_addressing_raw = odxstr_to_bool(et_element.findtext("USE-PHYSICAL-ADDRESSING"))
 

odxtools/matchingparameter.py

@@ -1,18 +1,19 @@
 # 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
 from .diagnostictroublecode import DiagnosticTroubleCode
 from .diagservice import DiagService
 from .exceptions import odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, resolve_snref
 from .odxtypes import BytesTypes, ParameterValue, ParameterValueDict
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class MatchingParameter:
     """According to ISO 22901, a MatchingParameter contains a string
     value identifying the active ECU or base variant. Moreover, it
@@ -34,12 +35,11 @@ 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 = None
+    out_param_if_snpathref: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MatchingParameter":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "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/message.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
     from .response import Response
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Message:
     """A diagnostic message with its interpretation.
 

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
@@ -10,15 +10,15 @@ from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .encoding import get_string_encoding
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import AtomicOdxType, BytesTypes, DataType
 from .termination import Termination
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class MinMaxLengthType(DiagCodedType):
-    max_length: Optional[int]
+    max_length: int | None = None
     min_length: int
     termination: Termination
 
@@ -28,9 +28,8 @@ class MinMaxLengthType(DiagCodedType):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MinMaxLengthType":
-        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "MinMaxLengthType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, context))
 
         max_length = None
         if et_element.find("MAX-LENGTH") is not None:

odxtools/modification.py

@@ -1,26 +1,27 @@
 # 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
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Modification:
     change: str
-    reason: Optional[str]
+    reason: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Modification":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "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 dataclasses import dataclass, field
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -13,13 +13,14 @@ from .multiplexercase import MultiplexerCase
 from .multiplexerdefaultcase import MultiplexerDefaultCase
 from .multiplexerswitchkey import MultiplexerSwitchKey
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, ParameterValue, odxstr_to_bool
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Multiplexer(ComplexDop):
     """This class represents a Multiplexer (MUX)
 
@@ -30,9 +31,9 @@ class Multiplexer(ComplexDop):
 
     byte_position: int
     switch_key: MultiplexerSwitchKey
-    default_case: Optional[MultiplexerDefaultCase]
-    cases: NamedItemList[MultiplexerCase]
-    is_visible_raw: Optional[bool]
+    default_case: MultiplexerDefaultCase | None = None
+    cases: NamedItemList[MultiplexerCase] = field(default_factory=NamedItemList)
+    is_visible_raw: bool | None = None
 
     @property
     def is_visible(self) -> bool:
@@ -40,20 +41,20 @@ class Multiplexer(ComplexDop):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Multiplexer":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Multiplexer":
         """Reads a Multiplexer from Diag Layer."""
-        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, context))
 
         byte_position = int(et_element.findtext("BYTE-POSITION", "0"))
         switch_key = MultiplexerSwitchKey.from_et(
-            odxrequire(et_element.find("SWITCH-KEY")), doc_frags)
+            odxrequire(et_element.find("SWITCH-KEY")), context)
 
         default_case = None
         if (dc_elem := et_element.find("DEFAULT-CASE")) is not None:
-            default_case = MultiplexerDefaultCase.from_et(dc_elem, doc_frags)
+            default_case = MultiplexerDefaultCase.from_et(dc_elem, context)
 
         cases = NamedItemList(
-            [MultiplexerCase.from_et(el, doc_frags) for el in et_element.iterfind("CASES/CASE")])
+            [MultiplexerCase.from_et(el, context) for el in et_element.iterfind("CASES/CASE")])
 
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
 
@@ -66,7 +67,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 +99,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)
@@ -127,8 +128,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 +148,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 +209,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]
@@ -235,3 +236,38 @@ class Multiplexer(ComplexDop):
         decode_state.origin_byte_position = orig_origin
 
         return result
+
+    @override
+    def get_static_bit_length(self) -> int | None:
+        """
+        Returns the static bit length of the multiplexer structure, if determinable.
+
+        If all cases (including the default, if present) have the same static bit length,
+        the codec length is considered static and is returned.
+        Otherwise, returns None to indicate that the size is dynamic.
+        """
+        reference_case = self.default_case if self.default_case else self.cases[0]
+
+        case_bit_length: int | None
+        if reference_case.structure is None:
+            case_bit_length = 0
+        else:
+            case_bit_length = reference_case.structure.get_static_bit_length()
+        if case_bit_length is None:
+            return None
+        case_size: int | None
+        for mux_case in self.cases:
+            if mux_case.structure is None:
+                case_size = 0
+            else:
+                case_size = mux_case.structure.get_static_bit_length()
+            if case_size != case_bit_length:
+                return None  # Found a case with a different or unknown size
+
+        switch_key_size = self.switch_key.dop.get_static_bit_length()
+        if switch_key_size is None:
+            return None
+
+        return max(
+            switch_key_size + self.switch_key.byte_position * 8 +
+            (self.switch_key.bit_position or 0), case_bit_length + self.byte_position * 8)

odxtools/multiplexercase.py

@@ -1,49 +1,49 @@
 # 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
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType, DataType
 from .snrefcontext import SnRefContext
 from .structure import Structure
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 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 = None
+    structure_snref: str | None = 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":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "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)
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+        structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), context)
         structure_snref = None
         if (structure_snref_elem := et_element.find("STRUCTURE-SNREF")) is not None:
             structure_snref = odxrequire(structure_snref_elem.get("SHORT-NAME"))
 
         lower_limit = Limit.limit_from_et(
             odxrequire(et_element.find("LOWER-LIMIT")),
-            doc_frags,
+            context,
             value_type=None,
         )
         upper_limit = Limit.limit_from_et(
             odxrequire(et_element.find("UPPER-LIMIT")),
-            doc_frags,
+            context,
             value_type=None,
         )
 
@@ -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,33 +1,34 @@
 # 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
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
 from .structure import Structure
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 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 = None
+    structure_snref: str | None = 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":
+                context: OdxDocContext) -> "MultiplexerDefaultCase":
         """Reads a default case for a multiplexer."""
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
-        structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), doc_frags)
+        structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), context)
         structure_snref = None
         if (structure_snref_elem := et_element.find("STRUCTURE-SNREF")) is not None:
             structure_snref = odxrequire(structure_snref_elem.get("SHORT-NAME"))
@@ -35,7 +36,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:

odxtools/multiplexerswitchkey.py

@@ -1,21 +1,22 @@
 # 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
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 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 = None
     dop_ref: OdxLinkRef
 
     @property
@@ -23,12 +24,11 @@ class MultiplexerSwitchKey:
         return self._dop
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MultiplexerSwitchKey":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "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
-        dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), doc_frags))
+        dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), context))
 
         return MultiplexerSwitchKey(
             byte_position=byte_position,
@@ -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,10 +138,10 @@ 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]]:
+    def __getitem__(self, key: SupportsIndex | str | slice) -> T | list[T]:
         if isinstance(key, (SupportsIndex, slice)):
             return super().__getitem__(key)
         else:
@@ -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.