odxtools 7.1.1__py3-none-any.whl → 7.2.0__py3-none-any.whl

odxtools/compumethods/tabintpcompumethod.py

@@ -1,107 +1,114 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Tuple, Union
+from typing import List, Union
+from xml.etree import ElementTree
 
-from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
-from .compumethod import CompuMethod, CompuMethodCategory
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuCategory, CompuMethod
 from .limit import IntervalType, Limit
 
 
 @dataclass
 class TabIntpCompuMethod(CompuMethod):
-    """
-    A compu method of type Tab Interpolated is used for linear interpolation.
-
-    A `TabIntpCompuMethod` is defined by a set of points. Each point is an (internal, physical) value pair.
-    When converting from internal to physical or vice-versa, the result is linearly interpolated.
-
-    The function defined by a `TabIntpCompuMethod` is similar to the one of a `ScaleLinearCompuMethod` with the following differences:
-
-    * `TabIntpCompuMethod`s are always continuous whereas `ScaleLinearCompuMethod` might have jumps
-    * `TabIntpCompuMethod`s are always invertible: Even if the linear interpolation is not monotonic, the first matching interval is taken.
-
-    Refer to ASAM MCD-2 D (ODX) Specification, section 7.3.6.6.8 for details.
-
-    Examples
-    --------
-
-    Create a TabIntpCompuMethod defined by the points (0, -1), (10, 1), (30, 2)::
-
-        method = TabIntpCompuMethod(
-            internal_type=DataType.A_UINT32,
-            physical_type=DataType.A_UINT32,
-            internal_points=[0, 10, 30],
-            physical_points=[-1, 1, 2]
-        )
-
-    Note that the points are given as two lists. The equivalent odx definition is::
-
-        <COMPU-METHOD>
-            <CATEGORY>TAB-INTP</CATEGORY>
-            <COMPU-INTERNAL-TO-PHYS>
-                <COMPU-SCALES>
-                    <COMPU-SCALE>
-                        <LOWER-LIMIT INTERVAL-TYPE = "CLOSED">0</LOWER-LIMIT>
-                        <COMPU-CONST>
-                            <V>-1</V>
-                        </COMPU-CONST>
-                    </COMPU-SCALE>
-                    <COMPU-SCALE>
-                        <LOWER-LIMIT INTERVAL-TYPE = "CLOSED">10</LOWER-LIMIT>
-                        <COMPU-CONST>
-                            <V>1</V>
-                        </COMPU-CONST>
-                    </COMPU-SCALE>
-                    <COMPU-SCALE>
-                        <LOWER-LIMIT INTERVAL-TYPE = "CLOSED">30</LOWER-LIMIT>
-                        <COMPU-CONST>
-                            <V>2</V>
-                        </COMPU-CONST>
-                    </COMPU-SCALE>
-                </COMPU-SCALES>
-            </COMPU-INTERNAL-TO-PHYS>
-        </COMPU-METHOD>
+    """A table-based interpolated compu method provides a continuous
+    transfer function based on piecewise linear interpolation.
+
+    A `TabIntpCompuMethod` is defined by a set of points. Each point
+    is an (internal, physical) value pair.  When converting from
+    internal to physical or vice-versa, the result is linearly
+    interpolated.
+
+    The function defined by a `TabIntpCompuMethod` is similar to the
+    one of a `ScaleLinearCompuMethod` with the following differences:
+
+    * `TabIntpCompuMethod`s are always continuous whereas
+      `ScaleLinearCompuMethod` might exhibit gaps
+    * `TabIntpCompuMethod`s are always invertible: Even if the linear
+      interpolation is not monotonic, the first matching interval is
+      used.
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.8.
 
     """
 
-    internal_points: List[Union[float, int]]
-    physical_points: List[Union[float, int]]
+    @property
+    def internal_points(self) -> List[Union[float, int]]:
+        return self._internal_points
+
+    @property
+    def physical_points(self) -> List[Union[float, int]]:
+        return self._physical_points
+
+    @property
+    def internal_lower_limit(self) -> Limit:
+        return self._internal_lower_limit
+
+    @property
+    def internal_upper_limit(self) -> Limit:
+        return self._internal_upper_limit
+
+    @property
+    def physical_lower_limit(self) -> Limit:
+        return self._physical_lower_limit
+
+    @property
+    def physical_upper_limit(self) -> Limit:
+        return self._physical_upper_limit
+
+    @staticmethod
+    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(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return TabIntpCompuMethod(**kwargs)
 
     def __post_init__(self) -> None:
+        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]] = []
+        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)):
+                odxraise("The type of values of tab-intp compumethods must "
+                         "either int or float")
+            if not isinstance(physical_point, (float, int)):
+                odxraise("The type of values of tab-intp compumethods must "
+                         "either int or float")
+
+            self._internal_points.append(internal_point)
+            self._physical_points.append(physical_point)
+
         self._physical_lower_limit = Limit(
-            value_raw=str(min(self.physical_points)),
+            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_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_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_raw=str(max(self._internal_points)),
             value_type=self.internal_type,
             interval_type=IntervalType.CLOSED)
 
-        self._assert_validity()
-
-    @property
-    def category(self) -> CompuMethodCategory:
-        return "TAB-INTP"
-
-    @property
-    def physical_lower_limit(self) -> Limit:
-        return self._physical_lower_limit
+        self.__assert_validity()
 
-    @property
-    def physical_upper_limit(self) -> Limit:
-        return self._physical_upper_limit
-
-    def _assert_validity(self) -> None:
+    def __assert_validity(self) -> None:
         odxassert(len(self.internal_points) == len(self.physical_points))
 
         odxassert(
@@ -110,7 +117,7 @@ class TabIntpCompuMethod(CompuMethod):
                 DataType.A_UINT32,
                 DataType.A_FLOAT32,
                 DataType.A_FLOAT64,
-            ], "Internal data type of tab-intp compumethod must be one of"
+            ], "Internal data type of TAB-INTP compumethod must be one of"
             " [A_INT32, A_UINT32, A_FLOAT32, A_FLOAT64]")
         odxassert(
             self.physical_type in [
@@ -118,51 +125,64 @@ class TabIntpCompuMethod(CompuMethod):
                 DataType.A_UINT32,
                 DataType.A_FLOAT32,
                 DataType.A_FLOAT64,
-            ], "Physical data type of tab-intp compumethod must be one of"
+            ], "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],
-                                      points: List[Tuple[Union[int, float],
-                                                         Union[int, float]]]) -> Union[float, None]:
-        for ((x0, y0), (x1, y1)) in zip(points[:-1], points[1:]):
-            if x0 <= x and x <= x1:
+    def __piecewise_linear_interpolate(self, x: Union[int, float],
+                                       range_samples: List[Union[int, float]],
+                                       domain_samples: List[Union[int,
+                                                                  float]]) -> Union[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]
+                y1 = domain_samples[i + 1]
                 return y0 + (x - x0) * (y1 - y0) / (x1 - x0)
 
         return None
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         if not isinstance(physical_value, (int, float)):
-            raise EncodeError("The type of values of tab-intp compumethods must "
-                              "either int or float")
+            odxraise("The type of values of tab-intp compumethods must "
+                     "either int or float", EncodeError)
+            return None
 
-        reference_points = list(zip(self.physical_points, self.internal_points))
         odxassert(
             isinstance(physical_value, (int, float)),
-            "Only integers and floats can be piecewise linearly interpolated")
-        result = self._piecewise_linear_interpolate(physical_value, reference_points)
+            "Only integers and floats can be piecewise linearly interpolated", EncodeError)
+        result = self.__piecewise_linear_interpolate(physical_value, self._physical_points,
+                                                     self._internal_points)
 
         if result is None:
-            raise EncodeError(f"Internal value {physical_value!r} must be inside the range"
-                              f" [{min(self.physical_points)}, {max(self.physical_points)}]")
+            odxraise(
+                f"Internal value {physical_value!r} must be inside the range"
+                f" [{min(self.physical_points)}, {max(self.physical_points)}]", EncodeError)
+
         res = self.internal_type.make_from(result)
-        if not isinstance(res, (int, float)):
-            odxraise()
+
         return res
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         if not isinstance(internal_value, (int, float)):
-            raise EncodeError("The internal type of values of tab-intp compumethods must "
-                              "either int or 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)),
+            "Only integers and floats can be piecewise linearly interpolated", DecodeError)
 
-        reference_points = list(zip(self.internal_points, self.physical_points))
-        result = self._piecewise_linear_interpolate(internal_value, reference_points)
+        result = self.__piecewise_linear_interpolate(internal_value, self._internal_points,
+                                                     self._physical_points)
 
         if result is None:
-            raise DecodeError(f"Internal value {internal_value!r} must be inside the range"
-                              f" [{min(self.internal_points)}, {max(self.internal_points)}]")
+            odxraise(
+                f"Internal value {internal_value!r} must be inside the range"
+                f" [{min(self.internal_points)}, {max(self.internal_points)}]", DecodeError)
+            return None
+
         res = self.physical_type.make_from(result)
-        if not isinstance(res, (int, float)):
-            odxraise()
+
         return res
 
     def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:

odxtools/compumethods/texttablecompumethod.py

@@ -1,76 +1,140 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, cast
+from typing import List, cast
+from xml.etree import ElementTree
 
-from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
-from .compumethod import CompuMethod, CompuMethodCategory
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuCategory, CompuMethod
 from .compuscale import CompuScale
 
 
 @dataclass
 class TexttableCompuMethod(CompuMethod):
+    """Text table compute methods translate numbers to human readable
+    textual descriptions.
 
-    internal_to_phys: List[CompuScale]
-    # For compu_default_value, the compu_const is always defined
-    # the compu_inverse_value is optional
-    compu_default_value: Optional[CompuScale]
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.7.
+
+    """
+
+    @staticmethod
+    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(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return TexttableCompuMethod(**kwargs)
 
     def __post_init__(self) -> None:
-        odxassert(self.physical_type == DataType.A_UNICODE2STRING,
-                  "TEXTTABLE must have A_UNICODE2STRING as its physical datatype.")
+        odxassert(self.category == CompuCategory.TEXTTABLE,
+                  "TexttableCompuMethod must exhibit TEXTTABLE category")
+
+        # the spec says that the physical data type shall be
+        # A_UNICODE2STRING, but we are a bit more lenient and allow
+        # any kind of string...
+        odxassert(
+            self.physical_type
+            in [DataType.A_UNICODE2STRING, DataType.A_UTF8STRING, DataType.A_ASCIISTRING],
+            "TEXTTABLE must have string type as its physical datatype.")
+
+        if self.compu_internal_to_phys is None:
+            odxraise("TEXTTABLE compu methods must exhibit a COMPU-INTERNAL-TO-PHYS subtag.")
+            scales = []
+        else:
+            scales = self.compu_internal_to_phys.compu_scales
+
         odxassert(
-            all(scale.lower_limit is not None or scale.upper_limit is not None
-                for scale in self.internal_to_phys),
-            "Text table compu method doesn't have expected format!")
+            all(scale.lower_limit is not None or scale.upper_limit is not None for scale in scales),
+            "All scales of TEXTTABLE compu methods must provide limits!")
+
+        self._compu_physical_default_value = None
+        citp = odxrequire(self.compu_internal_to_phys)
+        if (cdv := citp.compu_default_value) is not None:
+            self._compu_physical_default_value = self.physical_type.from_string(odxrequire(cdv.vt))
 
-    @property
-    def category(self) -> CompuMethodCategory:
-        return "TEXTTABLE"
+        self._compu_internal_default_value = None
+        cpti = self.compu_phys_to_internal
+        if cpti is not None and (cdv := cpti.compu_default_value) is not None:
+            self._compu_internal_default_value = self.internal_type.from_string(odxrequire(cdv.v))
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
-        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 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
+        scales = []
+        if (citp := self.compu_internal_to_phys) is not None:
+            scales = citp.compu_scales
+        matching_scales = [
+            x for x in scales if x.compu_const is not None and x.compu_const.value == physical_value
+        ]
+
+        if len(matching_scales) == 0:
+            if self._compu_internal_default_value is None:
+                odxraise(f"Texttable could not encode {physical_value!r}.", EncodeError)
+                return cast(None, AtomicOdxType)
+
+            return self._compu_internal_default_value
+        elif len(matching_scales) > 1:
+            odxraise(f"Texttable could not uniquely encode {physical_value!r}.", EncodeError)
 
-        return scale.applies(internal_value)
+        scale = matching_scales[0]
+        if scale.compu_inverse_value is not None and (civ :=
+                                                      scale.compu_inverse_value.value) is not None:
+            return civ
+        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
+
+        odxraise(f"Texttable compu method could not encode '{physical_value!r}'.", EncodeError)
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
-        matching_scales = [x for x in self.internal_to_phys if x.applies(internal_value)]
+        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)]
+
         if len(matching_scales) == 0:
-            if self.compu_default_value is None or self.compu_default_value.compu_const is None:
+            if self._compu_physical_default_value is None:
                 odxraise(f"Texttable could not decode {internal_value!r}.", DecodeError)
                 return cast(None, AtomicOdxType)
 
-            return self.compu_default_value.compu_const
+            return self._compu_physical_default_value
 
-        if len(matching_scales) != 1 or matching_scales[0].compu_const is None:
-            odxraise(f"Texttable could not decode {internal_value!r}.", DecodeError)
+        if len(matching_scales) > 1:
+            odxraise(f"Texttable could not uniquely decode {internal_value!r}.", DecodeError)
 
-        return matching_scales[0].compu_const
+        scale = matching_scales[0]
+
+        if scale.compu_const is None:
+            odxraise(f"Encountered a COMPU-SCALE with no COMPU-CONST.")
+            return cast(None, AtomicOdxType)
+
+        if scale.compu_const.value is not None:
+            return scale.compu_const.value
+
+        odxraise(f"Texttable compu method could not decode '{internal_value!r}'.", EncodeError)
 
     def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
-        if self.compu_default_value is not None:
+        if self._compu_physical_default_value is not None:
             return True
 
-        return any(x.compu_const == physical_value for x in self.internal_to_phys)
+        scales = []
+        if (cpti := self.compu_internal_to_phys) is not None:
+            scales = cpti.compu_scales
+
+        return any(scale.compu_const.value == physical_value
+                   for scale in scales
+                   if scale.compu_const is not None)
 
     def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
-        if self.compu_default_value is not None:
+        if self._compu_internal_default_value is not None:
             return True
 
-        return any(scale.applies(internal_value) for scale in self.internal_to_phys)
+        scales = []
+        if (citp := self.compu_internal_to_phys) is not None:
+            scales = citp.compu_scales
+
+        return any(scale.applies(internal_value) for scale in scales)

odxtools/createanydiagcodedtype.py

@@ -1,85 +1,28 @@
 # SPDX-License-Identifier: MIT
-from typing import List, cast
+from typing import List
 from xml.etree import ElementTree
 
 from .diagcodedtype import DiagCodedType
-from .exceptions import odxraise, odxrequire
+from .exceptions import odxraise
 from .globals import xsi
 from .leadinglengthinfotype import LeadingLengthInfoType
 from .minmaxlengthtype import MinMaxLengthType
-from .odxlink import OdxDocFragment, OdxLinkRef
-from .odxtypes import DataType, odxstr_to_bool
+from .odxlink import OdxDocFragment
 from .paramlengthinfotype import ParamLengthInfoType
 from .standardlengthtype import StandardLengthType
 
 
 def create_any_diag_coded_type_from_et(et_element: ElementTree.Element,
                                        doc_frags: List[OdxDocFragment]) -> DiagCodedType:
-    base_type_encoding = et_element.get("BASE-TYPE-ENCODING")
-
-    base_data_type_str = odxrequire(et_element.get("BASE-DATA-TYPE"))
-    try:
-        base_data_type = DataType(base_data_type_str)
-    except ValueError:
-        base_data_type = cast(DataType, None)
-        odxraise(f"Unknown base data type {base_data_type_str}")
-
-    is_highlow_byte_order_raw = odxstr_to_bool(et_element.get("IS-HIGHLOW-BYTE-ORDER"))
-
     dct_type = et_element.get(f"{xsi}type")
-    bit_length = None
     if dct_type == "LEADING-LENGTH-INFO-TYPE":
-        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
-        return LeadingLengthInfoType(
-            base_data_type=base_data_type,
-            bit_length=bit_length,
-            base_type_encoding=base_type_encoding,
-            is_highlow_byte_order_raw=is_highlow_byte_order_raw,
-        )
+        return LeadingLengthInfoType.from_et(et_element, doc_frags)
     elif dct_type == "MIN-MAX-LENGTH-TYPE":
-        min_length = int(odxrequire(et_element.findtext("MIN-LENGTH")))
-        max_length = None
-        if et_element.find("MAX-LENGTH") is not None:
-            max_length = int(odxrequire(et_element.findtext("MAX-LENGTH")))
-        termination = odxrequire(et_element.get("TERMINATION"))
-
-        return MinMaxLengthType(
-            base_data_type=base_data_type,
-            min_length=min_length,
-            max_length=max_length,
-            termination=termination,
-            base_type_encoding=base_type_encoding,
-            is_highlow_byte_order_raw=is_highlow_byte_order_raw,
-        )
+        return MinMaxLengthType.from_et(et_element, doc_frags)
     elif dct_type == "PARAM-LENGTH-INFO-TYPE":
-        length_key_ref = odxrequire(
-            OdxLinkRef.from_et(et_element.find("LENGTH-KEY-REF"), doc_frags))
-
-        return ParamLengthInfoType(
-            base_data_type=base_data_type,
-            length_key_ref=length_key_ref,
-            base_type_encoding=base_type_encoding,
-            is_highlow_byte_order_raw=is_highlow_byte_order_raw,
-        )
+        return ParamLengthInfoType.from_et(et_element, doc_frags)
     elif dct_type == "STANDARD-LENGTH-TYPE":
-        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
-        bit_mask = None
-        if (bit_mask_str := et_element.findtext("BIT-MASK")) is not None:
-            # The XSD uses the type xsd:hexBinary
-            # xsd:hexBinary allows for leading/trailing whitespace, empty strings, and it only allows an even
-            # number of hex digits, while some of the examples shown in the  ODX specification exhibit an
-            # odd number of hex digits.
-            # This causes a validation paradox, so we try to be flexible
-            bit_mask_str = bit_mask_str.strip()
-            if len(bit_mask_str):
-                bit_mask = int(bit_mask_str, 16)
-        is_condensed_raw = odxstr_to_bool(et_element.get("CONDENSED"))
-        return StandardLengthType(
-            base_data_type=base_data_type,
-            bit_length=bit_length,
-            bit_mask=bit_mask,
-            is_condensed_raw=is_condensed_raw,
-            base_type_encoding=base_type_encoding,
-            is_highlow_byte_order_raw=is_highlow_byte_order_raw,
-        )
-    raise NotImplementedError(f"I do not know the diag-coded-type {dct_type}")
+        return StandardLengthType.from_et(et_element, doc_frags)
+
+    odxraise(f"Unknown DIAG-CODED-TYPE {dct_type}", NotImplementedError)
+    return DiagCodedType.from_et(et_element, doc_frags)