odxtools 8.1.0__py3-none-any.whl → 8.2.1__py3-none-any.whl

odxtools/audience.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .additionalaudience import AdditionalAudience
+from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import odxstr_to_bool
 from .snrefcontext import SnRefContext
@@ -45,11 +46,11 @@ class Audience:
         return self.is_aftermarket_raw in [None, True]
 
     @property
-    def enabled_audiences(self) -> List[AdditionalAudience]:
+    def enabled_audiences(self) -> NamedItemList[AdditionalAudience]:
         return self._enabled_audiences
 
     @property
-    def disabled_audiences(self) -> List[AdditionalAudience]:
+    def disabled_audiences(self) -> NamedItemList[AdditionalAudience]:
         return self._disabled_audiences
 
     @staticmethod
@@ -85,12 +86,10 @@ class Audience:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._enabled_audiences = [
-            odxlinks.resolve(ref, AdditionalAudience) for ref in self.enabled_audience_refs
-        ]
-        self._disabled_audiences = [
-            odxlinks.resolve(ref, AdditionalAudience) for ref in self.disabled_audience_refs
-        ]
+        self._enabled_audiences = NamedItemList(
+            [odxlinks.resolve(ref, AdditionalAudience) for ref in self.enabled_audience_refs])
+        self._disabled_audiences = NamedItemList(
+            [odxlinks.resolve(ref, AdditionalAudience) for ref in self.disabled_audience_refs])
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/compumethods/compucodecompumethod.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional, cast
+from xml.etree import ElementTree
+
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
+from ..odxlink import OdxDocFragment
+from ..odxtypes import AtomicOdxType, DataType
+from ..progcode import ProgCode
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuCategory, CompuMethod
+
+
+@dataclass
+class CompuCodeCompuMethod(CompuMethod):
+    """A compu method specifies the tranfer functions using Java bytecode
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.9.
+    """
+
+    @property
+    def internal_to_phys_code(self) -> Optional[ProgCode]:
+        if self.compu_internal_to_phys is None:
+            return None
+
+        return self.compu_internal_to_phys.prog_code
+
+    @property
+    def phys_to_internal_code(self) -> Optional[ProgCode]:
+        if self.compu_phys_to_internal is None:
+            return None
+
+        return self.compu_phys_to_internal.prog_code
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "CompuCodeCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return CompuCodeCompuMethod(**kwargs)
+
+    def __post_init__(self) -> None:
+        odxassert(self.category == CompuCategory.COMPUCODE,
+                  "CompuCodeCompuMethod must exhibit COMPUCODE category")
+
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
+        odxraise(r"CompuCodeCompuMethod cannot be executed by odxtools", DecodeError)
+        return cast(AtomicOdxType, None)
+
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
+        odxraise(r"CompuCodeCompuMethod cannot be executed by odxtools", EncodeError)
+        return cast(AtomicOdxType, None)
+
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
+        # CompuCodeCompuMethod cannot be executed by odxtools
+        return False
+
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
+        # CompuCodeCompuMethod cannot be executed by odxtools
+        return False

odxtools/compumethods/compuinternaltophys.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from ..odxlink import OdxDocFragment
+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
 
@@ -37,3 +38,19 @@ class CompuInternalToPhys:
 
         return CompuInternalToPhys(
             compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        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/compumethod.py

@@ -1,12 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise
-from ..odxlink import OdxDocFragment
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType
+from ..snrefcontext import SnRefContext
 from .compuinternaltophys import CompuInternalToPhys
 from .compuphystointernal import CompuPhysToInternal
 
@@ -77,6 +78,31 @@ class CompuMethod:
             physical_type=physical_type,
             internal_type=internal_type)
 
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {}
+
+        if self.compu_internal_to_phys is not None:
+            result.update(self.compu_internal_to_phys._build_odxlinks())
+
+        if self.compu_phys_to_internal is not None:
+            result.update(self.compu_phys_to_internal._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.compu_internal_to_phys is not None:
+            self.compu_internal_to_phys._resolve_odxlinks(odxlinks)
+
+        if self.compu_phys_to_internal is not None:
+            self.compu_phys_to_internal._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.compu_internal_to_phys is not None:
+            self.compu_internal_to_phys._resolve_snrefs(context)
+
+        if self.compu_phys_to_internal is not None:
+            self.compu_phys_to_internal._resolve_snrefs(context)
+
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         raise NotImplementedError()
 

odxtools/compumethods/compuphystointernal.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from ..odxlink import OdxDocFragment
+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
 
@@ -37,3 +38,19 @@ class CompuPhysToInternal:
 
         return CompuPhysToInternal(
             compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        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/createanycompumethod.py

@@ -5,10 +5,13 @@ from xml.etree import ElementTree
 from ..exceptions import odxraise, odxrequire
 from ..odxlink import OdxDocFragment
 from ..odxtypes import DataType
+from .compucodecompumethod import CompuCodeCompuMethod
 from .compumethod import CompuMethod
 from .identicalcompumethod import IdenticalCompuMethod
 from .linearcompumethod import LinearCompuMethod
+from .ratfunccompumethod import RatFuncCompuMethod
 from .scalelinearcompumethod import ScaleLinearCompuMethod
+from .scaleratfunccompumethod import ScaleRatFuncCompuMethod
 from .tabintpcompumethod import TabIntpCompuMethod
 from .texttablecompumethod import TexttableCompuMethod
 
@@ -27,9 +30,18 @@ def create_any_compu_method_from_et(et_element: ElementTree.Element,
     elif compu_category == "SCALE-LINEAR":
         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":
         return TabIntpCompuMethod.compu_method_from_et(
             et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)

odxtools/compumethods/linearcompumethod.py

@@ -75,13 +75,13 @@ class LinearCompuMethod(CompuMethod):
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         if not self._segment.internal_applies(internal_value):
-            odxraise(r"Cannot decode internal value {internal_value}", DecodeError)
+            odxraise(f"Cannot decode internal value {internal_value!r}", DecodeError)
 
         return self._segment.convert_internal_to_physical(internal_value)
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         if not self._segment.physical_applies(physical_value):
-            odxraise(r"Cannot decode physical value {physical_value}", EncodeError)
+            odxraise(f"Cannot decode physical value {physical_value!r}", EncodeError)
 
         return self._segment.convert_physical_to_internal(physical_value)
 

odxtools/compumethods/ratfunccompumethod.py

@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional, cast
+from xml.etree import ElementTree
+
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
+from ..odxlink import OdxDocFragment
+from ..odxtypes import AtomicOdxType, DataType
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuCategory, CompuMethod
+from .ratfuncsegment import RatFuncSegment
+
+
+@dataclass
+class RatFuncCompuMethod(CompuMethod):
+    """A compu method using a rational function
+
+    i.e. internal values are converted to physical ones using the
+    function `f(x) = (a0 + a1*x + a2*x^2 ...)/(b0 + b0*x^2 ...)` where `f(x)`
+    is the physical value and `x` is the internal value. In contrast
+    to `ScaleRatFuncCompuMethod`, this compu method only exhibits a
+    single segment)
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.5.
+    """
+
+    @property
+    def int_to_phys_segment(self) -> RatFuncSegment:
+        return self._int_to_phys_segment
+
+    @property
+    def phys_to_int_segment(self) -> Optional[RatFuncSegment]:
+        return self._phys_to_int_segment
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "RatFuncCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return RatFuncCompuMethod(**kwargs)
+
+    def __post_init__(self) -> None:
+        odxassert(self.category == CompuCategory.RAT_FUNC,
+                  "RatFuncCompuMethod must exhibit RAT-FUNC category")
+
+        odxassert(self.physical_type in [
+            DataType.A_FLOAT32,
+            DataType.A_FLOAT64,
+            DataType.A_INT32,
+            DataType.A_UINT32,
+        ])
+        odxassert(self.internal_type in [
+            DataType.A_FLOAT32,
+            DataType.A_FLOAT64,
+            DataType.A_INT32,
+            DataType.A_UINT32,
+        ])
+
+        if self.compu_internal_to_phys is None:
+            odxraise("RAT-FUNC compu methods require COMPU-INTERNAL-TO-PHYS")
+            return
+
+        int_to_phys_scales = self.compu_internal_to_phys.compu_scales
+        if len(int_to_phys_scales) != 1:
+            odxraise("RAT-FUNC compu methods expect exactly one compu scale within "
+                     "COMPU-INTERNAL-TO-PHYS")
+            return cast(None, RatFuncCompuMethod)
+
+        self._int_to_phys_segment = RatFuncSegment.from_compu_scale(
+            int_to_phys_scales[0], value_type=self.physical_type)
+
+        self._phys_to_int_segment = None
+        if self.compu_phys_to_internal is not None:
+            phys_to_int_scales = self.compu_phys_to_internal.compu_scales
+            if len(phys_to_int_scales) != 1:
+                odxraise("RAT-FUNC compu methods expect exactly one compu scale within "
+                         "COMPU-PHYS-TO-INTERNAL")
+                return cast(None, RatFuncCompuMethod)
+
+            self._phys_to_int_segment = RatFuncSegment.from_compu_scale(
+                phys_to_int_scales[0], value_type=self.internal_type)
+
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
+        if not self._int_to_phys_segment.applies(internal_value):
+            odxraise(f"Cannot decode internal value {internal_value!r}", DecodeError)
+            return cast(AtomicOdxType, None)
+
+        return self._int_to_phys_segment.convert(internal_value)
+
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
+        if self._phys_to_int_segment is None or not self._phys_to_int_segment.applies(
+                physical_value):
+            odxraise(f"Cannot encode physical value {physical_value!r}", EncodeError)
+            return cast(AtomicOdxType, None)
+
+        return self._phys_to_int_segment.convert(physical_value)
+
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
+        return self._phys_to_int_segment is not None and self._phys_to_int_segment.applies(
+            physical_value)
+
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
+        return self._int_to_phys_segment.applies(internal_value)

odxtools/compumethods/ratfuncsegment.py

@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional, Union
+
+from ..exceptions import odxraise, odxrequire
+from ..odxtypes import AtomicOdxType, DataType
+from .compuscale import CompuScale
+from .limit import Limit
+
+
+@dataclass
+class RatFuncSegment:
+    """Helper class to represent a segment of a piecewise rational function.
+    """
+    value_type: DataType
+
+    numerator_coeffs: List[Union[int, float]]
+    denominator_coeffs: List[Union[int, float]]
+
+    lower_limit: Optional[Limit]
+    upper_limit: Optional[Limit]
+
+    @staticmethod
+    def from_compu_scale(scale: CompuScale, value_type: DataType) -> "RatFuncSegment":
+        coeffs = odxrequire(scale.compu_rational_coeffs,
+                            "Scales for rational functions must exhibit "
+                            "COMPU-RATIONAL-COEFFS")
+
+        numerator_coeffs = coeffs.numerators
+        denominator_coeffs = coeffs.denominators
+
+        lower_limit = scale.lower_limit
+        upper_limit = scale.upper_limit
+
+        return RatFuncSegment(
+            numerator_coeffs=numerator_coeffs,
+            denominator_coeffs=denominator_coeffs,
+            lower_limit=lower_limit,
+            upper_limit=upper_limit,
+            value_type=scale.range_type)
+
+    def convert(self, value: AtomicOdxType) -> Union[float, int]:
+        if not isinstance(value, (int, float)):
+            odxraise(f"Internal values of linear compumethods must "
+                     f"either be int or float (is: {type(value).__name__})")
+
+        numerator = 0.0
+        x = float(value)
+        for numerator_coeff in reversed(self.numerator_coeffs):
+            numerator *= x
+            numerator += float(numerator_coeff)
+
+        denominator = 0.0
+        for denominator_coeff in reversed(self.denominator_coeffs):
+            denominator *= x
+            denominator += float(denominator_coeff)
+
+        result = numerator / denominator
+
+        if self.value_type in [
+                DataType.A_INT32,
+                DataType.A_UINT32,
+        ]:
+            result = round(result)
+
+        return result
+
+    def applies(self, value: AtomicOdxType) -> bool:
+        """Returns True iff the segment is applicable to a given internal value"""
+        # Do type checks
+        expected_type = self.value_type.python_type
+        if issubclass(expected_type, float):
+            if not isinstance(value, (int, float)):
+                return False
+        else:
+            if not isinstance(value, expected_type):
+                return False
+
+        if self.lower_limit is not None and \
+           not self.lower_limit.complies_to_lower(value):
+            return False
+
+        if self.upper_limit is not None and \
+           not self.upper_limit.complies_to_upper(value):
+            return False
+
+        return True

odxtools/compumethods/scaleratfunccompumethod.py

@@ -0,0 +1,113 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional, cast
+from xml.etree import ElementTree
+
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
+from ..odxlink import OdxDocFragment
+from ..odxtypes import AtomicOdxType, DataType
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuCategory, CompuMethod
+from .ratfuncsegment import RatFuncSegment
+
+
+@dataclass
+class ScaleRatFuncCompuMethod(CompuMethod):
+    """A compu method using a piecewise rational function
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.5.
+    """
+
+    @property
+    def int_to_phys_segments(self) -> List[RatFuncSegment]:
+        return self._int_to_phys_segments
+
+    @property
+    def phys_to_int_segments(self) -> Optional[List[RatFuncSegment]]:
+        return self._phys_to_int_segments
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "ScaleRatFuncCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return ScaleRatFuncCompuMethod(**kwargs)
+
+    def __post_init__(self) -> None:
+        odxassert(self.category == CompuCategory.SCALE_RAT_FUNC,
+                  "ScaleRatFuncCompuMethod must exhibit SCALE-RAT-FUNC category")
+
+        odxassert(self.physical_type in [
+            DataType.A_FLOAT32,
+            DataType.A_FLOAT64,
+            DataType.A_INT32,
+            DataType.A_UINT32,
+        ])
+        odxassert(self.internal_type in [
+            DataType.A_FLOAT32,
+            DataType.A_FLOAT64,
+            DataType.A_INT32,
+            DataType.A_UINT32,
+        ])
+
+        if self.compu_internal_to_phys is None:
+            odxraise("RAT-FUNC compu methods require COMPU-INTERNAL-TO-PHYS")
+            return
+
+        int_to_phys_scales = self.compu_internal_to_phys.compu_scales
+        if len(int_to_phys_scales) < 1:
+            odxraise("RAT-FUNC compu methods expect at least one compu scale within "
+                     "COMPU-INTERNAL-TO-PHYS")
+            return
+
+        self._int_to_phys_segments = [
+            RatFuncSegment.from_compu_scale(scale, value_type=self.physical_type)
+            for scale in int_to_phys_scales
+        ]
+
+        self._phys_to_int_segments = None
+        if self.compu_phys_to_internal is not None:
+            phys_to_int_scales = self.compu_phys_to_internal.compu_scales
+            if len(phys_to_int_scales) < 1:
+                odxraise("SCALE-RAT-FUNC compu methods expect at least one compu scale within "
+                         "COMPU-PHYS-TO-INTERNAL")
+                return
+
+            self._phys_to_int_segments = [
+                RatFuncSegment.from_compu_scale(scale, value_type=self.internal_type)
+                for scale in phys_to_int_scales
+            ]
+
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
+        for seg in self._int_to_phys_segments:
+            if seg.applies(internal_value):
+                return seg.convert(internal_value)
+
+        odxraise(f"Internal value {internal_value!r} be decoded using this compumethod",
+                 DecodeError)
+        return cast(AtomicOdxType, None)
+
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
+        if self._phys_to_int_segments is None:
+            odxraise(f"Physical values cannot be encoded using this compumethod", EncodeError)
+            return cast(AtomicOdxType, None)
+
+        for seg in self._phys_to_int_segments:
+            if seg.applies(physical_value):
+                return seg.convert(physical_value)
+
+        odxraise(f"Physical values {physical_value!r} be decoded using this compumethod",
+                 EncodeError)
+        return cast(AtomicOdxType, None)
+
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
+        return any(seg.applies(internal_value) for seg in self._int_to_phys_segments)
+
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
+        if self._phys_to_int_segments is None:
+            return False
+
+        return any(seg.applies(physical_value) for seg in self._phys_to_int_segments)

odxtools/dataobjectproperty.py

@@ -84,6 +84,7 @@ class DataObjectProperty(DopBase):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
         result.update(self.diag_coded_type._build_odxlinks())
+        result.update(self.compu_method._build_odxlinks())
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -91,6 +92,7 @@ class DataObjectProperty(DopBase):
         super()._resolve_odxlinks(odxlinks)
 
         self.diag_coded_type._resolve_odxlinks(odxlinks)
+        self.compu_method._resolve_odxlinks(odxlinks)
 
         self._unit: Optional[Unit] = None
         if self.unit_ref:
@@ -100,6 +102,7 @@ class DataObjectProperty(DopBase):
         super()._resolve_snrefs(context)
 
         self.diag_coded_type._resolve_snrefs(context)
+        self.compu_method._resolve_snrefs(context)
 
     @property
     def unit(self) -> Optional[Unit]:

odxtools/diaglayers/basevariantraw.py

@@ -33,7 +33,13 @@ class BaseVariantRaw(HierarchyElementRaw):
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "BaseVariantRaw":
-        kwargs = dataclass_fields_asdict(HierarchyElementRaw.from_et(et_element, doc_frags))
+        # objects contained by diagnostic layers exibit an additional
+        # document fragment for the diag layer, so we use the document
+        # fragments of the odx id of the diag layer for IDs of
+        # contained objects.
+        her = HierarchyElementRaw.from_et(et_element, doc_frags)
+        kwargs = dataclass_fields_asdict(her)
+        doc_frags = her.odx_id.doc_fragments
 
         diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]] = []
         if (dv_elems := et_element.find("DIAG-VARIABLES")) is not None:

odxtools/diaglayers/diaglayer.py

@@ -13,6 +13,7 @@ from ..diagcomm import DiagComm
 from ..diagdatadictionaryspec import DiagDataDictionarySpec
 from ..diagservice import DiagService
 from ..exceptions import DecodeError, odxassert, odxraise
+from ..library import Library
 from ..message import Message
 from ..nameditemlist import NamedItemList, TNamed
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
@@ -259,6 +260,10 @@ class DiagLayer:
     def import_refs(self) -> List[OdxLinkRef]:
         return self.diag_layer_raw.import_refs
 
+    @property
+    def libraries(self) -> List[Library]:
+        return self.diag_layer_raw.libraries
+
     @property
     def sdgs(self) -> List[SpecialDataGroup]:
         return self.diag_layer_raw.sdgs