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

odxtools/compumethods/compuconst.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Optional
+from xml.etree import ElementTree
+
+from ..odxtypes import AtomicOdxType, DataType
+
+
+@dataclass
+class CompuConst:
+    v: Optional[str]
+    vt: Optional[str]
+
+    data_type: DataType
+
+    @staticmethod
+    def compuvalue_from_et(et_element: ElementTree.Element, *, data_type: DataType) -> "CompuConst":
+
+        v = et_element.findtext("V")
+        vt = et_element.findtext("VT")
+
+        return CompuConst(v=v, vt=vt, data_type=data_type)
+
+    def __post_init__(self) -> None:
+        self._value: Optional[AtomicOdxType] = self.vt
+        if self.v is not None:
+            self._value = self.data_type.from_string(self.v)
+
+    @property
+    def value(self) -> Optional[AtomicOdxType]:
+        return self._value

odxtools/compumethods/compudefaultvalue.py

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Optional
+from xml.etree import ElementTree
+
+from ..odxtypes import DataType
+from ..utils import dataclass_fields_asdict
+from .compuconst import CompuConst
+from .compuinversevalue import CompuInverseValue
+
+
+@dataclass
+class CompuDefaultValue(CompuConst):
+    compu_inverse_value: Optional[CompuInverseValue]
+
+    @staticmethod
+    def compuvalue_from_et(et_element: ElementTree.Element, *,
+                           data_type: DataType) -> "CompuDefaultValue":
+        kwargs = dataclass_fields_asdict(
+            CompuConst.compuvalue_from_et(et_element, data_type=data_type))
+
+        compu_inverse_value = None
+        if (civ_elem := et_element.find("COMPU-INVERSE-VALUE")) is not None:
+            compu_inverse_value = CompuInverseValue.compuvalue_from_et(
+                civ_elem, data_type=data_type)
+
+        return CompuDefaultValue(**kwargs, compu_inverse_value=compu_inverse_value)

odxtools/compumethods/compuinternaltophys.py

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from ..odxlink import OdxDocFragment
+from ..odxtypes import DataType
+from ..progcode import ProgCode
+from .compudefaultvalue import CompuDefaultValue
+from .compuscale import CompuScale
+
+
+@dataclass
+class CompuInternalToPhys:
+    compu_scales: List[CompuScale]
+    prog_code: Optional[ProgCode]
+    compu_default_value: Optional[CompuDefaultValue]
+
+    @staticmethod
+    def compu_internal_to_phys_from_et(et_element: ElementTree.Element,
+                                       doc_frags: List[OdxDocFragment], *, internal_type: DataType,
+                                       physical_type: DataType) -> "CompuInternalToPhys":
+        compu_scales = [
+            CompuScale.compuscale_from_et(
+                cse, doc_frags, internal_type=internal_type, physical_type=physical_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=physical_type)
+
+        return CompuInternalToPhys(
+            compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)

odxtools/compumethods/compuinversevalue.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+
+from .compuconst import CompuConst
+
+# make CompuInverseValue an alias for CompuConst. The XSD defines two
+# separate but identical groups for this (why?)...
+CompuInverseValue = CompuConst

odxtools/compumethods/compumethod.py

@@ -1,26 +1,81 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Literal
+from enum import Enum
+from typing import List, Optional
+from xml.etree import ElementTree
 
+from ..exceptions import odxraise
+from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
+from .compuinternaltophys import CompuInternalToPhys
+from .compuphystointernal import CompuPhysToInternal
 
-CompuMethodCategory = Literal[
-    "IDENTICAL",
-    "LINEAR",
-    "SCALE-LINEAR",
-    "TAB-INTP",
-    "TEXTTABLE",
-]
+
+class CompuCategory(Enum):
+    IDENTICAL = "IDENTICAL"
+    LINEAR = "LINEAR"
+    SCALE_LINEAR = "SCALE-LINEAR"
+    TEXTTABLE = "TEXTTABLE"
+    COMPUCODE = "COMPUCODE"
+    TAB_INTP = "TAB-INTP"
+    RAT_FUNC = "RAT-FUNC"
+    SCALE_RAT_FUNC = "SCALE-RAT-FUNC"
 
 
 @dataclass
 class CompuMethod:
-    internal_type: DataType
+    """A compu method translates between the internal representation
+    of a value and their physical representation.
+
+    There are many compu methods, but all of them are specified using
+    the same mechanism: The conversion from internal to physical
+    quantities is specified using the COMPU-INTERNAL-TO-PHYS subtag,
+    and the inverse is covered by
+    COMPU-PHYS-TO-INTERNAL. Alternatively to directly specifying the
+    parameters needed for conversion, it is also possible to specify a
+    Java program which does the conversion (doing this excludes using
+    ODX in non-Java contexts, though).
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.
+
+    """
+
+    category: CompuCategory
+    compu_internal_to_phys: Optional[CompuInternalToPhys]
+    compu_phys_to_internal: Optional[CompuPhysToInternal]
+
     physical_type: DataType
+    internal_type: DataType
 
-    @property
-    def category(self) -> CompuMethodCategory:
-        raise NotImplementedError()
+    @staticmethod
+    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:
+            odxraise("No category specified for compu method")
+            cat_text = "IDENTICAL"
+
+        try:
+            category = CompuCategory(cat_text)
+        except ValueError:
+            odxraise(f"Encountered compu method of unknown category '{cat_text}'")
+            category = CompuCategory.IDENTICAL
+
+        compu_internal_to_phys = None
+        if (citp_elem := et_element.find("COMPU-INTERNAL-TO-PHYS")) is not None:
+            compu_internal_to_phys = CompuInternalToPhys.compu_internal_to_phys_from_et(
+                citp_elem, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        compu_phys_to_internal = None
+        if (cpti_elem := et_element.find("COMPU-PHYS-TO-INTERNAL")) is not None:
+            compu_phys_to_internal = CompuPhysToInternal.compu_phys_to_internal_from_et(
+                cpti_elem, doc_frags, internal_type=internal_type, physical_type=physical_type)
+
+        return CompuMethod(
+            category=category,
+            compu_internal_to_phys=compu_internal_to_phys,
+            compu_phys_to_internal=compu_phys_to_internal,
+            physical_type=physical_type,
+            internal_type=internal_type)
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         raise NotImplementedError()

odxtools/compumethods/compuphystointernal.py

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from ..odxlink import OdxDocFragment
+from ..odxtypes import DataType
+from ..progcode import ProgCode
+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, internal_type=internal_type, physical_type=physical_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)

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,33 +15,14 @@ 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
@@ -52,15 +35,21 @@ class CompuScale:
     def compuscale_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
                            internal_type: DataType, physical_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)
         upper_limit = Limit.limit_from_et(
             et_element.find("UPPER-LIMIT"), doc_frags, value_type=internal_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_inverse_value = None
+        if (cive := et_element.find("COMPU-INVERSE-VALUE")) is not None:
+            compu_inverse_value = CompuInverseValue.compuvalue_from_et(
+                cive, data_type=internal_type)
+
+        compu_const = None
+        if (cce := et_element.find("COMPU-CONST")) is not None:
+            compu_const = CompuConst.compuvalue_from_et(cce, data_type=physical_type)
 
         compu_rational_coeffs: Optional[CompuRationalCoeffs] = None
         if (crc_elem := et_element.find("COMPU-RATIONAL-COEFFS")) is not None:

odxtools/compumethods/createanycompumethod.py

@@ -1,184 +1,38 @@
 # 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 .compumethod import CompuMethod
-from .compuscale import CompuScale
 from .identicalcompumethod import IdenticalCompuMethod
-from .limit import Limit
 from .linearcompumethod import LinearCompuMethod
 from .scalelinearcompumethod import ScaleLinearCompuMethod
 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-INTERNAL-TO-PHYS/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 == "TEXTTABLE":
+        return TexttableCompuMethod.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!")

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