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

odxtools/compumethods/texttablecompumethod.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, cast
+from typing import cast
 from xml.etree import ElementTree
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
@@ -22,7 +22,7 @@ class TexttableCompuMethod(CompuMethod):
     """
 
     @staticmethod
-    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                              internal_type: DataType,
                              physical_type: DataType) -> "TexttableCompuMethod":
         cm = CompuMethod.compu_method_from_et(
@@ -95,7 +95,7 @@ class TexttableCompuMethod(CompuMethod):
         scales = []
         if (citp := self.compu_internal_to_phys) is not None:
             scales = citp.compu_scales
-        matching_scales: List[CompuScale] = [x for x in scales if x.applies(internal_value)]
+        matching_scales: list[CompuScale] = [x for x in scales if x.applies(internal_value)]
 
         if len(matching_scales) == 0:
             if self._compu_physical_default_value is None:

odxtools/createanycomparam.py

@@ -1,4 +1,3 @@
-from typing import List, Union
 from xml.etree import ElementTree
 
 from .comparam import Comparam
@@ -6,9 +5,8 @@ from .complexcomparam import ComplexComparam
 from .odxlink import OdxDocFragment
 
 
-def create_any_comparam_from_et(
-        et_element: ElementTree.Element,
-        doc_frags: List[OdxDocFragment]) -> Union[Comparam, ComplexComparam]:
+def create_any_comparam_from_et(et_element: ElementTree.Element,
+                                doc_frags: list[OdxDocFragment]) -> Comparam | ComplexComparam:
     if et_element.tag == "COMPARAM":
         return Comparam.from_et(et_element, doc_frags)
     elif et_element.tag == "COMPLEX-COMPARAM":

odxtools/createanydiagcodedtype.py

@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: MIT
-from typing import List
 from xml.etree import ElementTree
 
 from .diagcodedtype import DiagCodedType
@@ -13,7 +12,7 @@ from .standardlengthtype import StandardLengthType
 
 
 def create_any_diag_coded_type_from_et(et_element: ElementTree.Element,
-                                       doc_frags: List[OdxDocFragment]) -> DiagCodedType:
+                                       doc_frags: list[OdxDocFragment]) -> DiagCodedType:
     dct_type = et_element.get(f"{xsi}type")
     if dct_type == "LEADING-LENGTH-INFO-TYPE":
         return LeadingLengthInfoType.from_et(et_element, doc_frags)

odxtools/database.py

@@ -1,8 +1,9 @@
 # SPDX-License-Identifier: MIT
+from collections import OrderedDict
 from itertools import chain
 from os import PathLike
 from pathlib import Path
-from typing import IO, Any, Dict, List, Optional, OrderedDict, Union
+from typing import IO, Any, Union
 from xml.etree import ElementTree
 from zipfile import ZipFile
 
@@ -30,7 +31,7 @@ class Database:
     """
 
     def __init__(self) -> None:
-        self.model_version: Optional[Version] = None
+        self.model_version: Version | None = None
         self.auxiliary_files: OrderedDict[str, IO[bytes]] = OrderedDict()
 
         # create an empty database object
@@ -68,16 +69,16 @@ class Database:
 
     def add_auxiliary_file(self,
                            aux_file_name: Union[str, "PathLike[Any]"],
-                           aux_file_obj: Optional[IO[bytes]] = None) -> None:
+                           aux_file_obj: IO[bytes] | None = None) -> None:
         if aux_file_obj is None:
             aux_file_obj = open(aux_file_name, "rb")
 
         self.auxiliary_files[str(aux_file_name)] = aux_file_obj
 
     def _process_xml_tree(self, root: ElementTree.Element) -> None:
-        dlcs: List[DiagLayerContainer] = []
-        comparam_subsets: List[ComparamSubset] = []
-        comparam_specs: List[ComparamSpec] = []
+        dlcs: list[DiagLayerContainer] = []
+        comparam_subsets: list[ComparamSubset] = []
+        comparam_specs: list[ComparamSpec] = []
 
         # ODX spec version
         model_version = Version(root.attrib.get("MODEL-VERSION", "2.0"))
@@ -160,8 +161,8 @@ class Database:
         for dlc in self.diag_layer_containers:
             dlc._resolve_snrefs(context)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result: Dict[OdxLinkId, Any] = {}
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result: dict[OdxLinkId, Any] = {}
 
         for subset in self.comparam_subsets:
             result.update(subset._build_odxlinks())

odxtools/dataobjectproperty.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 .compumethods.compumethod import CompuMethod
@@ -37,20 +37,20 @@ class DataObjectProperty(DopBase):
     #: The type of the value in the physical world
     physical_type: PhysicalType
 
-    internal_constr: Optional[InternalConstr]
+    internal_constr: InternalConstr | None
 
     #: The unit associated with physical values (e.g. 'm/s^2')
-    unit_ref: Optional[OdxLinkRef]
+    unit_ref: OdxLinkRef | None
 
-    physical_constr: Optional[InternalConstr]
+    physical_constr: InternalConstr | None
 
     @property
-    def unit(self) -> Optional[Unit]:
+    def unit(self) -> Unit | None:
         return self._unit
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DataObjectProperty":
+                doc_frags: list[OdxDocFragment]) -> "DataObjectProperty":
         """Reads a DATA-OBJECT-PROP."""
         kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, doc_frags))
 
@@ -83,7 +83,7 @@ class DataObjectProperty(DopBase):
             physical_constr=physical_constr,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
         result.update(self.compu_method._build_odxlinks())
         result.update(self.diag_coded_type._build_odxlinks())
@@ -96,7 +96,7 @@ class DataObjectProperty(DopBase):
         self.compu_method._resolve_odxlinks(odxlinks)
         self.diag_coded_type._resolve_odxlinks(odxlinks)
 
-        self._unit: Optional[Unit] = None
+        self._unit: Unit | None = None
         if self.unit_ref:
             self._unit = odxlinks.resolve(self.unit_ref, Unit)
 
@@ -106,7 +106,7 @@ class DataObjectProperty(DopBase):
         self.compu_method._resolve_snrefs(context)
         self.diag_coded_type._resolve_snrefs(context)
 
-    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()
 
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
@@ -118,7 +118,7 @@ class DataObjectProperty(DopBase):
                 f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
                 f" is not a valid.")
 
-        if not isinstance(physical_value, (int, float, str, BytesTypes)):
+        if not isinstance(physical_value, int | float | str | BytesTypes):
             odxraise(f"Invalid type '{type(physical_value).__name__}' for physical value. "
                      f"(Expect atomic type!)")
         internal_value = self.compu_method.convert_physical_to_internal(physical_value)

odxtools/decodestate.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING
 
 from .encoding import Encoding, get_string_encoding
 from .exceptions import DecodeError, odxassert, odxraise, strict_mode
@@ -41,22 +41,22 @@ class DecodeState:
     cursor_bit_position: int = 0
 
     #: values of the length key parameters decoded so far
-    length_keys: Dict[str, int] = field(default_factory=dict)
+    length_keys: dict[str, int] = field(default_factory=dict)
 
     #: values of the table key parameters decoded so far
-    table_keys: Dict[str, "TableRow"] = field(default_factory=dict)
+    table_keys: dict[str, "TableRow"] = field(default_factory=dict)
 
     #: List of parameters that have been decoded so far. The journal
     #: is used by some types of parameters which depend on the values of
     #: other parameters; i.e., environment data description parameters
-    journal: List[Tuple["Parameter", Optional[ParameterValue]]] = field(default_factory=list)
+    journal: list[tuple["Parameter", ParameterValue | None]] = field(default_factory=list)
 
     def extract_atomic_value(
         self,
         *,
         bit_length: int,
         base_data_type: DataType,
-        base_type_encoding: Optional[Encoding],
+        base_type_encoding: Encoding | None,
         is_highlow_byte_order: bool,
     ) -> AtomicOdxType:
         """Extract an internal value from a blob of raw bytes.

odxtools/description.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
@@ -10,13 +10,13 @@ from .odxlink import OdxDocFragment
 @dataclass
 class Description:
     text: str
-    external_docs: List[ExternalDoc]
+    external_docs: list[ExternalDoc]
 
-    text_identifier: Optional[str]
+    text_identifier: str | None
 
     @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element],
-                doc_frags: List[OdxDocFragment]) -> Optional["Description"]:
+    def from_et(et_element: ElementTree.Element | None,
+                doc_frags: list[OdxDocFragment]) -> Optional["Description"]:
         if et_element is None:
             return None
 

odxtools/determinenumberofitems.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 DetermineNumberOfItems:
     The object that determines the number of items of dynamic fields
     """
     byte_position: int
-    bit_position: Optional[int]
+    bit_position: int | None
     dop_ref: OdxLinkRef
 
     @property
@@ -24,7 +24,7 @@ class DetermineNumberOfItems:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DetermineNumberOfItems":
+                doc_frags: list[OdxDocFragment]) -> "DetermineNumberOfItems":
         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 DetermineNumberOfItems:
             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/diagcodedtype.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Literal, Optional, Union, cast
+from typing import Any, Literal, cast
 from xml.etree import ElementTree
 
 from .decodestate import DecodeState
@@ -22,10 +22,10 @@ DctType = Literal[
 
 @dataclass
 class DiagCodedType:
-    base_type_encoding: Optional[Encoding]
+    base_type_encoding: Encoding | None
     base_data_type: DataType
 
-    is_highlow_byte_order_raw: Optional[bool]
+    is_highlow_byte_order_raw: bool | None
 
     @property
     def dct_type(self) -> DctType:
@@ -39,7 +39,7 @@ class DiagCodedType:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DiagCodedType":
+                doc_frags: list[OdxDocFragment]) -> "DiagCodedType":
         base_type_encoding = None
         if (base_type_encoding_str := et_element.get("BASE-TYPE-ENCODING")) is not None:
             try:
@@ -61,7 +61,7 @@ class DiagCodedType:
             base_data_type=base_data_type,
             is_highlow_byte_order_raw=is_highlow_byte_order_raw)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:  # noqa: B027
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:  # noqa: B027
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:  # noqa: B027
@@ -72,10 +72,10 @@ class DiagCodedType:
         """Recursively resolve any short-name references"""
         pass
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return None
 
-    def _minimal_byte_length_of(self, internal_value: Union[bytes, str]) -> int:
+    def _minimal_byte_length_of(self, internal_value: bytes | str) -> int:
         """Helper method to get the minimal byte length.
         (needed for LeadingLength- and MinMaxLengthType)
         """

odxtools/diagcomm.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
@@ -34,21 +34,21 @@ class DiagComm(IdentifiableElement):
 
     """
 
-    admin_data: Optional[AdminData]
-    sdgs: List[SpecialDataGroup]
-    functional_class_refs: List[OdxLinkRef]
-    audience: Optional[Audience]
-    protocol_snrefs: List[str]
-    related_diag_comm_refs: List[RelatedDiagCommRef]
-    pre_condition_state_refs: List[PreConditionStateRef]
-    state_transition_refs: List[StateTransitionRef]
+    admin_data: AdminData | None
+    sdgs: list[SpecialDataGroup]
+    functional_class_refs: list[OdxLinkRef]
+    audience: Audience | None
+    protocol_snrefs: list[str]
+    related_diag_comm_refs: list[RelatedDiagCommRef]
+    pre_condition_state_refs: list[PreConditionStateRef]
+    state_transition_refs: list[StateTransitionRef]
 
     # attributes
-    semantic: Optional[str]
-    diagnostic_class: Optional[DiagClassType]
-    is_mandatory_raw: Optional[bool]
-    is_executable_raw: Optional[bool]
-    is_final_raw: Optional[bool]
+    semantic: str | None
+    diagnostic_class: DiagClassType | None
+    is_mandatory_raw: bool | None
+    is_executable_raw: bool | None
+    is_final_raw: bool | None
 
     @property
     def functional_classes(self) -> NamedItemList[FunctionalClass]:
@@ -83,7 +83,7 @@ class DiagComm(IdentifiableElement):
         return self.is_final_raw is True
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagComm":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DiagComm":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
@@ -122,7 +122,7 @@ class DiagComm(IdentifiableElement):
 
         semantic = et_element.attrib.get("SEMANTIC")
 
-        diagnostic_class: Optional[DiagClassType] = None
+        diagnostic_class: DiagClassType | None = None
         if (diagnostic_class_str := et_element.attrib.get("DIAGNOSTIC-CLASS")) is not None:
             try:
                 diagnostic_class = DiagClassType(diagnostic_class_str)
@@ -149,7 +149,7 @@ class DiagComm(IdentifiableElement):
             is_final_raw=is_final_raw,
             **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/diagdatadictionaryspec.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -26,7 +26,7 @@ from .unitspec import UnitSpec
 
 @dataclass
 class DiagDataDictionarySpec:
-    admin_data: Optional[AdminData]
+    admin_data: AdminData | None
     dtc_dops: NamedItemList[DtcDop]
     env_data_descs: NamedItemList[EnvironmentDataDescription]
     data_object_props: NamedItemList[DataObjectProperty]
@@ -37,13 +37,13 @@ class DiagDataDictionarySpec:
     end_of_pdu_fields: NamedItemList[EndOfPduField]
     muxs: NamedItemList[Multiplexer]
     env_datas: NamedItemList[EnvironmentData]
-    unit_spec: Optional[UnitSpec]
+    unit_spec: UnitSpec | None
     tables: NamedItemList[Table]
-    sdgs: List[SpecialDataGroup]
+    sdgs: list[SpecialDataGroup]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DiagDataDictionarySpec":
+                doc_frags: list[OdxDocFragment]) -> "DiagDataDictionarySpec":
         admin_data = None
         if (admin_data_elem := et_element.find("ADMIN-DATA")) is not None:
             admin_data = AdminData.from_et(admin_data_elem, doc_frags)
@@ -149,7 +149,7 @@ class DiagDataDictionarySpec:
                 self.env_datas,
             ))
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         # note that DataDictionarySpec objects do not exhibit an ODXLINK id.
         odxlinks = {}
 

odxtools/diaglayercontainer.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Dict, List, Union
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .diaglayers.basevariant import BaseVariant
@@ -41,7 +41,7 @@ class DiagLayerContainer(OdxCategory):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DiagLayerContainer":
+                doc_frags: list[OdxDocFragment]) -> "DiagLayerContainer":
 
         cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type=DocType.CONTAINER)
         doc_frags = cat.odx_id.doc_fragments
@@ -85,7 +85,7 @@ class DiagLayerContainer(OdxCategory):
             self.ecu_variants,
         ),)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for protocol in self.protocols:
@@ -132,5 +132,5 @@ class DiagLayerContainer(OdxCategory):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
 
-    def __getitem__(self, key: Union[int, str]) -> DiagLayer:
+    def __getitem__(self, key: int | str) -> DiagLayer:
         return self.diag_layers[key]

odxtools/diaglayers/basevariant.py

@@ -1,7 +1,8 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any, Dict, Iterable, List, Optional, Union, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -32,19 +33,19 @@ class BaseVariant(HierarchyElement):
     # <properties forwarded to the "raw" base variant>
     #####
     @property
-    def diag_variables_raw(self) -> List[Union[DiagVariable, OdxLinkRef]]:
+    def diag_variables_raw(self) -> list[DiagVariable | OdxLinkRef]:
         return self.base_variant_raw.diag_variables_raw
 
     @property
-    def dyn_defined_spec(self) -> Optional[DynDefinedSpec]:
+    def dyn_defined_spec(self) -> DynDefinedSpec | None:
         return self.base_variant_raw.dyn_defined_spec
 
     @property
-    def base_variant_pattern(self) -> Optional[BaseVariantPattern]:
+    def base_variant_pattern(self) -> BaseVariantPattern | None:
         return self.base_variant_raw.base_variant_pattern
 
     @property
-    def parent_refs(self) -> List[ParentRef]:
+    def parent_refs(self) -> list[ParentRef]:
         return self.base_variant_raw.parent_refs
 
     #####
@@ -67,7 +68,7 @@ class BaseVariant(HierarchyElement):
     #######
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "BaseVariant":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "BaseVariant":
         base_variant_raw = BaseVariantRaw.from_et(et_element, doc_frags)
 
         return BaseVariant(diag_layer_raw=base_variant_raw)
@@ -80,7 +81,7 @@ class BaseVariant(HierarchyElement):
             "The raw diagnostic layer passed to BaseVariant "
             "must be a BaseVariantRaw")
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         """Create a deep copy of the base variant
 
         Note that the copied diagnostic layer is not fully
@@ -113,7 +114,7 @@ class BaseVariant(HierarchyElement):
 
             return dl.diag_layer_raw.diag_variables  # type: ignore[no-any-return]
 
-        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+        def not_inherited_fn(parent_ref: ParentRef) -> list[str]:
             return parent_ref.not_inherited_variables
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
@@ -127,7 +128,7 @@ class BaseVariant(HierarchyElement):
 
             return dl.diag_layer_raw.variable_groups  # type: ignore[no-any-return]
 
-        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+        def not_inherited_fn(parent_ref: ParentRef) -> list[str]:
             return []
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)

odxtools/diaglayers/basevariantraw.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 from xml.etree import ElementTree
 
 from ..basevariantpattern import BaseVariantPattern
@@ -21,11 +21,11 @@ class BaseVariantRaw(HierarchyElementRaw):
     """This is a diagnostic layer for common functionality of an ECU
     """
 
-    diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]]
+    diag_variables_raw: list[DiagVariable | OdxLinkRef]
     variable_groups: NamedItemList[VariableGroup]
-    dyn_defined_spec: Optional[DynDefinedSpec]
-    base_variant_pattern: Optional[BaseVariantPattern]
-    parent_refs: List[ParentRef]
+    dyn_defined_spec: DynDefinedSpec | None
+    base_variant_pattern: BaseVariantPattern | None
+    parent_refs: list[ParentRef]
 
     @property
     def diag_variables(self) -> NamedItemList[DiagVariable]:
@@ -33,7 +33,7 @@ class BaseVariantRaw(HierarchyElementRaw):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "BaseVariantRaw":
+                doc_frags: list[OdxDocFragment]) -> "BaseVariantRaw":
         # objects contained by diagnostic layers exibit an additional
         # document fragment for the diag layer, so we use the document
         # fragments of the odx id of the diag layer for IDs of
@@ -42,10 +42,10 @@ class BaseVariantRaw(HierarchyElementRaw):
         kwargs = dataclass_fields_asdict(her)
         doc_frags = her.odx_id.doc_fragments
 
-        diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]] = []
+        diag_variables_raw: list[DiagVariable | OdxLinkRef] = []
         if (dv_elems := et_element.find("DIAG-VARIABLES")) is not None:
             for dv_proxy_elem in dv_elems:
-                dv_proxy: Union[OdxLinkRef, DiagVariable]
+                dv_proxy: OdxLinkRef | DiagVariable
                 if dv_proxy_elem.tag == "DIAG-VARIABLE-REF":
                     dv_proxy = OdxLinkRef.from_et(dv_proxy_elem, doc_frags)
                 elif dv_proxy_elem.tag == "DIAG-VARIABLE":
@@ -81,7 +81,7 @@ class BaseVariantRaw(HierarchyElementRaw):
             parent_refs=parent_refs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for dv_proxy in self.diag_variables_raw: