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

odxtools/compumethods/limit.py

@@ -1,45 +1,39 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
-from typing import List, Optional, overload
+from typing import Optional, overload
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType, compare_odx_values
-
-
-class IntervalType(Enum):
-    OPEN = "OPEN"
-    CLOSED = "CLOSED"
-    INFINITE = "INFINITE"
+from .intervaltype import IntervalType
 
 
 @dataclass
 class Limit:
-    value_raw: Optional[str]
-    value_type: Optional[DataType]
-    interval_type: Optional[IntervalType]
+    value_raw: str | None
+    value_type: DataType | None
+    interval_type: IntervalType | None
 
     @property
-    def value(self) -> Optional[AtomicOdxType]:
+    def value(self) -> AtomicOdxType | None:
         return self._value
 
     @staticmethod
     @overload
-    def limit_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment],
-                      value_type: Optional[DataType]) -> "Limit":
+    def limit_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment],
+                      value_type: DataType | None) -> "Limit":
         ...
 
     @staticmethod
     @overload
-    def limit_from_et(et_element: None, doc_frags: List[OdxDocFragment],
-                      value_type: Optional[DataType]) -> None:
+    def limit_from_et(et_element: None, doc_frags: list[OdxDocFragment],
+                      value_type: DataType | None) -> None:
         ...
 
     @staticmethod
-    def limit_from_et(et_element: Optional[ElementTree.Element], doc_frags: List[OdxDocFragment],
-                      value_type: Optional[DataType]) -> Optional["Limit"]:
+    def limit_from_et(et_element: ElementTree.Element | None, doc_frags: list[OdxDocFragment],
+                      value_type: DataType | None) -> Optional["Limit"]:
 
         if et_element is None:
             return None
@@ -56,7 +50,7 @@ class Limit:
         return Limit(value_raw=value_raw, interval_type=interval_type, value_type=value_type)
 
     def __post_init__(self) -> None:
-        self._value: Optional[AtomicOdxType] = None
+        self._value: AtomicOdxType | None = None
 
         if self.value_type is not None:
             self.set_value_type(self.value_type)

odxtools/compumethods/linearcompumethod.py

@@ -1,13 +1,14 @@
 # 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
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
 from .linearsegment import LinearSegment
 
 
@@ -29,7 +30,7 @@ class LinearCompuMethod(CompuMethod):
         return self._segment
 
     @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) -> "LinearCompuMethod":
         cm = CompuMethod.compu_method_from_et(

odxtools/compumethods/linearsegment.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional, Union
 
 from ..exceptions import odxraise, odxrequire
 from ..odxtypes import AtomicOdxType, DataType
@@ -24,20 +23,20 @@ class LinearSegment:
     offset: float
     factor: float
     denominator: float
-    internal_lower_limit: Optional[Limit]
-    internal_upper_limit: Optional[Limit]
+    internal_lower_limit: Limit | None
+    internal_upper_limit: Limit | None
 
-    inverse_value: Union[int, float]  # value used as inverse if factor is 0
+    inverse_value: int | float  # value used as inverse if factor is 0
 
     internal_type: DataType
     physical_type: DataType
 
     @property
-    def physical_lower_limit(self) -> Optional[Limit]:
+    def physical_lower_limit(self) -> Limit | None:
         return self._physical_lower_limit
 
     @property
-    def physical_upper_limit(self) -> Optional[Limit]:
+    def physical_upper_limit(self) -> Limit | None:
         return self._physical_upper_limit
 
     @staticmethod
@@ -52,10 +51,10 @@ class LinearSegment:
         if len(coeffs.denominators) > 0:
             denominator = coeffs.denominators[0]
 
-        inverse_value: Union[int, float] = 0
+        inverse_value: int | float = 0
         if scale.compu_inverse_value is not None:
             x = odxrequire(scale.compu_inverse_value).value
-            if not isinstance(x, (int, float)):
+            if not isinstance(x, int | float):
                 odxraise(f"Non-numeric COMPU-INVERSE-VALUE specified ({x!r})")
             inverse_value = x
 
@@ -75,8 +74,8 @@ class LinearSegment:
     def __post_init__(self) -> None:
         self.__compute_physical_limits()
 
-    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> Union[float, int]:
-        if not isinstance(internal_value, (int, float)):
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> float | int:
+        if not isinstance(internal_value, int | float):
             odxraise(f"Internal values of linear compumethods must "
                      f"either be int or float (is: {type(internal_value).__name__})")
 
@@ -90,8 +89,8 @@ class LinearSegment:
 
         return result
 
-    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> Union[float, int]:
-        if not isinstance(physical_value, (int, float)):
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> float | int:
+        if not isinstance(physical_value, int | float):
             odxraise(f"Physical values of linear compumethods must "
                      f"either be int or float (is: {type(physical_value).__name__})")
 
@@ -115,7 +114,7 @@ class LinearSegment:
         This method is called by `__post_init__()`.
         """
 
-        def convert_internal_to_physical_limit(internal_limit: Optional[Limit]) -> Optional[Limit]:
+        def convert_internal_to_physical_limit(internal_limit: Limit | None) -> Limit | None:
             """Helper method to convert a single internal limit
             """
             if internal_limit is None or internal_limit.value_raw is None:
@@ -152,7 +151,7 @@ class LinearSegment:
         # Do type checks
         expected_type = self.physical_type.python_type
         if issubclass(expected_type, float):
-            if not isinstance(physical_value, (int, float)):
+            if not isinstance(physical_value, int | float):
                 return False
         else:
             if not isinstance(physical_value, expected_type):
@@ -173,7 +172,7 @@ class LinearSegment:
         # Do type checks
         expected_type = self.internal_type.python_type
         if issubclass(expected_type, float):
-            if not isinstance(internal_value, (int, float)):
+            if not isinstance(internal_value, int | float):
                 return False
         else:
             if not isinstance(internal_value, expected_type):

odxtools/compumethods/ratfunccompumethod.py

@@ -1,13 +1,14 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, cast
+from typing import cast
 from xml.etree import ElementTree
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
 from .ratfuncsegment import RatFuncSegment
 
 
@@ -29,11 +30,11 @@ class RatFuncCompuMethod(CompuMethod):
         return self._int_to_phys_segment
 
     @property
-    def phys_to_int_segment(self) -> Optional[RatFuncSegment]:
+    def phys_to_int_segment(self) -> RatFuncSegment | None:
         return self._phys_to_int_segment
 
     @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) -> "RatFuncCompuMethod":
         cm = CompuMethod.compu_method_from_et(

odxtools/compumethods/ratfuncsegment.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, Union
 
 from ..exceptions import odxraise, odxrequire
 from ..odxtypes import AtomicOdxType, DataType
@@ -14,11 +13,11 @@ class RatFuncSegment:
     """
     value_type: DataType
 
-    numerator_coeffs: List[Union[int, float]]
-    denominator_coeffs: List[Union[int, float]]
+    numerator_coeffs: list[int | float]
+    denominator_coeffs: list[int | float]
 
-    lower_limit: Optional[Limit]
-    upper_limit: Optional[Limit]
+    lower_limit: Limit | None
+    upper_limit: Limit | None
 
     @staticmethod
     def from_compu_scale(scale: CompuScale, value_type: DataType) -> "RatFuncSegment":
@@ -39,8 +38,8 @@ class RatFuncSegment:
             upper_limit=upper_limit,
             value_type=scale.range_type)
 
-    def convert(self, value: AtomicOdxType) -> Union[float, int]:
-        if not isinstance(value, (int, float)):
+    def convert(self, value: AtomicOdxType) -> float | int:
+        if not isinstance(value, int | float):
             odxraise(f"Internal values of linear compumethods must "
                      f"either be int or float (is: {type(value).__name__})")
 
@@ -70,7 +69,7 @@ class RatFuncSegment:
         # Do type checks
         expected_type = self.value_type.python_type
         if issubclass(expected_type, float):
-            if not isinstance(value, (int, float)):
+            if not isinstance(value, int | float):
                 return False
         else:
             if not isinstance(value, expected_type):

odxtools/compumethods/scalelinearcompumethod.py

@@ -1,14 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Union, cast
+from typing import cast
 from xml.etree import ElementTree
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
-from .limit import IntervalType
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
+from .intervaltype import IntervalType
 from .linearsegment import LinearSegment
 
 
@@ -20,11 +21,11 @@ class ScaleLinearCompuMethod(CompuMethod):
     """
 
     @property
-    def segments(self) -> List[LinearSegment]:
+    def segments(self) -> list[LinearSegment]:
         return self._segments
 
     @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) -> "ScaleLinearCompuMethod":
         cm = CompuMethod.compu_method_from_et(
@@ -34,7 +35,7 @@ class ScaleLinearCompuMethod(CompuMethod):
         return ScaleLinearCompuMethod(**kwargs)
 
     def __post_init__(self) -> None:
-        self._segments: List[LinearSegment] = []
+        self._segments: list[LinearSegment] = []
 
         odxassert(self.category == CompuCategory.SCALE_LINEAR,
                   "ScaleLinearCompuMethod must exibit SCALE-LINEAR category")
@@ -99,7 +100,7 @@ class ScaleLinearCompuMethod(CompuMethod):
                 self._is_invertible = False
                 break
 
-            if not isinstance(x, (int, float)):
+            if not isinstance(x, int | float):
                 odxraise("Linear segments must use int or float for all quantities")
 
             # the respective function value at the interval's
@@ -110,7 +111,7 @@ class ScaleLinearCompuMethod(CompuMethod):
                 self._is_invertible = False
                 break
 
-    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> Union[float, int]:
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> float | int:
         if not self._is_invertible:
             odxraise(
                 f"Trying to encode value {physical_value!r} using a non-invertible "
@@ -127,7 +128,7 @@ class ScaleLinearCompuMethod(CompuMethod):
 
         return seg.convert_physical_to_internal(physical_value)
 
-    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> Union[float, int]:
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> float | int:
         applicable_segments = [
             seg for seg in self._segments if seg.internal_applies(internal_value)
         ]

odxtools/compumethods/scaleratfunccompumethod.py

@@ -1,13 +1,14 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, cast
+from typing import cast
 from xml.etree import ElementTree
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
 from .ratfuncsegment import RatFuncSegment
 
 
@@ -19,15 +20,15 @@ class ScaleRatFuncCompuMethod(CompuMethod):
     """
 
     @property
-    def int_to_phys_segments(self) -> List[RatFuncSegment]:
+    def int_to_phys_segments(self) -> list[RatFuncSegment]:
         return self._int_to_phys_segments
 
     @property
-    def phys_to_int_segments(self) -> Optional[List[RatFuncSegment]]:
+    def phys_to_int_segments(self) -> list[RatFuncSegment] | None:
         return self._phys_to_int_segments
 
     @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) -> "ScaleRatFuncCompuMethod":
         cm = CompuMethod.compu_method_from_et(

odxtools/compumethods/tabintpcompumethod.py

@@ -1,14 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Union
 from xml.etree import ElementTree
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
-from .limit import IntervalType, Limit
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
+from .intervaltype import IntervalType
+from .limit import Limit
 
 
 @dataclass
@@ -35,11 +36,11 @@ class TabIntpCompuMethod(CompuMethod):
     """
 
     @property
-    def internal_points(self) -> List[Union[float, int]]:
+    def internal_points(self) -> list[float | int]:
         return self._internal_points
 
     @property
-    def physical_points(self) -> List[Union[float, int]]:
+    def physical_points(self) -> list[float | int]:
         return self._physical_points
 
     @property
@@ -59,7 +60,7 @@ class TabIntpCompuMethod(CompuMethod):
         return self._physical_upper_limit
 
     @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) -> "TabIntpCompuMethod":
         cm = CompuMethod.compu_method_from_et(
@@ -72,16 +73,16 @@ class TabIntpCompuMethod(CompuMethod):
         odxassert(self.category == CompuCategory.TAB_INTP,
                   "TabIntpCompuMethod must exibit TAB-INTP category")
 
-        self._internal_points: List[Union[int, float]] = []
-        self._physical_points: List[Union[int, float]] = []
+        self._internal_points: list[int | float] = []
+        self._physical_points: list[int | float] = []
         for scale in odxrequire(self.compu_internal_to_phys).compu_scales:
             internal_point = odxrequire(scale.lower_limit).value
             physical_point = odxrequire(scale.compu_const).value
 
-            if not isinstance(internal_point, (float, int)):
+            if not isinstance(internal_point, float | int):
                 odxraise("The type of values of tab-intp compumethods must "
                          "either int or float")
-            if not isinstance(physical_point, (float, int)):
+            if not isinstance(physical_point, float | int):
                 odxraise("The type of values of tab-intp compumethods must "
                          "either int or float")
 
@@ -128,10 +129,8 @@ class TabIntpCompuMethod(CompuMethod):
             ], "Physical data type of TAB-INTP compumethod must be one of"
             " [A_INT32, A_UINT32, A_FLOAT32, A_FLOAT64]")
 
-    def __piecewise_linear_interpolate(self, x: Union[int, float],
-                                       range_samples: List[Union[int, float]],
-                                       domain_samples: List[Union[int,
-                                                                  float]]) -> Union[float, None]:
+    def __piecewise_linear_interpolate(self, x: int | float, range_samples: list[int | float],
+                                       domain_samples: list[int | float]) -> float | None:
         for i in range(0, len(range_samples) - 1):
             if (x0 := range_samples[i]) <= x and x <= (x1 := range_samples[i + 1]):
                 y0 = domain_samples[i]
@@ -141,13 +140,13 @@ class TabIntpCompuMethod(CompuMethod):
         return None
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
-        if not isinstance(physical_value, (int, float)):
+        if not isinstance(physical_value, int | float):
             odxraise("The type of values of tab-intp compumethods must "
                      "either int or float", EncodeError)
             return None
 
         odxassert(
-            isinstance(physical_value, (int, float)),
+            isinstance(physical_value, int | float),
             "Only integers and floats can be piecewise linearly interpolated", EncodeError)
         result = self.__piecewise_linear_interpolate(physical_value, self._physical_points,
                                                      self._internal_points)
@@ -162,14 +161,14 @@ class TabIntpCompuMethod(CompuMethod):
         return res
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
-        if not isinstance(internal_value, (int, float)):
+        if not isinstance(internal_value, int | float):
             odxraise(
                 "The internal type of values of tab-intp compumethods must "
                 "either int or float", EncodeError)
             return None
 
         odxassert(
-            isinstance(internal_value, (int, float)),
+            isinstance(internal_value, int | float),
             "Only integers and floats can be piecewise linearly interpolated", DecodeError)
 
         result = self.__piecewise_linear_interpolate(internal_value, self._internal_points,
@@ -186,14 +185,14 @@ class TabIntpCompuMethod(CompuMethod):
         return res
 
     def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
-        if not isinstance(physical_value, (int, float)):
+        if not isinstance(physical_value, int | float):
             return False
 
         return min(self.physical_points) <= physical_value and physical_value <= max(
             self.physical_points)
 
     def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
-        if not isinstance(internal_value, (int, float)):
+        if not isinstance(internal_value, int | float):
             return False
 
         return min(self.internal_points) <= internal_value and internal_value <= max(

odxtools/compumethods/texttablecompumethod.py

@@ -1,13 +1,14 @@
 # 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
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
 from .compuscale import CompuScale
 
 
@@ -21,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(
@@ -94,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())