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

odxtools/compumethods/compuinternaltophys.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 ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -13,13 +13,13 @@ from .compuscale import CompuScale
 
 @dataclass
 class CompuInternalToPhys:
-    compu_scales: List[CompuScale]
-    prog_code: Optional[ProgCode]
-    compu_default_value: Optional[CompuDefaultValue]
+    compu_scales: list[CompuScale]
+    prog_code: ProgCode | None
+    compu_default_value: CompuDefaultValue | None
 
     @staticmethod
     def compu_internal_to_phys_from_et(et_element: ElementTree.Element,
-                                       doc_frags: List[OdxDocFragment], *, internal_type: DataType,
+                                       doc_frags: list[OdxDocFragment], *, internal_type: DataType,
                                        physical_type: DataType) -> "CompuInternalToPhys":
         compu_scales = [
             CompuScale.compuscale_from_et(
@@ -39,7 +39,7 @@ class CompuInternalToPhys:
         return CompuInternalToPhys(
             compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.prog_code is not None:

odxtools/compumethods/compumethod.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise
@@ -31,14 +31,14 @@ class CompuMethod:
     """
 
     category: CompuCategory
-    compu_internal_to_phys: Optional[CompuInternalToPhys]
-    compu_phys_to_internal: Optional[CompuPhysToInternal]
+    compu_internal_to_phys: CompuInternalToPhys | None
+    compu_phys_to_internal: CompuPhysToInternal | None
 
     physical_type: DataType
     internal_type: DataType
 
     @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) -> "CompuMethod":
         cat_text = et_element.findtext("CATEGORY")
         if cat_text is None:
@@ -67,7 +67,7 @@ class CompuMethod:
             physical_type=physical_type,
             internal_type=internal_type)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.compu_internal_to_phys is not None:

odxtools/compumethods/compuphystointernal.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 ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -13,13 +13,13 @@ from .compuscale import CompuScale
 
 @dataclass
 class CompuPhysToInternal:
-    compu_scales: List[CompuScale]
-    prog_code: Optional[ProgCode]
-    compu_default_value: Optional[CompuDefaultValue]
+    compu_scales: list[CompuScale]
+    prog_code: ProgCode | None
+    compu_default_value: CompuDefaultValue | None
 
     @staticmethod
     def compu_phys_to_internal_from_et(et_element: ElementTree.Element,
-                                       doc_frags: List[OdxDocFragment], *, internal_type: DataType,
+                                       doc_frags: list[OdxDocFragment], *, internal_type: DataType,
                                        physical_type: DataType) -> "CompuPhysToInternal":
         compu_scales = [
             CompuScale.compuscale_from_et(
@@ -39,7 +39,7 @@ class CompuPhysToInternal:
         return CompuPhysToInternal(
             compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.prog_code is not None:

odxtools/compumethods/compurationalcoeffs.py

@@ -1,6 +1,6 @@
 # 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 odxassert, odxrequire
@@ -12,11 +12,11 @@ from ..odxtypes import DataType
 class CompuRationalCoeffs:
     value_type: DataType
 
-    numerators: List[Union[int, float]]
-    denominators: List[Union[int, float]]
+    numerators: list[int | float]
+    denominators: list[int | float]
 
     @staticmethod
-    def coeffs_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def coeffs_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                        value_type: DataType) -> "CompuRationalCoeffs":
         odxassert(
             value_type

odxtools/compumethods/compuscale.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from ..description import Description
@@ -17,13 +16,13 @@ class CompuScale:
     """A COMPU-SCALE represents one value range of a COMPU-METHOD.
     """
 
-    short_label: Optional[str]
-    description: Optional[Description]
-    lower_limit: Optional[Limit]
-    upper_limit: Optional[Limit]
-    compu_inverse_value: Optional[CompuInverseValue]
-    compu_const: Optional[CompuConst]
-    compu_rational_coeffs: Optional[CompuRationalCoeffs]
+    short_label: str | None
+    description: Description | None
+    lower_limit: Limit | None
+    upper_limit: Limit | None
+    compu_inverse_value: CompuInverseValue | None
+    compu_const: CompuConst | None
+    compu_rational_coeffs: CompuRationalCoeffs | None
 
     # the following two attributes are not specified for COMPU-SCALE
     # tags in the XML, but they are required to do anything useful
@@ -38,7 +37,7 @@ class CompuScale:
     range_type: DataType
 
     @staticmethod
-    def compuscale_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def compuscale_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                            domain_type: DataType, range_type: DataType) -> "CompuScale":
         short_label = et_element.findtext("SHORT-LABEL")
         description = Description.from_et(et_element.find("DESC"), doc_frags)
@@ -56,7 +55,7 @@ class CompuScale:
         if (cce := et_element.find("COMPU-CONST")) is not None:
             compu_const = CompuConst.compuvalue_from_et(cce, data_type=range_type)
 
-        compu_rational_coeffs: Optional[CompuRationalCoeffs] = None
+        compu_rational_coeffs: CompuRationalCoeffs | None = None
         if (crc_elem := et_element.find("COMPU-RATIONAL-COEFFS")) is not None:
             compu_rational_coeffs = CompuRationalCoeffs.coeffs_from_et(
                 crc_elem, doc_frags, value_type=range_type)

odxtools/compumethods/createanycompumethod.py

@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: MIT
-from typing import List
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise, odxrequire
@@ -17,7 +16,7 @@ from .texttablecompumethod import TexttableCompuMethod
 
 
 def create_any_compu_method_from_et(et_element: ElementTree.Element,
-                                    doc_frags: List[OdxDocFragment], *, internal_type: DataType,
+                                    doc_frags: list[OdxDocFragment], *, internal_type: DataType,
                                     physical_type: DataType) -> CompuMethod:
     compu_category = odxrequire(et_element.findtext("CATEGORY"))
 

odxtools/compumethods/identicalcompumethod.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
 from xml.etree import ElementTree
 
 from ..exceptions import odxassert
@@ -18,7 +17,7 @@ class IdenticalCompuMethod(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) -> "IdenticalCompuMethod":
         cm = CompuMethod.compu_method_from_et(

odxtools/compumethods/limit.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, overload
+from typing import Optional, overload
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise
@@ -11,29 +11,29 @@ 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
@@ -50,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,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
@@ -30,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,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 ..exceptions import DecodeError, EncodeError, odxassert, odxraise
@@ -30,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,6 +1,6 @@
 # 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
@@ -21,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(
@@ -35,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")
@@ -100,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
@@ -111,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 "
@@ -128,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,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 ..exceptions import DecodeError, EncodeError, odxassert, odxraise
@@ -20,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,6 +1,5 @@
 # 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
@@ -37,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
@@ -61,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(
@@ -74,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")
 
@@ -130,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]
@@ -143,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)
@@ -164,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,
@@ -188,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(