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

odxtools/compumethods/compuphystointernal.py

@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxtypes import DataType
+from ..progcode import ProgCode
+from ..snrefcontext import SnRefContext
+from .compudefaultvalue import CompuDefaultValue
+from .compuscale import CompuScale
+
+
+@dataclass
+class CompuPhysToInternal:
+    compu_scales: List[CompuScale]
+    prog_code: Optional[ProgCode]
+    compu_default_value: Optional[CompuDefaultValue]
+
+    @staticmethod
+    def compu_phys_to_internal_from_et(et_element: ElementTree.Element,
+                                       doc_frags: List[OdxDocFragment], *, internal_type: DataType,
+                                       physical_type: DataType) -> "CompuPhysToInternal":
+        compu_scales = [
+            CompuScale.compuscale_from_et(
+                cse, doc_frags, domain_type=physical_type, range_type=internal_type)
+            for cse in et_element.iterfind("COMPU-SCALES/COMPU-SCALE")
+        ]
+
+        prog_code = None
+        if (pce := et_element.find("PROG-CODE")) is not None:
+            prog_code = ProgCode.from_et(pce, doc_frags)
+
+        compu_default_value = None
+        if (cdve := et_element.find("COMPU-DEFAULT-VALUE")) is not None:
+            compu_default_value = CompuDefaultValue.compuvalue_from_et(
+                cdve, data_type=internal_type)
+
+        return CompuPhysToInternal(
+            compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {}
+
+        if self.prog_code is not None:
+            result.update(self.prog_code._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.prog_code is not None:
+            self.prog_code._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.prog_code is not None:
+            self.prog_code._resolve_snrefs(context)

odxtools/compumethods/compurationalcoeffs.py

@@ -1,25 +1,36 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import List, Union, cast
 from xml.etree import ElementTree
 
-from ..exceptions import odxrequire
+from ..exceptions import odxassert, odxrequire
 from ..odxlink import OdxDocFragment
+from ..odxtypes import DataType
 
 
 @dataclass
 class CompuRationalCoeffs:
-    numerators: List[float]
-    denominators: List[float]
+    value_type: DataType
+
+    numerators: List[Union[int, float]]
+    denominators: List[Union[int, float]]
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "CompuRationalCoeffs":
+    def coeffs_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                       value_type: DataType) -> "CompuRationalCoeffs":
+        odxassert(
+            value_type
+            in (DataType.A_UINT32, DataType.A_INT32, DataType.A_FLOAT32, DataType.A_FLOAT64),
+            "Rational coefficients must be of numeric type.")
+
         numerators = [
-            float(odxrequire(elem.text)) for elem in et_element.iterfind("COMPU-NUMERATOR/V")
+            cast(float, value_type.from_string(odxrequire(elem.text)))
+            for elem in et_element.iterfind("COMPU-NUMERATOR/V")
         ]
         denominators = [
-            float(odxrequire(elem.text)) for elem in et_element.iterfind("COMPU-DENOMINATOR/V")
+            cast(float, value_type.from_string(odxrequire(elem.text)))
+            for elem in et_element.iterfind("COMPU-DENOMINATOR/V")
         ]
 
-        return CompuRationalCoeffs(numerators=numerators, denominators=denominators)
+        return CompuRationalCoeffs(
+            value_type=value_type, numerators=numerators, denominators=denominators)

odxtools/compumethods/compuscale.py

@@ -3,9 +3,11 @@ from dataclasses import dataclass
 from typing import List, Optional
 from xml.etree import ElementTree
 
+from ..description import Description
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
-from ..utils import create_description_from_et
+from .compuconst import CompuConst
+from .compuinversevalue import CompuInverseValue
 from .compurationalcoeffs import CompuRationalCoeffs
 from .limit import Limit
 
@@ -13,58 +15,51 @@ from .limit import Limit
 @dataclass
 class CompuScale:
     """A COMPU-SCALE represents one value range of a COMPU-METHOD.
-
-    Example:
-
-    For a TEXTTABLE compu method a compu scale within COMPU-INTERNAL-TO-PHYS
-    can be defined with
-    ```
-    scale = CompuScale(
-        short_label="example_label", # optional: provide a label
-        description="<p>fancy description</p>", # optional: provide a description
-        lower_limit=Limit(0), # required: lower limit
-        upper_limit=Limit(3), # required: upper limit
-        compu_inverse_value=2, # required if lower_limit != upper_limit
-        compu_const="true", # required: physical value to be shown to the user
-    )
-    ```
-
-    Almost all attributes are optional but there are compu-method-specific restrictions.
-    E.g., lower_limit must always be defined unless the COMPU-METHOD is of CATEGORY LINEAR or RAT-FUNC.
-    Either `compu_const` or `compu_rational_coeffs` must be defined but never both.
     """
 
     short_label: Optional[str]
-    description: Optional[str]
+    description: Optional[Description]
     lower_limit: Optional[Limit]
     upper_limit: Optional[Limit]
-    compu_inverse_value: Optional[AtomicOdxType]
-    compu_const: Optional[AtomicOdxType]
+    compu_inverse_value: Optional[CompuInverseValue]
+    compu_const: Optional[CompuConst]
     compu_rational_coeffs: Optional[CompuRationalCoeffs]
 
     # the following two attributes are not specified for COMPU-SCALE
     # tags in the XML, but they are required to do anything useful
-    # with it.
-    internal_type: DataType
-    physical_type: DataType
+    # with compu scales: The domain type is the input set of the
+    # function associated with the compu scale object, whilst the
+    # range type represents the output set. IOW, for scales contained
+    # by the internal-to-physical mapping function, the domain type is
+    # the internal and the range type is the physical type of the
+    # compu method. (Vice versa for scales specified by the
+    # physical-to-internal mapping function.)
+    domain_type: DataType
+    range_type: DataType
 
     @staticmethod
     def compuscale_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
-                           internal_type: DataType, physical_type: DataType) -> "CompuScale":
+                           domain_type: DataType, range_type: DataType) -> "CompuScale":
         short_label = et_element.findtext("SHORT-LABEL")
-        description = create_description_from_et(et_element.find("DESC"))
+        description = Description.from_et(et_element.find("DESC"), doc_frags)
 
         lower_limit = Limit.limit_from_et(
-            et_element.find("LOWER-LIMIT"), doc_frags, value_type=internal_type)
+            et_element.find("LOWER-LIMIT"), doc_frags, value_type=domain_type)
         upper_limit = Limit.limit_from_et(
-            et_element.find("UPPER-LIMIT"), doc_frags, value_type=internal_type)
+            et_element.find("UPPER-LIMIT"), doc_frags, value_type=domain_type)
+
+        compu_inverse_value = None
+        if (cive := et_element.find("COMPU-INVERSE-VALUE")) is not None:
+            compu_inverse_value = CompuInverseValue.compuvalue_from_et(cive, data_type=domain_type)
 
-        compu_inverse_value = internal_type.create_from_et(et_element.find("COMPU-INVERSE-VALUE"))
-        compu_const = physical_type.create_from_et(et_element.find("COMPU-CONST"))
+        compu_const = None
+        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
         if (crc_elem := et_element.find("COMPU-RATIONAL-COEFFS")) is not None:
-            compu_rational_coeffs = CompuRationalCoeffs.from_et(crc_elem, doc_frags)
+            compu_rational_coeffs = CompuRationalCoeffs.coeffs_from_et(
+                crc_elem, doc_frags, value_type=range_type)
 
         return CompuScale(
             short_label=short_label,
@@ -74,8 +69,8 @@ class CompuScale:
             compu_inverse_value=compu_inverse_value,
             compu_const=compu_const,
             compu_rational_coeffs=compu_rational_coeffs,
-            internal_type=internal_type,
-            physical_type=physical_type)
+            domain_type=domain_type,
+            range_type=range_type)
 
     def applies(self, internal_value: AtomicOdxType) -> bool:
 

odxtools/compumethods/createanycompumethod.py

@@ -1,186 +1,53 @@
 # SPDX-License-Identifier: MIT
-from typing import Any, Dict, List, Optional
+from typing import List
 from xml.etree import ElementTree
 
-from ..exceptions import odxassert, odxraise, odxrequire
+from ..exceptions import odxraise, odxrequire
 from ..odxlink import OdxDocFragment
 from ..odxtypes import DataType
+from .compucodecompumethod import CompuCodeCompuMethod
 from .compumethod import CompuMethod
-from .compuscale import CompuScale
 from .identicalcompumethod import IdenticalCompuMethod
-from .limit import Limit
 from .linearcompumethod import LinearCompuMethod
+from .ratfunccompumethod import RatFuncCompuMethod
 from .scalelinearcompumethod import ScaleLinearCompuMethod
+from .scaleratfunccompumethod import ScaleRatFuncCompuMethod
 from .tabintpcompumethod import TabIntpCompuMethod
 from .texttablecompumethod import TexttableCompuMethod
 
 
-def _parse_compu_scale_to_linear_compu_method(
-    et_element: ElementTree.Element,
-    doc_frags: List[OdxDocFragment],
-    *,
-    internal_type: DataType,
-    physical_type: DataType,
-    is_scale_linear: bool = False,
-    **kwargs: Any,
-) -> LinearCompuMethod:
-    odxassert(physical_type in [
-        DataType.A_FLOAT32,
-        DataType.A_FLOAT64,
-        DataType.A_INT32,
-        DataType.A_UINT32,
-    ])
-    odxassert(internal_type in [
-        DataType.A_FLOAT32,
-        DataType.A_FLOAT64,
-        DataType.A_INT32,
-        DataType.A_UINT32,
-    ])
-
-    if physical_type.python_type == float:
-        computation_python_type = physical_type.from_string
-    else:
-        computation_python_type = internal_type.from_string
-
-    kwargs = kwargs.copy()
-    kwargs["internal_type"] = internal_type
-    kwargs["physical_type"] = physical_type
-
-    coeffs = odxrequire(et_element.find("COMPU-RATIONAL-COEFFS"))
-    nums = coeffs.iterfind("COMPU-NUMERATOR/V")
-
-    offset = computation_python_type(odxrequire(next(nums).text))
-    factor_el = next(nums, None)
-    factor = computation_python_type(odxrequire(factor_el.text) if factor_el is not None else "0")
-    denominator = 1.0
-    if (string := coeffs.findtext("COMPU-DENOMINATOR/V")) is not None:
-        denominator = float(string)
-        if denominator == 0:
-            odxraise("CompuMethod: A denominator of zero will lead to divisions by zero.")
-
-    # Read lower limit
-    internal_lower_limit = Limit.limit_from_et(
-        et_element.find("LOWER-LIMIT"),
-        doc_frags,
-        value_type=internal_type,
-    )
-
-    kwargs["internal_lower_limit"] = internal_lower_limit
-
-    # Read upper limit
-    internal_upper_limit = Limit.limit_from_et(
-        et_element.find("UPPER-LIMIT"),
-        doc_frags,
-        value_type=internal_type,
-    )
-
-    kwargs["internal_upper_limit"] = internal_upper_limit
-    kwargs["denominator"] = denominator
-    kwargs["factor"] = factor
-    kwargs["offset"] = offset
-
-    return LinearCompuMethod(**kwargs)
-
-
-def create_compu_default_value(et_element: Optional[ElementTree.Element],
-                               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.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,
                                     physical_type: DataType) -> CompuMethod:
-    compu_category = et_element.findtext("CATEGORY")
-    odxassert(compu_category in [
-        "IDENTICAL",
-        "LINEAR",
-        "SCALE-LINEAR",
-        "TEXTTABLE",
-        "COMPUCODE",
-        "TAB-INTP",
-        "RAT-FUNC",
-        "SCALE-RAT-FUNC",
-    ])
-
-    if et_element.find("COMPU-PHYS-TO-INTERNAL") is not None:  # TODO: Is this never used?
-        raise NotImplementedError(f"Found COMPU-PHYS-TO-INTERNAL for category {compu_category}")
-
-    kwargs: Dict[str, Any] = {
-        "physical_type": physical_type,
-        "internal_type": internal_type,
-    }
+    compu_category = odxrequire(et_element.findtext("CATEGORY"))
 
     if compu_category == "IDENTICAL":
-        odxassert(
-            internal_type == physical_type or
-            (internal_type in [DataType.A_ASCIISTRING, DataType.A_UTF8STRING] and
-             physical_type == DataType.A_UNICODE2STRING),
-            f"Internal type '{internal_type}' and physical type '{physical_type}'"
-            f" must be the same for compu methods of category '{compu_category}'")
-        return IdenticalCompuMethod(internal_type=internal_type, physical_type=physical_type)
-
-    if compu_category == "TEXTTABLE":
-        odxassert(physical_type == DataType.A_UNICODE2STRING)
-        compu_internal_to_phys = odxrequire(et_element.find("COMPU-INTERNAL-TO-PHYS"))
-
-        internal_to_phys: List[CompuScale] = []
-        for scale_elem in compu_internal_to_phys.iterfind("COMPU-SCALES/COMPU-SCALE"):
-            internal_to_phys.append(
-                CompuScale.compuscale_from_et(
-                    scale_elem, doc_frags, internal_type=internal_type,
-                    physical_type=physical_type))
-        compu_default_value = create_compu_default_value(
-            et_element.find("COMPU-DEFAULT-VALUE"), doc_frags, **kwargs)
-
-        return TexttableCompuMethod(
-            internal_to_phys=internal_to_phys,
-            compu_default_value=compu_default_value,
-            **kwargs,
-        )
-
+        return IdenticalCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
     elif compu_category == "LINEAR":
-        # 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_elem, doc_frags, **kwargs)
-
+        return LinearCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
     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_elem, doc_frags, **kwargs)
-            for scale_elem in scale_elems
-        ]
-        return ScaleLinearCompuMethod(linear_methods=linear_methods, **kwargs)
-
+        return ScaleLinearCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+    elif compu_category == "RAT-FUNC":
+        return RatFuncCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+    elif compu_category == "SCALE-RAT-FUNC":
+        return ScaleRatFuncCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+    elif compu_category == "TEXTTABLE":
+        return TexttableCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+    elif compu_category == "COMPUCODE":
+        return CompuCodeCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
     elif compu_category == "TAB-INTP":
-        internal_points = []
-        physical_points = []
-        for scale_elem in et_element.iterfind("COMPU-INTERNAL-TO-PHYS/COMPU-SCALES/COMPU-SCALE"):
-            internal_point = internal_type.from_string(
-                odxrequire(scale_elem.findtext("LOWER-LIMIT")))
-            physical_point = physical_type.create_from_et(
-                odxrequire(scale_elem.find("COMPU-CONST")))
-
-            if not isinstance(internal_point, (float, int)):
-                odxraise()
-            if not isinstance(physical_point, (float, int)):
-                odxraise()
-
-            internal_points.append(internal_point)
-            physical_points.append(physical_point)
-
-        return TabIntpCompuMethod(
-            internal_points=internal_points, physical_points=physical_points, **kwargs)
+        return TabIntpCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
 
     # 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)
+    return IdenticalCompuMethod.compu_method_from_et(
+        et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)

odxtools/compumethods/identicalcompumethod.py

@@ -1,16 +1,41 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import List
+from xml.etree import ElementTree
 
-from ..odxtypes import AtomicOdxType
-from .compumethod import CompuMethod, CompuMethodCategory
+from ..exceptions import odxassert
+from ..odxlink import OdxDocFragment
+from ..odxtypes import AtomicOdxType, DataType
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuMethod
 
 
 @dataclass
 class IdenticalCompuMethod(CompuMethod):
-
-    @property
-    def category(self) -> CompuMethodCategory:
-        return "IDENTICAL"
+    """Identical compu methods just pass through the internal value.
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.2.
+    """
+
+    @staticmethod
+    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(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        odxassert(
+            internal_type == physical_type or
+            (internal_type
+             in [DataType.A_ASCIISTRING, DataType.A_UTF8STRING, DataType.A_UNICODE2STRING] and
+             physical_type
+             in [DataType.A_ASCIISTRING, DataType.A_UTF8STRING, DataType.A_UNICODE2STRING]),
+            f"Internal type and physical type must be the same for compu methods of category "
+            f"'{cm.category}' (internal type: '{internal_type.value}', physical type: "
+            f"'{physical_type.value}')")
+
+        return IdenticalCompuMethod(**kwargs)
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         return physical_value