odxtools 6.6.1__py3-none-any.whl → 6.7.0__py3-none-any.whl

odxtools/compumethods/createanycompumethod.py

@@ -1,16 +1,14 @@
 # SPDX-License-Identifier: MIT
-import warnings
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from ..exceptions import OdxWarning, odxassert, odxraise, odxrequire
-from ..globals import logger
+from ..exceptions import odxassert, odxraise, odxrequire
 from ..odxlink import OdxDocFragment
 from ..odxtypes import DataType
 from .compumethod import CompuMethod
 from .compuscale import CompuScale
 from .identicalcompumethod import IdenticalCompuMethod
-from .limit import IntervalType, Limit
+from .limit import Limit
 from .linearcompumethod import LinearCompuMethod
 from .scalelinearcompumethod import ScaleLinearCompuMethod
 from .tabintpcompumethod import TabIntpCompuMethod
@@ -18,8 +16,9 @@ from .texttablecompumethod import TexttableCompuMethod
 
 
 def _parse_compu_scale_to_linear_compu_method(
+    et_element: ElementTree.Element,
+    doc_frags: List[OdxDocFragment],
     *,
-    scale_element: ElementTree.Element,
     internal_type: DataType,
     physical_type: DataType,
     is_scale_linear: bool = False,
@@ -38,7 +37,7 @@ def _parse_compu_scale_to_linear_compu_method(
         DataType.A_UINT32,
     ])
 
-    if physical_type.as_python_type() == float:
+    if physical_type.python_type == float:
         computation_python_type = physical_type.from_string
     else:
         computation_python_type = internal_type.from_string
@@ -47,7 +46,7 @@ def _parse_compu_scale_to_linear_compu_method(
     kwargs["internal_type"] = internal_type
     kwargs["physical_type"] = physical_type
 
-    coeffs = odxrequire(scale_element.find("COMPU-RATIONAL-COEFFS"))
+    coeffs = odxrequire(et_element.find("COMPU-RATIONAL-COEFFS"))
     nums = coeffs.iterfind("COMPU-NUMERATOR/V")
 
     offset = computation_python_type(odxrequire(next(nums).text))
@@ -57,32 +56,24 @@ def _parse_compu_scale_to_linear_compu_method(
     if (string := coeffs.findtext("COMPU-DENOMINATOR/V")) is not None:
         denominator = float(string)
         if denominator == 0:
-            warnings.warn(
-                "CompuMethod: A denominator of zero will lead to divisions by zero.",
-                OdxWarning,
-                stacklevel=1)
+            odxraise("CompuMethod: A denominator of zero will lead to divisions by zero.")
+
     # Read lower limit
-    internal_lower_limit = Limit.from_et(
-        scale_element.find("LOWER-LIMIT"),
-        internal_type=internal_type,
+    internal_lower_limit = Limit.limit_from_et(
+        et_element.find("LOWER-LIMIT"),
+        doc_frags,
+        value_type=internal_type,
     )
-    if internal_lower_limit is None:
-        internal_lower_limit = Limit(0, IntervalType.INFINITE)
+
     kwargs["internal_lower_limit"] = internal_lower_limit
 
     # Read upper limit
-    internal_upper_limit = Limit.from_et(
-        scale_element.find("UPPER-LIMIT"),
-        internal_type=internal_type,
+    internal_upper_limit = Limit.limit_from_et(
+        et_element.find("UPPER-LIMIT"),
+        doc_frags,
+        value_type=internal_type,
     )
-    if internal_upper_limit is None:
-        if not is_scale_linear:
-            internal_upper_limit = Limit(0, IntervalType.INFINITE)
-        else:
-            odxassert(internal_lower_limit is not None and
-                      internal_lower_limit.interval_type == IntervalType.CLOSED)
-            logger.info("Scale linear without UPPER-LIMIT")
-            internal_upper_limit = internal_lower_limit
+
     kwargs["internal_upper_limit"] = internal_upper_limit
     kwargs["denominator"] = denominator
     kwargs["factor"] = factor
@@ -92,19 +83,19 @@ def _parse_compu_scale_to_linear_compu_method(
 
 
 def create_compu_default_value(et_element: Optional[ElementTree.Element],
-                               doc_frags: List[OdxDocFragment], internal_type: DataType,
+                               doc_frags: List[OdxDocFragment], internal_type: DataType, *,
                                physical_type: DataType) -> Optional[CompuScale]:
     if et_element is None:
         return None
     compu_const = physical_type.create_from_et(et_element)
-    scale = CompuScale.from_et(
+    scale = CompuScale.compuscale_from_et(
         et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
     scale.compu_const = compu_const
     return scale
 
 
 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 = et_element.findtext("CATEGORY")
     odxassert(compu_category in [
@@ -142,7 +133,7 @@ def create_any_compu_method_from_et(et_element: ElementTree.Element,
         internal_to_phys: List[CompuScale] = []
         for scale_elem in compu_internal_to_phys.iterfind("COMPU-SCALES/COMPU-SCALE"):
             internal_to_phys.append(
-                CompuScale.from_et(
+                CompuScale.compuscale_from_et(
                     scale_elem, doc_frags, internal_type=internal_type,
                     physical_type=physical_type))
         compu_default_value = create_compu_default_value(
@@ -158,13 +149,13 @@ def create_any_compu_method_from_et(et_element: ElementTree.Element,
         # Compu method can be described by the function f(x) = (offset + factor * x) / denominator
 
         scale_elem = odxrequire(et_element.find("COMPU-INTERNAL-TO-PHYS/COMPU-SCALES/COMPU-SCALE"))
-        return _parse_compu_scale_to_linear_compu_method(scale_element=scale_elem, **kwargs)
+        return _parse_compu_scale_to_linear_compu_method(scale_elem, doc_frags, **kwargs)
 
     elif compu_category == "SCALE-LINEAR":
 
         scale_elems = et_element.iterfind("COMPU-INTERNAL-TO-PHYS/COMPU-SCALES/COMPU-SCALE")
         linear_methods = [
-            _parse_compu_scale_to_linear_compu_method(scale_element=scale_elem, **kwargs)
+            _parse_compu_scale_to_linear_compu_method(scale_elem, doc_frags, **kwargs)
             for scale_elem in scale_elems
         ]
         return ScaleLinearCompuMethod(linear_methods=linear_methods, **kwargs)
@@ -189,6 +180,7 @@ def create_any_compu_method_from_et(et_element: ElementTree.Element,
         return TabIntpCompuMethod(
             internal_points=internal_points, physical_points=physical_points, **kwargs)
 
-    # TODO: Implement other categories (never instantiate CompuMethod)
-    logger.warning(f"Warning: Computation category {compu_category} is not implemented!")
+    # TODO: Implement all categories (never instantiate the CompuMethod base class!)
+    odxraise(f"Warning: Computation category {compu_category} is not implemented!")
+
     return IdenticalCompuMethod(internal_type=DataType.A_UINT32, physical_type=DataType.A_UINT32)

odxtools/compumethods/limit.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
+from typing import List, Optional, overload
 from xml.etree import ElementTree
 
-from ..exceptions import odxassert, odxraise, odxrequire
-from ..odxtypes import AtomicOdxType, DataType
+from ..exceptions import odxraise
+from ..odxlink import OdxDocFragment
+from ..odxtypes import AtomicOdxType, DataType, compare_odx_values
 
 
 class IntervalType(Enum):
@@ -16,42 +17,54 @@ class IntervalType(Enum):
 
 @dataclass
 class Limit:
-    value: AtomicOdxType
-    interval_type: IntervalType = IntervalType.CLOSED
+    value_raw: Optional[str]
+    value_type: Optional[DataType]
+    interval_type: Optional[IntervalType]
 
     def __post_init__(self) -> None:
-        if self.interval_type == IntervalType.INFINITE:
-            self.value = 0
+        self._value: Optional[AtomicOdxType] = None
+
+        if self.value_type is not None:
+            self.set_value_type(self.value_type)
+
+    @staticmethod
+    @overload
+    def limit_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment],
+                      value_type: Optional[DataType]) -> "Limit":
+        ...
+
+    @staticmethod
+    @overload
+    def limit_from_et(et_element: None, doc_frags: List[OdxDocFragment],
+                      value_type: Optional[DataType]) -> None:
+        ...
 
     @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element], *,
-                internal_type: DataType) -> Optional["Limit"]:
+    def limit_from_et(et_element: Optional[ElementTree.Element], doc_frags: List[OdxDocFragment],
+                      value_type: Optional[DataType]) -> Optional["Limit"]:
 
         if et_element is None:
             return None
 
+        interval_type = None
         if (interval_type_str := et_element.get("INTERVAL-TYPE")) is not None:
             try:
                 interval_type = IntervalType(interval_type_str)
             except ValueError:
-                interval_type = IntervalType.CLOSED
                 odxraise(f"Encountered unknown interval type '{interval_type_str}'")
-        else:
-            interval_type = IntervalType.CLOSED
-
-        if interval_type == IntervalType.INFINITE:
-            if et_element.tag == "LOWER-LIMIT":
-                return Limit(float("-inf"), interval_type)
-            else:
-                odxassert(et_element.tag == "UPPER-LIMIT")
-                return Limit(float("inf"), interval_type)
-        elif internal_type == DataType.A_BYTEFIELD:
-            hex_text = odxrequire(et_element.text)
-            if len(hex_text) % 2 == 1:
-                hex_text = "0" + hex_text
-            return Limit(bytes.fromhex(hex_text), interval_type)
-        else:
-            return Limit(internal_type.from_string(odxrequire(et_element.text)), interval_type)
+
+        value_raw = et_element.text
+
+        return Limit(value_raw=value_raw, interval_type=interval_type, value_type=value_type)
+
+    def set_value_type(self, value_type: DataType) -> None:
+        self.value_type = value_type
+        if self.value_raw is not None:
+            self._value = value_type.from_string(self.value_raw)
+
+    @property
+    def value(self) -> Optional[AtomicOdxType]:
+        return self._value
 
     def complies_to_upper(self, value: AtomicOdxType) -> bool:
         """Checks if the value is in the range w.r.t. the upper limit.
@@ -60,13 +73,23 @@ class Limit:
         * If the interval type is open, return `value < limit.value`.
         * If the interval type is infinite, return `True`.
         """
-        if self.interval_type == IntervalType.CLOSED:
-            return value <= self.value  # type: ignore[operator]
-        elif self.interval_type == IntervalType.OPEN:
-            return value < self.value  # type: ignore[operator]
-        elif self.interval_type == IntervalType.INFINITE:
+        if self._value is None:
+            # if no value is specified, assume interval type INFINITE
+            # (what are we supposed to compare against?)
             return True
 
+        if self.interval_type is None or self.interval_type == IntervalType.CLOSED:
+            # assume interval type CLOSED if a value was specified,
+            # but no interval type
+            return compare_odx_values(value, self._value) <= 0
+        elif self.interval_type == IntervalType.OPEN:
+            return compare_odx_values(value, self._value) < 0
+
+        if self.interval_type != IntervalType.INFINITE:
+            odxraise("Unhandled interval type {self.interval_type}")
+
+        return True
+
     def complies_to_lower(self, value: AtomicOdxType) -> bool:
         """Checks if the value is in the range w.r.t. the lower limit.
 
@@ -74,9 +97,20 @@ class Limit:
         * If the interval type is open, return `limit.value < value`.
         * If the interval type is infinite, return `True`.
         """
-        if self.interval_type == IntervalType.CLOSED:
-            return self.value <= value  # type: ignore[operator]
-        elif self.interval_type == IntervalType.OPEN:
-            return self.value < value  # type: ignore[operator]
-        elif self.interval_type == IntervalType.INFINITE:
+
+        if self._value is None:
+            # if no value is specified, assume interval type INFINITE
+            # (what are we supposed to compare against?)
             return True
+
+        if self.interval_type is None or self.interval_type == IntervalType.CLOSED:
+            # assume interval type CLOSED if a value was specified,
+            # but no interval type
+            return compare_odx_values(value, self._value) >= 0
+        elif self.interval_type == IntervalType.OPEN:
+            return compare_odx_values(value, self._value) > 0
+
+        if self.interval_type != IntervalType.INFINITE:
+            odxraise("Unhandled interval type {self.interval_type}")
+
+        return True

odxtools/compumethods/linearcompumethod.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import cast
+from typing import Optional
 
-from ..exceptions import DecodeError, EncodeError, odxassert
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
 from ..odxtypes import AtomicOdxType, DataType
 from .compumethod import CompuMethod, CompuMethodCategory
-from .limit import IntervalType, Limit
+from .limit import Limit
 
 
 @dataclass
@@ -60,8 +60,8 @@ class LinearCompuMethod(CompuMethod):
     offset: float
     factor: float
     denominator: float
-    internal_lower_limit: Limit
-    internal_upper_limit: Limit
+    internal_lower_limit: Optional[Limit]
+    internal_upper_limit: Optional[Limit]
 
     def __post_init__(self) -> None:
         odxassert(self.denominator > 0)
@@ -73,11 +73,11 @@ class LinearCompuMethod(CompuMethod):
         return "LINEAR"
 
     @property
-    def physical_lower_limit(self) -> Limit:
+    def physical_lower_limit(self) -> Optional[Limit]:
         return self._physical_lower_limit
 
     @property
-    def physical_upper_limit(self) -> Limit:
+    def physical_upper_limit(self) -> Optional[Limit]:
         return self._physical_upper_limit
 
     def __compute_physical_limits(self) -> None:
@@ -86,65 +86,61 @@ class LinearCompuMethod(CompuMethod):
         This method is only called during the initialization of a LinearCompuMethod.
         """
 
-        def convert_to_limit_to_physical(limit: Limit, is_upper_limit: bool) -> Limit:
+        def convert_internal_to_physical_limit(internal_limit: Optional[Limit],
+                                               is_upper_limit: bool) -> Optional[Limit]:
             """Helper method
 
             Parameters:
 
-            limit
+            internal_limit
                 the internal limit to be converted to a physical limit
             is_upper_limit
                 True iff limit is the internal upper limit
             """
-            odxassert(isinstance(limit.value, (int, float)))
-            if limit.interval_type == IntervalType.INFINITE:
-                return limit
-            elif (limit.interval_type == limit.interval_type.OPEN and
-                  self.internal_type.as_python_type() == int):
-                closed_limit = limit.value - 1 if is_upper_limit else limit.value + 1
-                return Limit(
-                    value=self._convert_internal_to_physical(closed_limit),
-                    interval_type=IntervalType.CLOSED,
-                )
-            else:
-                return Limit(
-                    value=self._convert_internal_to_physical(limit.value),
-                    interval_type=limit.interval_type,
-                )
+            if internal_limit is None or internal_limit.value_raw is None:
+                return None
+
+            internal_value = self.internal_type.from_string(internal_limit.value_raw)
+            physical_value = self._convert_internal_to_physical(internal_value)
+
+            result = Limit(
+                value_raw=str(physical_value),
+                value_type=self.physical_type,
+                interval_type=internal_limit.interval_type)
+
+            return result
+
+        self._physical_lower_limit = None
+        self._physical_upper_limit = None
 
         if self.factor >= 0:
-            self._physical_lower_limit = convert_to_limit_to_physical(self.internal_lower_limit,
-                                                                      False)
-            self._physical_upper_limit = convert_to_limit_to_physical(self.internal_upper_limit,
-                                                                      True)
+            self._physical_lower_limit = convert_internal_to_physical_limit(
+                self.internal_lower_limit, False)
+            self._physical_upper_limit = convert_internal_to_physical_limit(
+                self.internal_upper_limit, True)
         else:
             # If the factor is negative, the lower and upper limit are swapped
-            self._physical_lower_limit = convert_to_limit_to_physical(self.internal_upper_limit,
-                                                                      True)
-            self._physical_upper_limit = convert_to_limit_to_physical(self.internal_lower_limit,
-                                                                      False)
-
-        if self.physical_type == DataType.A_UINT32:
-            # If the data type is unsigned, the physical lower limit should be at least 0.
-            if (self._physical_lower_limit.interval_type == IntervalType.INFINITE or
-                    cast(float, self._physical_lower_limit.value) < 0):
-                self._physical_lower_limit = Limit(value=0, interval_type=IntervalType.CLOSED)
+            self._physical_lower_limit = convert_internal_to_physical_limit(
+                self.internal_upper_limit, True)
+            self._physical_upper_limit = convert_internal_to_physical_limit(
+                self.internal_lower_limit, False)
 
     def _convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         if not isinstance(internal_value, (int, float)):
-            raise DecodeError("The type of internal values of linear compumethods must "
-                              "either int or float")
+            raise DecodeError(f"The type of internal values of linear compumethods must "
+                              f"either int or float (is: {type(internal_value).__name__})")
 
         if self.denominator is None:
             result = self.offset + self.factor * internal_value
         else:
             result = (self.offset + self.factor * internal_value) / self.denominator
 
-        if self.internal_type == DataType.A_FLOAT64 and self.physical_type in [
+        if self.physical_type in [
                 DataType.A_INT32,
                 DataType.A_UINT32,
         ]:
             result = round(result)
+
         return self.physical_type.make_from(result)
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
@@ -153,8 +149,10 @@ class LinearCompuMethod(CompuMethod):
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         if not isinstance(physical_value, (int, float)):
-            raise EncodeError("The type of physical values of linear compumethods must "
-                              "either int or float")
+            odxraise(
+                "The type of physical values of linear compumethods must "
+                "either int or float", EncodeError)
+            return 0
 
         odxassert(
             self.is_valid_physical_value(physical_value),
@@ -166,7 +164,7 @@ class LinearCompuMethod(CompuMethod):
         else:
             result = ((physical_value * self.denominator) - self.offset) / self.factor
 
-        if self.physical_type == DataType.A_FLOAT64 and self.internal_type in [
+        if self.internal_type in [
                 DataType.A_INT32,
                 DataType.A_UINT32,
         ]:
@@ -175,29 +173,40 @@ class LinearCompuMethod(CompuMethod):
 
     def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
         # Do type checks
-        expected_type = self.physical_type.as_python_type()
-        if expected_type == float and not isinstance(physical_value, (int, float)):
-            return False
-        elif expected_type != float and not isinstance(physical_value, expected_type):
-            return False
+        expected_type = self.physical_type.python_type
+        if issubclass(expected_type, float):
+            if not isinstance(physical_value, (int, float)):
+                return False
+        else:
+            if not isinstance(physical_value, expected_type):
+                return False
 
-        # Compare to the limits
-        if not self.physical_lower_limit.complies_to_lower(physical_value):
+        # Check the limits
+        if self.physical_lower_limit is not None and not self.physical_lower_limit.complies_to_lower(
+                physical_value):
             return False
-        if not self.physical_upper_limit.complies_to_upper(physical_value):
+        if self.physical_upper_limit is not None and not self.physical_upper_limit.complies_to_upper(
+                physical_value):
             return False
+
         return True
 
     def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
-        expected_type = self.internal_type.as_python_type()
-        if expected_type == float and not isinstance(internal_value, (int, float)):
-            return False
-        elif expected_type != float and not isinstance(internal_value, expected_type):
-            return False
+        # Do type checks
+        expected_type = self.internal_type.python_type
+        if issubclass(expected_type, float):
+            if not isinstance(internal_value, (int, float)):
+                return False
+        else:
+            if not isinstance(internal_value, expected_type):
+                return False
 
-        if not self.internal_lower_limit.complies_to_lower(internal_value):
+        # Check the limits
+        if self.internal_lower_limit is not None and not self.internal_lower_limit.complies_to_lower(
+                internal_value):
             return False
-        if not self.internal_upper_limit.complies_to_upper(internal_value):
+        if self.internal_upper_limit is not None and not self.internal_upper_limit.complies_to_upper(
+                internal_value):
             return False
 
         return True

odxtools/compumethods/tabintpcompumethod.py

@@ -69,8 +69,23 @@ class TabIntpCompuMethod(CompuMethod):
     physical_points: List[Union[float, int]]
 
     def __post_init__(self) -> None:
-        self._physical_lower_limit = Limit(min(self.physical_points), IntervalType.CLOSED)
-        self._physical_upper_limit = Limit(max(self.physical_points), IntervalType.CLOSED)
+        self._physical_lower_limit = Limit(
+            value_raw=str(min(self.physical_points)),
+            value_type=self.physical_type,
+            interval_type=IntervalType.CLOSED)
+        self._physical_upper_limit = Limit(
+            value_raw=str(max(self.physical_points)),
+            value_type=self.physical_type,
+            interval_type=IntervalType.CLOSED)
+
+        self._internal_lower_limit = Limit(
+            value_raw=str(min(self.internal_points)),
+            value_type=self.internal_type,
+            interval_type=IntervalType.CLOSED)
+        self._internal_upper_limit = Limit(
+            value_raw=str(max(self.internal_points)),
+            value_type=self.internal_type,
+            interval_type=IntervalType.CLOSED)
 
         self._assert_validity()
 
@@ -124,9 +139,7 @@ class TabIntpCompuMethod(CompuMethod):
         odxassert(
             isinstance(physical_value, (int, float)),
             "Only integers and floats can be piecewise linearly interpolated")
-        result = self._piecewise_linear_interpolate(
-            physical_value,  # type: ignore[arg-type]
-            reference_points)
+        result = self._piecewise_linear_interpolate(physical_value, reference_points)
 
         if result is None:
             raise EncodeError(f"Internal value {physical_value!r} must be inside the range"
@@ -142,9 +155,7 @@ class TabIntpCompuMethod(CompuMethod):
                               "either int or float")
 
         reference_points = list(zip(self.internal_points, self.physical_points))
-        result = self._piecewise_linear_interpolate(
-            internal_value,  # type: ignore[arg-type]
-            reference_points)
+        result = self._piecewise_linear_interpolate(internal_value, reference_points)
 
         if result is None:
             raise DecodeError(f"Internal value {internal_value!r} must be inside the range"

odxtools/compumethods/texttablecompumethod.py

@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List, Optional, cast
 
-from ..exceptions import DecodeError, EncodeError, odxassert
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
 from ..odxtypes import AtomicOdxType, DataType
 from .compumethod import CompuMethod, CompuMethodCategory
 from .compuscale import CompuScale
@@ -28,53 +28,49 @@ class TexttableCompuMethod(CompuMethod):
     def category(self) -> CompuMethodCategory:
         return "TEXTTABLE"
 
-    def get_scales(self) -> List[CompuScale]:
-        scales = list(self.internal_to_phys)
-        if self.compu_default_value:
-            # Default is last, since it's a fallback
-            scales.append(self.compu_default_value)
-        return scales
-
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
-        matching_scales = [x for x in self.get_scales() if x.compu_const == physical_value]
+        matching_scales = [x for x in self.internal_to_phys if x.compu_const == physical_value]
         for scale in matching_scales:
             if scale.compu_inverse_value is not None:
                 return scale.compu_inverse_value
-            elif scale.lower_limit is not None:
-                return scale.lower_limit.value
-            elif scale.upper_limit is not None:
-                return scale.upper_limit.value
+            elif scale.lower_limit is not None and scale.lower_limit._value is not None:
+                return scale.lower_limit._value
+            elif scale.upper_limit is not None and scale.upper_limit._value is not None:
+                return scale.upper_limit._value
+
+        if self.compu_default_value is not None and self.compu_default_value.compu_inverse_value is not None:
+            return self.compu_default_value.compu_inverse_value
 
         raise EncodeError(f"Texttable compu method could not encode '{physical_value!r}'.")
 
     def __is_internal_in_scale(self, internal_value: AtomicOdxType, scale: CompuScale) -> bool:
         if scale == self.compu_default_value:
             return True
-        if scale.lower_limit is not None and not scale.lower_limit.complies_to_lower(
-                internal_value):
-            return False
-        # If no UPPER-LIMIT is defined
-        # the COMPU-SCALE will be applied only for the value defined in LOWER-LIMIT
-        upper_limit = scale.upper_limit or scale.lower_limit
-        if upper_limit is not None and not upper_limit.complies_to_upper(internal_value):
-            return False
-        # value complies to the defined limits
-        return True
+
+        return scale.applies(internal_value)
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
-        scale = next(
-            filter(
-                lambda scale: self.__is_internal_in_scale(internal_value, scale),
-                self.get_scales(),
-            ), None)
-        if scale is None or scale.compu_const is None:
-            raise DecodeError(
-                f"Texttable compu method could not decode {internal_value!r} to string.")
-        return scale.compu_const
+        matching_scales = [x for x in self.internal_to_phys if x.applies(internal_value)]
+        if len(matching_scales) == 0:
+            if self.compu_default_value is None or self.compu_default_value.compu_const is None:
+                odxraise(f"Texttable could not decode {internal_value!r}.", DecodeError)
+                return cast(None, AtomicOdxType)
+
+            return self.compu_default_value.compu_const
+
+        if len(matching_scales) != 1 or matching_scales[0].compu_const is None:
+            odxraise(f"Texttable could not decode {internal_value!r}.", DecodeError)
+
+        return matching_scales[0].compu_const
 
     def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
-        return any(x.compu_const == physical_value for x in self.get_scales())
+        if self.compu_default_value is not None:
+            return True
+
+        return any(x.compu_const == physical_value for x in self.internal_to_phys)
 
     def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
-        return any(
-            self.__is_internal_in_scale(internal_value, scale) for scale in self.get_scales())
+        if self.compu_default_value is not None:
+            return True
+
+        return any(scale.applies(internal_value) for scale in self.internal_to_phys)