odxtools 7.3.0__py3-none-any.whl → 7.4.1__py3-none-any.whl

odxtools/cli/_print_utils.py

@@ -235,7 +235,7 @@ def print_dl_metrics(variants: List[DiagLayer], print_fn: Callable[..., Any] = p
     type = []
     num_services = []
     num_dops = []
-    num_comparams = []
+    num_comparam_refs = []
     for variant in variants:
         assert isinstance(variant, DiagLayer)
         all_services: List[Union[DiagService, SingleEcuJob]] = sorted(
@@ -244,13 +244,13 @@ def print_dl_metrics(variants: List[DiagLayer], print_fn: Callable[..., Any] = p
         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_comparams.append(len(variant.comparams))
+        num_comparam_refs.append(len(variant.comparam_refs))
 
     table = {
         'Name': name,
         'Variant Type': type,
         'Number of Services': num_services,
         'Number of DOPs': num_dops,
-        'Number of communication parameters': num_comparams
+        'Number of communication parameters': num_comparam_refs
     }
     print_fn(tabulate(table, headers='keys', tablefmt='presto'))

odxtools/cli/browse.py

@@ -112,7 +112,8 @@ def prompt_single_parameter_value(parameter: Parameter) -> Optional[AtomicOdxTyp
 
 def encode_message_interactively(sub_service: Union[Request, Response],
                                  ask_user_confirmation: bool = False) -> None:
-    if not sys.__stdin__.isatty() or not sys.__stdout__.isatty():
+    if sys.__stdin__ is None or sys.__stdout__ is None or not sys.__stdin__.isatty(
+    ) or not sys.__stdout__.isatty():
         raise SystemError("This command can only be used in an interactive shell!")
     param_dict = sub_service.parameter_dict()
 
@@ -260,7 +261,8 @@ def encode_message_from_string_values(
 
 
 def browse(odxdb: Database) -> None:
-    if not sys.__stdin__.isatty() or not sys.__stdout__.isatty():
+    if sys.__stdin__ is None or sys.__stdout__ is None or not sys.__stdin__.isatty(
+    ) or not sys.__stdout__.isatty():
         raise SystemError("This command can only be used in an interactive shell!")
     dl_names = [dl.short_name for dl in odxdb.diag_layers]
     while True:

odxtools/cli/list.py

@@ -57,7 +57,7 @@ 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
-        comparams = dl.comparams
+        comparam_refs = dl.comparam_refs
 
         for proto in dl.protocols:
             if (can_rx_id := dl.get_can_receive_id(proto.short_name)) is not None:
@@ -103,12 +103,12 @@ 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  "))
 
-        if print_comparams and len(comparams) > 0:
+        if print_comparams and len(comparam_refs) > 0:
             rich.print("\n")
             rich.print(
                 f"The communication parameters of the {dl.variant_type.value} '{dl.short_name}' are: "
             )
-            for com_param in comparams:
+            for com_param in comparam_refs:
                 rich.print(f"  {com_param.short_name}: {com_param.value}")
 
 

odxtools/commrelation.py

@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: MIT
+import warnings
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from .description import Description
+from .diagcomm import DiagComm
+from .diagservice import DiagService
+from .exceptions import OdxWarning, odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .parameters.parameter import Parameter
+from .snrefcontext import SnRefContext
+
+
+class CommRelationValueType(Enum):
+    CURRENT = "CURRENT"
+    STORED = "STORED"
+    STATIC = "STATIC"
+    SUBSTITUTED = "SUBSTITUTED"
+
+
+@dataclass
+class CommRelation:
+    description: Optional[Description]
+    relation_type: str
+    diag_comm_ref: Optional[OdxLinkRef]
+    diag_comm_snref: Optional[str]
+    in_param_if_snref: Optional[str]
+    #in_param_if_snpathref: Optional[str] # TODO
+    out_param_if_snref: Optional[str]
+    #out_param_if_snpathref: Optional[str] # TODO
+    value_type_raw: Optional[CommRelationValueType]
+
+    @property
+    def diag_comm(self) -> DiagComm:
+        return self._diag_comm
+
+    @property
+    def in_param_if(self) -> Optional[Parameter]:
+        return self._in_param_if
+
+    @property
+    def out_param_if(self) -> Optional[Parameter]:
+        return self._out_param_if
+
+    @property
+    def value_type(self) -> CommRelationValueType:
+        if self.value_type_raw is None:
+            return CommRelationValueType.CURRENT
+
+        return self.value_type_raw
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "CommRelation":
+        description = Description.from_et(et_element.find("DESC"), doc_frags)
+        relation_type = odxrequire(et_element.findtext("RELATION-TYPE"))
+
+        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), doc_frags)
+        diag_comm_snref = None
+        if (diag_comm_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
+            diag_comm_snref = odxrequire(diag_comm_snref_elem.get("SHORT-NAME"))
+
+        in_param_if_snref = None
+        if (in_param_if_snref_elem := et_element.find("IN-PARAM-IF-SNREF")) is not None:
+            in_param_if_snref = odxrequire(in_param_if_snref_elem.get("SHORT-NAME"))
+
+        if et_element.find("IN-PARAM-IF-SNPATHREF") is not None:
+            warnings.warn("SNPATHREFs are not supported by odxtools yet", OdxWarning, stacklevel=1)
+
+        out_param_if_snref = None
+        if (out_param_if_snref_elem := et_element.find("OUT-PARAM-IF-SNREF")) is not None:
+            out_param_if_snref = odxrequire(out_param_if_snref_elem.get("SHORT-NAME"))
+
+        if et_element.find("OUT-PARAM-IF-SNPATHREF") is not None:
+            warnings.warn("SNPATHREFs are not supported by odxtools yet", OdxWarning, stacklevel=1)
+
+        value_type_raw = None
+        if (value_type_str := et_element.get("VALUE-TYPE")) is not None:
+            try:
+                value_type_raw = CommRelationValueType(value_type_str)
+            except ValueError:
+                odxraise(f"Encountered unknown comm relation value type '{value_type_str}'")
+
+        return CommRelation(
+            description=description,
+            relation_type=relation_type,
+            diag_comm_ref=diag_comm_ref,
+            diag_comm_snref=diag_comm_snref,
+            in_param_if_snref=in_param_if_snref,
+            out_param_if_snref=out_param_if_snref,
+            value_type_raw=value_type_raw)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.diag_comm_ref is not None:
+            self._diag_comm = odxlinks.resolve(self.diag_comm_ref, DiagComm)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        diag_layer = odxrequire(context.diag_layer)
+
+        if self.diag_comm_snref is not None:
+            self._diag_comm = resolve_snref(self.diag_comm_snref, diag_layer.diag_comms, DiagComm)
+
+        service = self.diag_comm
+        if not isinstance(service, DiagService):
+            odxraise(f"DIAG-VARIABLE references non-service {type(service).__name__} "
+                     f"diagnostic communication")
+
+        self._in_param_if = None
+        if self.in_param_if_snref is not None:
+            self._in_param_if = resolve_snref(self.in_param_if_snref,
+                                              odxrequire(service.request).parameters, Parameter)
+
+        self._out_param_if = None
+        if self.out_param_if_snref is not None:
+            self._out_param_if = resolve_snref(self.out_param_if_snref,
+                                               odxrequire(service.positive_responses[0]).parameters,
+                                               Parameter)

odxtools/comparaminstance.py

@@ -32,7 +32,7 @@ class ComparamInstance:
         spec_ref = odxrequire(OdxLinkRef.from_et(et_element, doc_frags))
 
         # ODX standard v2.0.0 defined only VALUE. ODX v2.0.1 decided
-        # to break things and change it to choice between SIMPLE-VALUE
+        # to break things and change it to a choice between SIMPLE-VALUE
         # and COMPLEX-VALUE
         value: Union[str, List[Union[str, ComplexValue]]]
         if et_element.find("VALUE") is not None:

odxtools/comparamspec.py

@@ -51,8 +51,7 @@ class ComparamSpec(IdentifiableElement):
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks: Dict[OdxLinkId, Any] = {}
-        if self.odx_id is not None:
-            odxlinks[self.odx_id] = self
+        odxlinks[self.odx_id] = self
 
         if self.admin_data is not None:
             odxlinks.update(self.admin_data._build_odxlinks())

odxtools/diaglayer.py

@@ -170,9 +170,9 @@ class DiagLayer:
         self._diag_comms = NamedItemList(diag_comms)
 
         # filter the diag comms for services and single-ECU jobs
-        services = [dc for dc in diag_comms if isinstance(dc, DiagService)]
+        diag_services = [dc for dc in diag_comms if isinstance(dc, DiagService)]
         single_ecu_jobs = [dc for dc in diag_comms if isinstance(dc, SingleEcuJob)]
-        self._services = NamedItemList(services)
+        self._diag_services = NamedItemList(diag_services)
         self._single_ecu_jobs = NamedItemList(single_ecu_jobs)
 
         global_negative_responses = self._compute_available_global_neg_responses(odxlinks)
@@ -289,7 +289,7 @@ class DiagLayer:
         # scheme, cf the docstring of
         # _compute_available_commmunication_parameters().
         #####
-        self._comparams = NamedItemList(self._compute_available_commmunication_parameters())
+        self._comparam_refs = NamedItemList(self._compute_available_commmunication_parameters())
 
         #####
         # resolve all SNREFs. TODO: We allow SNREFS to objects that
@@ -407,12 +407,17 @@ class DiagLayer:
 
     @property
     def services(self) -> NamedItemList[DiagService]:
+        """This property is an alias for `.diag_services`"""
+        return self._diag_services
+
+    @property
+    def diag_services(self) -> NamedItemList[DiagService]:
         """All diagnostic services applicable to this DiagLayer
 
         This is a subset of all diagnostic communication
         primitives. All references are resolved in the list returned.
         """
-        return self._services
+        return self._diag_services
 
     @property
     def single_ecu_jobs(self) -> NamedItemList[SingleEcuJob]:
@@ -707,20 +712,20 @@ class DiagLayer:
                 com_params_dict[(cp.spec_ref.ref_id, cp.protocol_snref)] = cp
 
         # finally, handle the locally defined communication parameters
-        for cp in self.diag_layer_raw.comparams:
+        for cp in self.diag_layer_raw.comparam_refs:
             com_params_dict[(cp.spec_ref.ref_id, cp.protocol_snref)] = cp
 
         return list(com_params_dict.values())
 
     @property
-    def comparams(self) -> NamedItemList[ComparamInstance]:
+    def comparam_refs(self) -> NamedItemList[ComparamInstance]:
         """All communication parameters applicable to this DiagLayer
 
         Note that, although communication parameters use inheritance,
         it is *not* the "value inheritance" scheme used by e.g. DOPs,
         tables, state charts, ...
         """
-        return self._comparams
+        return self._comparam_refs
 
     @cached_property
     def protocols(self) -> NamedItemList["DiagLayer"]:
@@ -757,7 +762,7 @@ class DiagLayer:
             protocol_name = protocol
 
         # determine the set of applicable communication parameters
-        cps = [cp for cp in self.comparams if cp.short_name == cp_short_name]
+        cps = [cp for cp in self.comparam_refs if cp.short_name == cp_short_name]
         if protocol_name is not None:
             cps = [cp for cp in cps if cp.protocol_snref in (None, protocol_name)]
 

odxtools/diaglayerraw.py

@@ -14,6 +14,8 @@ from .diagcomm import DiagComm
 from .diagdatadictionaryspec import DiagDataDictionarySpec
 from .diaglayertype import DiagLayerType
 from .diagservice import DiagService
+from .diagvariable import DiagVariable
+from .dyndefinedspec import DynDefinedSpec
 from .ecuvariantpattern import EcuVariantPattern
 from .element import IdentifiableElement
 from .exceptions import odxassert, odxraise, odxrequire
@@ -29,6 +31,7 @@ from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .statechart import StateChart
 from .utils import dataclass_fields_asdict
+from .variablegroup import VariableGroup
 
 
 @dataclass
@@ -44,7 +47,7 @@ class DiagLayerRaw(IdentifiableElement):
     company_datas: NamedItemList[CompanyData]
     functional_classes: NamedItemList[FunctionalClass]
     diag_data_dictionary_spec: Optional[DiagDataDictionarySpec]
-    diag_comms: List[Union[OdxLinkRef, DiagComm]]
+    diag_comms_raw: List[Union[OdxLinkRef, DiagComm]]
     requests: NamedItemList[Request]
     positive_responses: NamedItemList[Response]
     negative_responses: NamedItemList[Response]
@@ -59,15 +62,36 @@ class DiagLayerRaw(IdentifiableElement):
     # these attributes are only defined for some kinds of diag layers!
     # TODO: make a proper class hierarchy!
     parent_refs: List[ParentRef]
-    comparams: List[ComparamInstance]
+    comparam_refs: List[ComparamInstance]
     ecu_variant_patterns: List[EcuVariantPattern]
     comparam_spec_ref: Optional[OdxLinkRef]
     prot_stack_snref: Optional[str]
-    # diag_variables: List[DiagVariable] # TODO
-    # diag_variable_groups: List[DiagVariableGroup] # TODO
-    # dyn_defined_spec: Optional[DynDefinedSpec] # TODO
+    diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]]
+    variable_groups: NamedItemList[VariableGroup]
+    dyn_defined_spec: Optional[DynDefinedSpec]
     # base_variant_patterns: List[EcuVariantPattern] # TODO
 
+    @property
+    def diag_comms(self) -> NamedItemList[DiagComm]:
+        return self._diag_comms
+
+    @property
+    def diag_services(self) -> NamedItemList[DiagService]:
+        return self._diag_services
+
+    @property
+    def services(self) -> NamedItemList[DiagService]:
+        """This property is an alias for `.diag_services`"""
+        return self._diag_services
+
+    @property
+    def single_ecu_jobs(self) -> NamedItemList[SingleEcuJob]:
+        return self._single_ecu_jobs
+
+    @property
+    def diag_variables(self) -> NamedItemList[DiagVariable]:
+        return self._diag_variables
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagLayerRaw":
         try:
@@ -101,7 +125,7 @@ class DiagLayerRaw(IdentifiableElement):
         if (ddds_elem := et_element.find("DIAG-DATA-DICTIONARY-SPEC")) is not None:
             diag_data_dictionary_spec = DiagDataDictionarySpec.from_et(ddds_elem, doc_frags)
 
-        diag_comms: List[Union[OdxLinkRef, DiagComm]] = []
+        diag_comms_raw: List[Union[OdxLinkRef, DiagComm]] = []
         if (dc_elems := et_element.find("DIAG-COMMS")) is not None:
             for dc_proxy_elem in dc_elems:
                 dc: Union[OdxLinkRef, DiagComm]
@@ -113,7 +137,7 @@ class DiagLayerRaw(IdentifiableElement):
                     odxassert(dc_proxy_elem.tag == "SINGLE-ECU-JOB")
                     dc = SingleEcuJob.from_et(dc_proxy_elem, doc_frags)
 
-                diag_comms.append(dc)
+                diag_comms_raw.append(dc)
 
         requests = NamedItemList([
             Request.from_et(rq_elem, doc_frags)
@@ -159,7 +183,7 @@ class DiagLayerRaw(IdentifiableElement):
             for pr_el in et_element.iterfind("PARENT-REFS/PARENT-REF")
         ]
 
-        comparams = [
+        comparam_refs = [
             ComparamInstance.from_et(el, doc_frags)
             for el in et_element.iterfind("COMPARAM-REFS/COMPARAM-REF")
         ]
@@ -178,6 +202,29 @@ class DiagLayerRaw(IdentifiableElement):
         if (prot_stack_snref_elem := et_element.find("PROT-STACK-SNREF")) is not None:
             prot_stack_snref = odxrequire(prot_stack_snref_elem.get("SHORT-NAME"))
 
+        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 tags may only contain "
+                             "DIAG-VARIABLE and DIAG-VARIABLE-REF subtags")
+
+                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)
+
         # Create DiagLayer
         return DiagLayerRaw(
             variant_type=variant_type,
@@ -185,7 +232,7 @@ class DiagLayerRaw(IdentifiableElement):
             company_datas=NamedItemList(company_datas),
             functional_classes=NamedItemList(functional_classes),
             diag_data_dictionary_spec=diag_data_dictionary_spec,
-            diag_comms=diag_comms,
+            diag_comms_raw=diag_comms_raw,
             requests=requests,
             positive_responses=positive_responses,
             negative_responses=negative_responses,
@@ -195,10 +242,13 @@ class DiagLayerRaw(IdentifiableElement):
             additional_audiences=NamedItemList(additional_audiences),
             sdgs=sdgs,
             parent_refs=parent_refs,
-            comparams=comparams,
+            comparam_refs=comparam_refs,
             ecu_variant_patterns=ecu_variant_patterns,
             comparam_spec_ref=comparam_spec_ref,
             prot_stack_snref=prot_stack_snref,
+            diag_variables_raw=diag_variables_raw,
+            variable_groups=variable_groups,
+            dyn_defined_spec=dyn_defined_spec,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -214,10 +264,10 @@ class DiagLayerRaw(IdentifiableElement):
             odxlinks.update(company_data._build_odxlinks())
         for functional_class in self.functional_classes:
             odxlinks.update(functional_class._build_odxlinks())
-        for diag_comm in self.diag_comms:
-            if isinstance(diag_comm, OdxLinkRef):
+        for dc_proxy in self.diag_comms_raw:
+            if isinstance(dc_proxy, OdxLinkRef):
                 continue
-            odxlinks.update(diag_comm._build_odxlinks())
+            odxlinks.update(dc_proxy._build_odxlinks())
         for request in self.requests:
             odxlinks.update(request._build_odxlinks())
         for positive_response in self.positive_responses:
@@ -234,8 +284,13 @@ class DiagLayerRaw(IdentifiableElement):
             odxlinks.update(sdg._build_odxlinks())
         for parent_ref in self.parent_refs:
             odxlinks.update(parent_ref._build_odxlinks())
-        for comparam in self.comparams:
+        for comparam in self.comparam_refs:
             odxlinks.update(comparam._build_odxlinks())
+        for dv_proxy in self.diag_variables_raw:
+            if not isinstance(dv_proxy, OdxLinkRef):
+                odxlinks.update(dv_proxy._build_odxlinks())
+        if self.dyn_defined_spec is not None:
+            odxlinks.update(self.dyn_defined_spec._build_odxlinks())
 
         return odxlinks
 
@@ -258,10 +313,28 @@ class DiagLayerRaw(IdentifiableElement):
             company_data._resolve_odxlinks(odxlinks)
         for functional_class in self.functional_classes:
             functional_class._resolve_odxlinks(odxlinks)
-        for diag_comm in self.diag_comms:
-            if isinstance(diag_comm, OdxLinkRef):
-                continue
-            diag_comm._resolve_odxlinks(odxlinks)
+
+        # resolve references to diagnostic communication objects and
+        # separate them into services and single-ecu jobs
+        self._diag_comms = NamedItemList[DiagComm]()
+        self._diag_services = NamedItemList[DiagService]()
+        self._single_ecu_jobs = NamedItemList[SingleEcuJob]()
+        for dc_proxy in self.diag_comms_raw:
+            if isinstance(dc_proxy, OdxLinkRef):
+                dc = odxlinks.resolve(dc_proxy, DiagComm)
+            else:
+                dc = dc_proxy
+                dc._resolve_odxlinks(odxlinks)
+
+            self._diag_comms.append(dc)
+
+            if isinstance(dc, DiagService):
+                self._diag_services.append(dc)
+            elif isinstance(dc, SingleEcuJob):
+                self._single_ecu_jobs.append(dc)
+            else:
+                odxraise()
+
         for request in self.requests:
             request._resolve_odxlinks(odxlinks)
         for positive_response in self.positive_responses:
@@ -278,9 +351,22 @@ class DiagLayerRaw(IdentifiableElement):
             sdg._resolve_odxlinks(odxlinks)
         for parent_ref in self.parent_refs:
             parent_ref._resolve_odxlinks(odxlinks)
-        for comparam in self.comparams:
+        for comparam in self.comparam_refs:
             comparam._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)
+
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         self._prot_stack: Optional[ProtStack] = None
         if self.prot_stack_snref is not None:
@@ -299,10 +385,10 @@ class DiagLayerRaw(IdentifiableElement):
             company_data._resolve_snrefs(context)
         for functional_class in self.functional_classes:
             functional_class._resolve_snrefs(context)
-        for diag_comm in self.diag_comms:
-            if isinstance(diag_comm, OdxLinkRef):
+        for dc_proxy in self.diag_comms_raw:
+            if isinstance(dc_proxy, OdxLinkRef):
                 continue
-            diag_comm._resolve_snrefs(context)
+            dc_proxy._resolve_snrefs(context)
         for request in self.requests:
             request._resolve_snrefs(context)
         for positive_response in self.positive_responses:
@@ -319,9 +405,16 @@ class DiagLayerRaw(IdentifiableElement):
             sdg._resolve_snrefs(context)
         for parent_ref in self.parent_refs:
             parent_ref._resolve_snrefs(context)
-        for comparam in self.comparams:
+        for comparam in self.comparam_refs:
             comparam._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)
+
     @property
     def comparam_spec(self) -> Optional[Union[ComparamSpec, ComparamSubset]]:
         return self._comparam_spec

odxtools/diagvariable.py

@@ -0,0 +1,104 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from .admindata import AdminData
+from .commrelation import CommRelation
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxtypes import odxstr_to_bool
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .swvariable import SwVariable
+from .utils import dataclass_fields_asdict
+from .variablegroup import VariableGroup
+
+
+@dataclass
+class DiagVariable(IdentifiableElement):
+    """Representation of a diagnostic variable
+    """
+
+    admin_data: Optional[AdminData]
+    variable_group_ref: OdxLinkRef
+    sw_variables: List[SwVariable]
+    comm_relations: List[CommRelation]
+    #snref_to_tablerow: Optional[SnrefToTableRow] # TODO
+    sdgs: List[SpecialDataGroup]
+    is_read_before_write_raw: Optional[bool]
+
+    @property
+    def variable_group(self) -> VariableGroup:
+        return self._variable_group
+
+    @property
+    def is_read_before_write(self) -> bool:
+        return self.is_read_before_write_raw is True
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagVariable":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        variable_group_ref = odxrequire(
+            OdxLinkRef.from_et(et_element.find("VARIABLE-GROUP-REF"), doc_frags))
+        sw_variables = NamedItemList([
+            SwVariable.from_et(swv_elem, doc_frags)
+            for swv_elem in et_element.iterfind("SW-VARIABLES/SW-VARIABLE")
+        ])
+        comm_relations = [
+            CommRelation.from_et(cr_elem, doc_frags)
+            for cr_elem in et_element.iterfind("COMM-RELATIONS/COMM-RELATION")
+        ]
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
+        is_read_before_write_raw = odxstr_to_bool(et_element.get("IS-READ-BEFORE-WRITE"))
+
+        return DiagVariable(
+            admin_data=admin_data,
+            variable_group_ref=variable_group_ref,
+            sw_variables=sw_variables,
+            comm_relations=comm_relations,
+            sdgs=sdgs,
+            is_read_before_write_raw=is_read_before_write_raw,
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {self.odx_id: self}
+
+        if self.admin_data is not None:
+            result.update(self.admin_data._build_odxlinks())
+
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        for cr in self.comm_relations:
+            result.update(cr._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._variable_group = odxlinks.resolve(self.variable_group_ref, VariableGroup)
+
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+        for cr in self.comm_relations:
+            cr._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(context)
+
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)
+
+        for cr in self.comm_relations:
+            cr._resolve_snrefs(context)