odxtools 7.4.0__py3-none-any.whl → 8.0.0__py3-none-any.whl

odxtools/cli/_print_utils.py

@@ -7,7 +7,7 @@ import markdownify
 from tabulate import tabulate  # TODO: switch to rich tables
 
 from ..description import Description
-from ..diaglayer import DiagLayer
+from ..diaglayers.diaglayer import DiagLayer
 from ..diagservice import DiagService
 from ..parameters.codedconstparameter import CodedConstParameter
 from ..parameters.nrcconstparameter import NrcConstParameter
@@ -243,8 +243,9 @@ def print_dl_metrics(variants: List[DiagLayer], print_fn: Callable[..., Any] = p
         name.append(variant.short_name)
         type.append(variant.variant_type.value)
         num_services.append(len(all_services))
-        num_dops.append(len(variant.diag_data_dictionary_spec.data_object_props))
-        num_comparam_refs.append(len(variant.comparam_refs))
+        ddds = variant.diag_data_dictionary_spec
+        num_dops.append(len(ddds.data_object_props))
+        num_comparam_refs.append(len(getattr(variant, "comparams_refs", [])))
 
     table = {
         'Name': name,

odxtools/cli/browse.py

@@ -12,6 +12,7 @@ from ..dataobjectproperty import DataObjectProperty
 from ..diaglayer import DiagLayer
 from ..diagservice import DiagService
 from ..exceptions import odxraise, odxrequire
+from ..hierarchyelement import HierarchyElement
 from ..odxtypes import AtomicOdxType, DataType, ParameterValueDict
 from ..parameters.matchingrequestparameter import MatchingRequestParameter
 from ..parameters.parameter import Parameter
@@ -283,19 +284,20 @@ def browse(odxdb: Database) -> None:
         print(f"{type(answer.get('variant'))=}")
         assert isinstance(variant, DiagLayer)
 
-        if (rx_id := variant.get_receive_id()) is not None:
-            recv_id = hex(rx_id)
-        else:
-            recv_id = "None"
+        if isinstance(variant, HierarchyElement):
+            if (rx_id := variant.get_receive_id()) is not None:
+                recv_id = hex(rx_id)
+            else:
+                recv_id = "None"
 
-        if (tx_id := variant.get_send_id()) is not None:
-            send_id = hex(tx_id)
-        else:
-            send_id = "None"
+            if (tx_id := variant.get_send_id()) is not None:
+                send_id = hex(tx_id)
+            else:
+                send_id = "None"
 
-        print(
-            f"{variant.variant_type.value} '{variant.short_name}' (Receive ID: {recv_id}, Send ID: {send_id})"
-        )
+            print(
+                f"{variant.variant_type.value} '{variant.short_name}' (Receive ID: {recv_id}, Send ID: {send_id})"
+            )
 
         while True:
             services: List[DiagService] = [

odxtools/cli/compare.py

@@ -9,7 +9,7 @@ from rich import print
 from tabulate import tabulate  # TODO: switch to rich tables
 
 from ..database import Database
-from ..diaglayer import DiagLayer
+from ..diaglayers.diaglayer import DiagLayer
 from ..diagservice import DiagService
 from ..loadfile import load_file
 from ..odxtypes import AtomicOdxType

odxtools/cli/list.py

@@ -4,9 +4,14 @@ from typing import Callable, List, Optional
 
 import rich
 
+from ..comparaminstance import ComparamInstance
 from ..database import Database
+from ..dataobjectproperty import DataObjectProperty
 from ..diagcomm import DiagComm
-from ..diaglayer import DiagLayer
+from ..diaglayers.basevariant import BaseVariant
+from ..diaglayers.diaglayer import DiagLayer
+from ..diaglayers.ecuvariant import EcuVariant
+from ..diaglayers.hierarchyelement import HierarchyElement
 from ..diagservice import DiagService
 from ..singleecujob import SingleEcuJob
 from . import _parser_utils
@@ -56,15 +61,14 @@ def print_summary(odxdb: Database,
 
         all_services: List[DiagComm] = sorted(dl.services, key=lambda x: x.short_name)
 
-        data_object_properties = dl.diag_data_dictionary_spec.data_object_props
-        comparam_refs = dl.comparam_refs
+        if isinstance(dl, (BaseVariant, EcuVariant)):
+            for proto in dl.protocols:
+                if (can_rx_id := dl.get_can_receive_id(proto.short_name)) is not None:
+                    rich.print(
+                        f"  CAN receive ID for protocol '{proto.short_name}': 0x{can_rx_id:x}")
 
-        for proto in dl.protocols:
-            if (can_rx_id := dl.get_can_receive_id(proto.short_name)) is not None:
-                rich.print(f"  CAN receive ID for protocol '{proto.short_name}': 0x{can_rx_id:x}")
-
-            if (can_tx_id := dl.get_can_send_id(proto.short_name)) is not None:
-                rich.print(f"  CAN send ID for protocol '{proto.short_name}': 0x{can_tx_id:x}")
+                if (can_tx_id := dl.get_can_send_id(proto.short_name)) is not None:
+                    rich.print(f"  CAN send ID for protocol '{proto.short_name}': 0x{can_tx_id:x}")
 
         if dl.description:
             desc = format_desc(dl.description, indent=2)
@@ -95,7 +99,9 @@ def print_summary(odxdb: Database,
                         rich.print(f" Single ECU job: {service.odx_id}")
                     else:
                         rich.print(f" Unidentifiable service: {service}")
-
+        ddd_spec = dl.diag_data_dictionary_spec
+        data_object_properties: List[
+            DataObjectProperty] = [] if ddd_spec is None else ddd_spec.data_object_props
         if print_dops and len(data_object_properties) > 0:
             rich.print("\n")
             rich.print(f"The DOPs of the {dl.variant_type.value} '{dl.short_name}' are: ")
@@ -103,6 +109,10 @@ def print_summary(odxdb: Database,
                     data_object_properties, key=lambda x: (type(x).__name__, x.short_name)):
                 rich.print("  " + str(dop.short_name).replace("\n", "\n  "))
 
+        comparam_refs: List[ComparamInstance] = []
+        if isinstance(dl, HierarchyElement):
+            comparam_refs = dl.comparam_refs
+
         if print_comparams and len(comparam_refs) > 0:
             rich.print("\n")
             rich.print(

odxtools/cli/snoop.py

@@ -4,12 +4,13 @@
 import argparse
 import asyncio
 import sys
-from typing import Any, Type
+from typing import Any, List, Optional, Type
 
 import can
 
 import odxtools.isotp_state_machine as ism
 import odxtools.uds as uds
+from odxtools.diaglayers.protocol import Protocol
 from odxtools.exceptions import DecodeError
 from odxtools.isotp_state_machine import IsoTpStateMachine
 from odxtools.response import Response, ResponseType
@@ -245,21 +246,43 @@ def run(args: argparse.Namespace) -> None:
 
     protocol_name = args.protocol
     if odx_diag_layer is not None and protocol_name is not None:
-        protocol_names = [x.short_name for x in odx_diag_layer.protocols]
+        protocols: Optional[List[Protocol]] = getattr(odx_diag_layer, "protocols", None)
+
+        if protocols is None:
+            print(f"ECU variant {odx_diag_layer.short_name} is of type "
+                  f"{odx_diag_layer.variant_type.value} and thus does not "
+                  f"feature any protocols")
+            sys.exit(1)
+
+        protocol_names = [x.short_name for x in protocols]
         if protocol_name not in protocol_names:
             print(f"ECU variant {odx_diag_layer.short_name} does not support "
                   f"a protocol named '{protocol_name}'. Supported protocols are:")
-            for x in odx_diag_layer.protocols:
+            for x in protocols:
                 desc = "" if x.description is None else f": {x.description}"
                 print(f"  {x.short_name}{desc}")
             sys.exit(1)
 
     # if no can IDs have been explicitly specified, take them from the DL
     if args.rx is None and odx_diag_layer:
-        args.rx = str(odx_diag_layer.get_can_receive_id(protocol=protocol_name))
+        get_can_rx_id = getattr(odx_diag_layer, "get_can_receive_id", None)
+        if get_can_rx_id is None:
+            print(f"ECU variant {odx_diag_layer.short_name} is of type "
+                  f"{odx_diag_layer.variant_type.value} and thus does not "
+                  f"provide any communication parameters")
+            sys.exit(1)
+
+        args.rx = str(get_can_rx_id(protocol=protocol_name))
 
     if args.tx is None and odx_diag_layer:
-        args.tx = str(odx_diag_layer.get_can_send_id(protocol=protocol_name))
+        get_can_tx_id = getattr(odx_diag_layer, "get_can_send_id", None)
+        if get_can_tx_id is None:
+            print(f"ECU variant {odx_diag_layer.short_name} is of type "
+                  f"{odx_diag_layer.variant_type.value} and thus does not "
+                  f"provide any communication parameters")
+            sys.exit(1)
+
+        args.tx = str(get_can_tx_id(protocol=protocol_name))
 
     if args.rx is None:
         print(f"Could not determine a CAN receive ID.")

odxtools/database.py

@@ -9,8 +9,13 @@ from packaging.version import Version
 
 from .comparamspec import ComparamSpec
 from .comparamsubset import ComparamSubset
-from .diaglayer import DiagLayer
 from .diaglayercontainer import DiagLayerContainer
+from .diaglayers.basevariant import BaseVariant
+from .diaglayers.diaglayer import DiagLayer
+from .diaglayers.ecushareddata import EcuSharedData
+from .diaglayers.ecuvariant import EcuVariant
+from .diaglayers.functionalgroup import FunctionalGroup
+from .diaglayers.protocol import Protocol
 from .exceptions import odxraise
 from .nameditemlist import NamedItemList
 from .odxlink import OdxLinkDatabase, OdxLinkId
@@ -101,10 +106,16 @@ class Database:
         self._diag_layers = NamedItemList(
             chain(*[dlc.diag_layers for dlc in self.diag_layer_containers]))
 
+        self._ecu_shared_datas = NamedItemList(
+            chain(*[dlc.ecu_shared_datas for dlc in self.diag_layer_containers]))
         self._protocols = NamedItemList(
             chain(*[dlc.protocols for dlc in self.diag_layer_containers]))
-
-        self._ecus = NamedItemList(chain(*[dlc.ecu_variants for dlc in self.diag_layer_containers]))
+        self._functional_groups = NamedItemList(
+            chain(*[dlc.functional_groups for dlc in self.diag_layer_containers]))
+        self._base_variants = NamedItemList(
+            chain(*[dlc.base_variants for dlc in self.diag_layer_containers]))
+        self._ecu_variants = NamedItemList(
+            chain(*[dlc.ecu_variants for dlc in self.diag_layer_containers]))
 
         # Build odxlinks
         self._odxlinks = OdxLinkDatabase()
@@ -145,19 +156,44 @@ class Database:
         return self._odxlinks
 
     @property
-    def protocols(self) -> NamedItemList[DiagLayer]:
-        """
-        All protocols defined by this database
+    def ecu_shared_datas(self) -> NamedItemList[EcuSharedData]:
+        """All ECU shared data layers defined by this database
+
+        ECU shared data layers act as a kind of shared library for
+        data that is common to multiple otherwise unrelated ECUs.
+
         """
+        return self._ecu_shared_datas
+
+    @property
+    def protocols(self) -> NamedItemList[Protocol]:
+        """All protocol layers defined by this database"""
         return self._protocols
 
     @property
-    def ecus(self) -> NamedItemList[DiagLayer]:
-        """ECU-variants defined in the database"""
-        return self._ecus
+    def functional_groups(self) -> NamedItemList["FunctionalGroup"]:
+        """Functional group layers defined in the database"""
+        return self._functional_groups
+
+    @property
+    def base_variants(self) -> NamedItemList["BaseVariant"]:
+        """Base variants defined in the database"""
+        return self._base_variants
+
+    @property
+    def ecus(self) -> NamedItemList["EcuVariant"]:
+        """ECU variants defined in the database
+
+        This property is an alias for `.ecu_variants`"""
+        return self._ecu_variants
+
+    @property
+    def ecu_variants(self) -> NamedItemList["EcuVariant"]:
+        """ECU variants defined in the database"""
+        return self._ecu_variants
 
     @property
-    def diag_layers(self) -> NamedItemList[DiagLayer]:
+    def diag_layers(self) -> NamedItemList["DiagLayer"]:
         """All diagnostic layers defined in the database"""
         return self._diag_layers
 

odxtools/diagcomm.py

@@ -19,7 +19,7 @@ from .statetransition import StateTransition
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+    from .diaglayers.protocol import Protocol
 
 
 class DiagClassType(Enum):
@@ -143,7 +143,7 @@ class DiagComm(IdentifiableElement):
         return self._functional_classes
 
     @property
-    def protocols(self) -> NamedItemList["DiagLayer"]:
+    def protocols(self) -> NamedItemList["Protocol"]:
         return self._protocols
 
     @property
@@ -216,12 +216,12 @@ class DiagComm(IdentifiableElement):
         if TYPE_CHECKING:
             diag_layer = odxrequire(context.diag_layer)
             self._protocols = NamedItemList([
-                resolve_snref(prot_snref, diag_layer.protocols, DiagLayer)
+                resolve_snref(prot_snref, getattr(diag_layer, "protocols", []), Protocol)
                 for prot_snref in self.protocol_snrefs
             ])
         else:
             diag_layer = odxrequire(context.diag_layer)
             self._protocols = NamedItemList([
-                resolve_snref(prot_snref, diag_layer.protocols)
+                resolve_snref(prot_snref, getattr(diag_layer, "protocols", []))
                 for prot_snref in self.protocol_snrefs
             ])

odxtools/diaglayercontainer.py

@@ -6,7 +6,12 @@ from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .companydata import CompanyData
-from .diaglayer import DiagLayer
+from .diaglayers.basevariant import BaseVariant
+from .diaglayers.diaglayer import DiagLayer
+from .diaglayers.ecushareddata import EcuSharedData
+from .diaglayers.ecuvariant import EcuVariant
+from .diaglayers.functionalgroup import FunctionalGroup
+from .diaglayers.protocol import Protocol
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
@@ -22,13 +27,20 @@ if TYPE_CHECKING:
 class DiagLayerContainer(IdentifiableElement):
     admin_data: Optional[AdminData]
     company_datas: NamedItemList[CompanyData]
-    ecu_shared_datas: NamedItemList[DiagLayer]
-    protocols: NamedItemList[DiagLayer]
-    functional_groups: NamedItemList[DiagLayer]
-    base_variants: NamedItemList[DiagLayer]
-    ecu_variants: NamedItemList[DiagLayer]
+    ecu_shared_datas: NamedItemList[EcuSharedData]
+    protocols: NamedItemList[Protocol]
+    functional_groups: NamedItemList[FunctionalGroup]
+    base_variants: NamedItemList[BaseVariant]
+    ecu_variants: NamedItemList[EcuVariant]
     sdgs: List[SpecialDataGroup]
 
+    @property
+    def ecus(self) -> NamedItemList[EcuVariant]:
+        """ECU variants defined in the container
+
+        This property is an alias for `.ecu_variants`"""
+        return self.ecu_variants
+
     def __post_init__(self) -> None:
         self._diag_layers = NamedItemList[DiagLayer](chain(
             self.ecu_shared_datas,
@@ -54,23 +66,23 @@ class DiagLayerContainer(IdentifiableElement):
             for cde in et_element.iterfind("COMPANY-DATAS/COMPANY-DATA")
         ])
         ecu_shared_datas = NamedItemList([
-            DiagLayer.from_et(dl_element, doc_frags)
+            EcuSharedData.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("ECU-SHARED-DATAS/ECU-SHARED-DATA")
         ])
         protocols = NamedItemList([
-            DiagLayer.from_et(dl_element, doc_frags)
+            Protocol.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("PROTOCOLS/PROTOCOL")
         ])
         functional_groups = NamedItemList([
-            DiagLayer.from_et(dl_element, doc_frags)
+            FunctionalGroup.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("FUNCTIONAL-GROUPS/FUNCTIONAL-GROUP")
         ])
         base_variants = NamedItemList([
-            DiagLayer.from_et(dl_element, doc_frags)
+            BaseVariant.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("BASE-VARIANTS/BASE-VARIANT")
         ])
         ecu_variants = NamedItemList([
-            DiagLayer.from_et(dl_element, doc_frags)
+            EcuVariant.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("ECU-VARIANTS/ECU-VARIANT")
         ])
         sdgs = [

odxtools/diaglayers/basevariant.py

@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: MIT
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List, Optional, Union, cast
+from xml.etree import ElementTree
+
+from typing_extensions import override
+
+from ..diagvariable import DiagVariable
+from ..dyndefinedspec import DynDefinedSpec
+from ..exceptions import odxassert
+from ..nameditemlist import NamedItemList
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from ..parentref import ParentRef
+from ..variablegroup import VariableGroup
+from .basevariantraw import BaseVariantRaw
+from .diaglayer import DiagLayer
+from .hierarchyelement import HierarchyElement
+
+
+@dataclass
+class BaseVariant(HierarchyElement):
+    """This is a diagnostic layer for common functionality of an ECU
+    """
+
+    @property
+    def base_variant_raw(self) -> BaseVariantRaw:
+        return cast(BaseVariantRaw, self.diag_layer_raw)
+
+    #####
+    # <properties forwarded to the "raw" base variant>
+    #####
+    @property
+    def diag_variables_raw(self) -> List[Union[DiagVariable, OdxLinkRef]]:
+        return self.base_variant_raw.diag_variables_raw
+
+    @property
+    def dyn_defined_spec(self) -> Optional[DynDefinedSpec]:
+        return self.base_variant_raw.dyn_defined_spec
+
+    @property
+    def parent_refs(self) -> List[ParentRef]:
+        return self.base_variant_raw.parent_refs
+
+    #####
+    # </properties forwarded to the "raw" base variant>
+    #####
+
+    #######
+    # <properties subject to value inheritance>
+    #######
+    @property
+    def diag_variables(self) -> NamedItemList[DiagVariable]:
+        return self._diag_variables
+
+    @property
+    def variable_groups(self) -> NamedItemList[VariableGroup]:
+        return self._variable_groups
+
+    #######
+    # </properties subject to value inheritance>
+    #######
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "BaseVariant":
+        base_variant_raw = BaseVariantRaw.from_et(et_element, doc_frags)
+
+        return BaseVariant(diag_layer_raw=base_variant_raw)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+
+        odxassert(
+            isinstance(self.diag_layer_raw, BaseVariantRaw),
+            "The raw diagnostic layer passed to BaseVariant "
+            "must be a BaseVariantRaw")
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+        """Create a deep copy of the base variant
+
+        Note that the copied diagnostic layer is not fully
+        initialized, so `_finalize_init()` should to be called on it
+        before it can be used normally.
+        """
+
+        result = super().__deepcopy__(memo)
+
+        # note that the self.base_variant_raw object is *not* copied at
+        # this place because the attribute points to the same object
+        # as self.diag_layer_raw.
+        result.base_variant_raw = deepcopy(self.base_variant_raw, memo)
+
+        return result
+
+    @override
+    def _compute_value_inheritance(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._compute_value_inheritance(odxlinks)
+
+        self._diag_variables = NamedItemList(self._compute_available_diag_variables(odxlinks))
+        self._variable_groups = NamedItemList(self._compute_available_variable_groups(odxlinks))
+
+    def _compute_available_diag_variables(self,
+                                          odxlinks: OdxLinkDatabase) -> Iterable[DiagVariable]:
+
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[DiagVariable]:
+            if not hasattr(dl.diag_layer_raw, "diag_variables"):
+                return []
+
+            return dl.diag_layer_raw.diag_variables  # type: ignore[no-any-return]
+
+        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+            return parent_ref.not_inherited_variables
+
+        return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
+
+    def _compute_available_variable_groups(self,
+                                           odxlinks: OdxLinkDatabase) -> Iterable[VariableGroup]:
+
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[VariableGroup]:
+            if not hasattr(dl.diag_layer_raw, "variable_groups"):
+                return []
+
+            return dl.diag_layer_raw.variable_groups  # type: ignore[no-any-return]
+
+        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+            return []
+
+        return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)

odxtools/diaglayers/basevariantraw.py

@@ -0,0 +1,117 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Union
+from xml.etree import ElementTree
+
+from ..diagvariable import DiagVariable
+from ..dyndefinedspec import DynDefinedSpec
+from ..exceptions import odxraise
+from ..nameditemlist import NamedItemList
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..parentref import ParentRef
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
+from ..variablegroup import VariableGroup
+from .hierarchyelementraw import HierarchyElementRaw
+
+
+@dataclass
+class BaseVariantRaw(HierarchyElementRaw):
+    """This is a diagnostic layer for common functionality of an ECU
+    """
+
+    diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]]
+    variable_groups: NamedItemList[VariableGroup]
+    dyn_defined_spec: Optional[DynDefinedSpec]
+    # TODO: base_variant_pattern: Optional[BaseVariantPattern]
+    parent_refs: List[ParentRef]
+
+    @property
+    def diag_variables(self) -> NamedItemList[DiagVariable]:
+        return self._diag_variables
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "BaseVariantRaw":
+        kwargs = dataclass_fields_asdict(HierarchyElementRaw.from_et(et_element, doc_frags))
+
+        diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]] = []
+        if (dv_elems := et_element.find("DIAG-VARIABLES")) is not None:
+            for dv_proxy_elem in dv_elems:
+                dv_proxy: Union[OdxLinkRef, DiagVariable]
+                if dv_proxy_elem.tag == "DIAG-VARIABLE-REF":
+                    dv_proxy = OdxLinkRef.from_et(dv_proxy_elem, doc_frags)
+                elif dv_proxy_elem.tag == "DIAG-VARIABLE":
+                    dv_proxy = DiagVariable.from_et(dv_proxy_elem, doc_frags)
+                else:
+                    odxraise()
+
+                diag_variables_raw.append(dv_proxy)
+
+        variable_groups = NamedItemList([
+            VariableGroup.from_et(vg_elem, doc_frags)
+            for vg_elem in et_element.iterfind("VARIABLE-GROUPS/VARIABLE-GROUP")
+        ])
+
+        dyn_defined_spec = None
+        if (dds_elem := et_element.find("DYN-DEFINED-SPEC")) is not None:
+            dyn_defined_spec = DynDefinedSpec.from_et(dds_elem, doc_frags)
+
+        parent_refs = [
+            ParentRef.from_et(pr_elem, doc_frags)
+            for pr_elem in et_element.iterfind("PARENT-REFS/PARENT-REF")
+        ]
+
+        return BaseVariantRaw(
+            diag_variables_raw=diag_variables_raw,
+            variable_groups=variable_groups,
+            dyn_defined_spec=dyn_defined_spec,
+            parent_refs=parent_refs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = super()._build_odxlinks()
+
+        for dv_proxy in self.diag_variables_raw:
+            if not isinstance(dv_proxy, OdxLinkRef):
+                result.update(dv_proxy._build_odxlinks())
+
+        if self.dyn_defined_spec is not None:
+            result.update(self.dyn_defined_spec._build_odxlinks())
+
+        for parent_ref in self.parent_refs:
+            result.update(parent_ref._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        self._diag_variables: NamedItemList[DiagVariable] = NamedItemList()
+        for dv_proxy in self.diag_variables_raw:
+            if isinstance(dv_proxy, OdxLinkRef):
+                dv = odxlinks.resolve(dv_proxy, DiagVariable)
+            else:
+                dv_proxy._resolve_odxlinks(odxlinks)
+                dv = dv_proxy
+
+            self._diag_variables.append(dv)
+
+        if self.dyn_defined_spec is not None:
+            self.dyn_defined_spec._resolve_odxlinks(odxlinks)
+
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        for dv_proxy in self.diag_variables_raw:
+            if not isinstance(dv_proxy, OdxLinkRef):
+                dv_proxy._resolve_snrefs(context)
+
+        if self.dyn_defined_spec is not None:
+            self.dyn_defined_spec._resolve_snrefs(context)
+
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_snrefs(context)